sessions_test.go

// Code generated by Fern. DO NOT EDIT.

package api

import (
	json "encoding/json"
	assert "github.com/stretchr/testify/assert"
	require "github.com/stretchr/testify/require"
	testing "testing"
	time "time"
)

func TestSettersCreateSessionDto(t *testing.T) {
	t.Run("SetName", func(t *testing.T) {
		obj := &CreateSessionDto{}
		var fernTestValueName *string
		obj.SetName(fernTestValueName)
		assert.Equal(t, fernTestValueName, obj.Name)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStatus", func(t *testing.T) {
		obj := &CreateSessionDto{}
		var fernTestValueStatus *CreateSessionDtoStatus
		obj.SetStatus(fernTestValueStatus)
		assert.Equal(t, fernTestValueStatus, obj.Status)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetExpirationSeconds", func(t *testing.T) {
		obj := &CreateSessionDto{}
		var fernTestValueExpirationSeconds *float64
		obj.SetExpirationSeconds(fernTestValueExpirationSeconds)
		assert.Equal(t, fernTestValueExpirationSeconds, obj.ExpirationSeconds)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetAssistantId", func(t *testing.T) {
		obj := &CreateSessionDto{}
		var fernTestValueAssistantId *string
		obj.SetAssistantId(fernTestValueAssistantId)
		assert.Equal(t, fernTestValueAssistantId, obj.AssistantId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetAssistant", func(t *testing.T) {
		obj := &CreateSessionDto{}
		var fernTestValueAssistant *CreateAssistantDto
		obj.SetAssistant(fernTestValueAssistant)
		assert.Equal(t, fernTestValueAssistant, obj.Assistant)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetAssistantOverrides", func(t *testing.T) {
		obj := &CreateSessionDto{}
		var fernTestValueAssistantOverrides *AssistantOverrides
		obj.SetAssistantOverrides(fernTestValueAssistantOverrides)
		assert.Equal(t, fernTestValueAssistantOverrides, obj.AssistantOverrides)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSquadId", func(t *testing.T) {
		obj := &CreateSessionDto{}
		var fernTestValueSquadId *string
		obj.SetSquadId(fernTestValueSquadId)
		assert.Equal(t, fernTestValueSquadId, obj.SquadId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSquad", func(t *testing.T) {
		obj := &CreateSessionDto{}
		var fernTestValueSquad *CreateSquadDto
		obj.SetSquad(fernTestValueSquad)
		assert.Equal(t, fernTestValueSquad, obj.Squad)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMessages", func(t *testing.T) {
		obj := &CreateSessionDto{}
		var fernTestValueMessages []*CreateSessionDtoMessagesItem
		obj.SetMessages(fernTestValueMessages)
		assert.Equal(t, fernTestValueMessages, obj.Messages)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCustomer", func(t *testing.T) {
		obj := &CreateSessionDto{}
		var fernTestValueCustomer *CreateCustomerDto
		obj.SetCustomer(fernTestValueCustomer)
		assert.Equal(t, fernTestValueCustomer, obj.Customer)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCustomerId", func(t *testing.T) {
		obj := &CreateSessionDto{}
		var fernTestValueCustomerId *string
		obj.SetCustomerId(fernTestValueCustomerId)
		assert.Equal(t, fernTestValueCustomerId, obj.CustomerId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetPhoneNumberId", func(t *testing.T) {
		obj := &CreateSessionDto{}
		var fernTestValuePhoneNumberId *string
		obj.SetPhoneNumberId(fernTestValuePhoneNumberId)
		assert.Equal(t, fernTestValuePhoneNumberId, obj.PhoneNumberId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetPhoneNumber", func(t *testing.T) {
		obj := &CreateSessionDto{}
		var fernTestValuePhoneNumber *ImportTwilioPhoneNumberDto
		obj.SetPhoneNumber(fernTestValuePhoneNumber)
		assert.Equal(t, fernTestValuePhoneNumber, obj.PhoneNumber)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitCreateSessionDto(t *testing.T) {
	t.Run("SetName_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDto{}
		var fernTestValueName *string

		// Act
		obj.SetName(fernTestValueName)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetStatus_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDto{}
		var fernTestValueStatus *CreateSessionDtoStatus

		// Act
		obj.SetStatus(fernTestValueStatus)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetExpirationSeconds_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDto{}
		var fernTestValueExpirationSeconds *float64

		// Act
		obj.SetExpirationSeconds(fernTestValueExpirationSeconds)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetAssistantId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDto{}
		var fernTestValueAssistantId *string

		// Act
		obj.SetAssistantId(fernTestValueAssistantId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetAssistant_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDto{}
		var fernTestValueAssistant *CreateAssistantDto

		// Act
		obj.SetAssistant(fernTestValueAssistant)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetAssistantOverrides_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDto{}
		var fernTestValueAssistantOverrides *AssistantOverrides

		// Act
		obj.SetAssistantOverrides(fernTestValueAssistantOverrides)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetSquadId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDto{}
		var fernTestValueSquadId *string

		// Act
		obj.SetSquadId(fernTestValueSquadId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetSquad_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDto{}
		var fernTestValueSquad *CreateSquadDto

		// Act
		obj.SetSquad(fernTestValueSquad)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetMessages_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDto{}
		var fernTestValueMessages []*CreateSessionDtoMessagesItem

		// Act
		obj.SetMessages(fernTestValueMessages)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetCustomer_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDto{}
		var fernTestValueCustomer *CreateCustomerDto

		// Act
		obj.SetCustomer(fernTestValueCustomer)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetCustomerId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDto{}
		var fernTestValueCustomerId *string

		// Act
		obj.SetCustomerId(fernTestValueCustomerId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetPhoneNumberId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDto{}
		var fernTestValuePhoneNumberId *string

		// Act
		obj.SetPhoneNumberId(fernTestValuePhoneNumberId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetPhoneNumber_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDto{}
		var fernTestValuePhoneNumber *ImportTwilioPhoneNumberDto

		// Act
		obj.SetPhoneNumber(fernTestValuePhoneNumber)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

}

func TestSettersDeleteSessionsRequest(t *testing.T) {
	t.Run("SetId", func(t *testing.T) {
		obj := &DeleteSessionsRequest{}
		var fernTestValueId string
		obj.SetId(fernTestValueId)
		assert.Equal(t, fernTestValueId, obj.Id)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitDeleteSessionsRequest(t *testing.T) {
	t.Run("SetId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DeleteSessionsRequest{}
		var fernTestValueId string

		// Act
		obj.SetId(fernTestValueId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

}

func TestSettersGetSessionsRequest(t *testing.T) {
	t.Run("SetId", func(t *testing.T) {
		obj := &GetSessionsRequest{}
		var fernTestValueId string
		obj.SetId(fernTestValueId)
		assert.Equal(t, fernTestValueId, obj.Id)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitGetSessionsRequest(t *testing.T) {
	t.Run("SetId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GetSessionsRequest{}
		var fernTestValueId string

		// Act
		obj.SetId(fernTestValueId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

}

func TestSettersListSessionsRequest(t *testing.T) {
	t.Run("SetId", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueId *string
		obj.SetId(fernTestValueId)
		assert.Equal(t, fernTestValueId, obj.Id)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetName", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueName *string
		obj.SetName(fernTestValueName)
		assert.Equal(t, fernTestValueName, obj.Name)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetAssistantId", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueAssistantId *string
		obj.SetAssistantId(fernTestValueAssistantId)
		assert.Equal(t, fernTestValueAssistantId, obj.AssistantId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetAssistantIdAny", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueAssistantIdAny *string
		obj.SetAssistantIdAny(fernTestValueAssistantIdAny)
		assert.Equal(t, fernTestValueAssistantIdAny, obj.AssistantIdAny)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSquadId", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueSquadId *string
		obj.SetSquadId(fernTestValueSquadId)
		assert.Equal(t, fernTestValueSquadId, obj.SquadId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetWorkflowId", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueWorkflowId *string
		obj.SetWorkflowId(fernTestValueWorkflowId)
		assert.Equal(t, fernTestValueWorkflowId, obj.WorkflowId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetNumberE164CheckEnabled", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueNumberE164CheckEnabled *bool
		obj.SetNumberE164CheckEnabled(fernTestValueNumberE164CheckEnabled)
		assert.Equal(t, fernTestValueNumberE164CheckEnabled, obj.NumberE164CheckEnabled)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetExtension", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueExtension *string
		obj.SetExtension(fernTestValueExtension)
		assert.Equal(t, fernTestValueExtension, obj.Extension)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetAssistantOverrides", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueAssistantOverrides *string
		obj.SetAssistantOverrides(fernTestValueAssistantOverrides)
		assert.Equal(t, fernTestValueAssistantOverrides, obj.AssistantOverrides)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetNumber", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueNumber *string
		obj.SetNumber(fernTestValueNumber)
		assert.Equal(t, fernTestValueNumber, obj.Number)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSipUri", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueSipUri *string
		obj.SetSipUri(fernTestValueSipUri)
		assert.Equal(t, fernTestValueSipUri, obj.SipUri)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetEmail", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueEmail *string
		obj.SetEmail(fernTestValueEmail)
		assert.Equal(t, fernTestValueEmail, obj.Email)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetExternalId", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueExternalId *string
		obj.SetExternalId(fernTestValueExternalId)
		assert.Equal(t, fernTestValueExternalId, obj.ExternalId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCustomerNumberAny", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueCustomerNumberAny *string
		obj.SetCustomerNumberAny(fernTestValueCustomerNumberAny)
		assert.Equal(t, fernTestValueCustomerNumberAny, obj.CustomerNumberAny)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetPhoneNumberId", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValuePhoneNumberId *string
		obj.SetPhoneNumberId(fernTestValuePhoneNumberId)
		assert.Equal(t, fernTestValuePhoneNumberId, obj.PhoneNumberId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetPhoneNumberIdAny", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValuePhoneNumberIdAny []*string
		obj.SetPhoneNumberIdAny(fernTestValuePhoneNumberIdAny)
		assert.Equal(t, fernTestValuePhoneNumberIdAny, obj.PhoneNumberIdAny)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetPage", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValuePage *float64
		obj.SetPage(fernTestValuePage)
		assert.Equal(t, fernTestValuePage, obj.Page)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSortOrder", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueSortOrder *ListSessionsRequestSortOrder
		obj.SetSortOrder(fernTestValueSortOrder)
		assert.Equal(t, fernTestValueSortOrder, obj.SortOrder)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetLimit", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueLimit *float64
		obj.SetLimit(fernTestValueLimit)
		assert.Equal(t, fernTestValueLimit, obj.Limit)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCreatedAtGt", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueCreatedAtGt *time.Time
		obj.SetCreatedAtGt(fernTestValueCreatedAtGt)
		assert.Equal(t, fernTestValueCreatedAtGt, obj.CreatedAtGt)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCreatedAtLt", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueCreatedAtLt *time.Time
		obj.SetCreatedAtLt(fernTestValueCreatedAtLt)
		assert.Equal(t, fernTestValueCreatedAtLt, obj.CreatedAtLt)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCreatedAtGe", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueCreatedAtGe *time.Time
		obj.SetCreatedAtGe(fernTestValueCreatedAtGe)
		assert.Equal(t, fernTestValueCreatedAtGe, obj.CreatedAtGe)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCreatedAtLe", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueCreatedAtLe *time.Time
		obj.SetCreatedAtLe(fernTestValueCreatedAtLe)
		assert.Equal(t, fernTestValueCreatedAtLe, obj.CreatedAtLe)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetUpdatedAtGt", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueUpdatedAtGt *time.Time
		obj.SetUpdatedAtGt(fernTestValueUpdatedAtGt)
		assert.Equal(t, fernTestValueUpdatedAtGt, obj.UpdatedAtGt)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetUpdatedAtLt", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueUpdatedAtLt *time.Time
		obj.SetUpdatedAtLt(fernTestValueUpdatedAtLt)
		assert.Equal(t, fernTestValueUpdatedAtLt, obj.UpdatedAtLt)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetUpdatedAtGe", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueUpdatedAtGe *time.Time
		obj.SetUpdatedAtGe(fernTestValueUpdatedAtGe)
		assert.Equal(t, fernTestValueUpdatedAtGe, obj.UpdatedAtGe)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetUpdatedAtLe", func(t *testing.T) {
		obj := &ListSessionsRequest{}
		var fernTestValueUpdatedAtLe *time.Time
		obj.SetUpdatedAtLe(fernTestValueUpdatedAtLe)
		assert.Equal(t, fernTestValueUpdatedAtLe, obj.UpdatedAtLe)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitListSessionsRequest(t *testing.T) {
	t.Run("SetId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueId *string

		// Act
		obj.SetId(fernTestValueId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetName_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueName *string

		// Act
		obj.SetName(fernTestValueName)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetAssistantId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueAssistantId *string

		// Act
		obj.SetAssistantId(fernTestValueAssistantId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetAssistantIdAny_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueAssistantIdAny *string

		// Act
		obj.SetAssistantIdAny(fernTestValueAssistantIdAny)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetSquadId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueSquadId *string

		// Act
		obj.SetSquadId(fernTestValueSquadId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetWorkflowId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueWorkflowId *string

		// Act
		obj.SetWorkflowId(fernTestValueWorkflowId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetNumberE164CheckEnabled_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueNumberE164CheckEnabled *bool

		// Act
		obj.SetNumberE164CheckEnabled(fernTestValueNumberE164CheckEnabled)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetExtension_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueExtension *string

		// Act
		obj.SetExtension(fernTestValueExtension)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetAssistantOverrides_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueAssistantOverrides *string

		// Act
		obj.SetAssistantOverrides(fernTestValueAssistantOverrides)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetNumber_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueNumber *string

		// Act
		obj.SetNumber(fernTestValueNumber)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetSipUri_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueSipUri *string

		// Act
		obj.SetSipUri(fernTestValueSipUri)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetEmail_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueEmail *string

		// Act
		obj.SetEmail(fernTestValueEmail)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetExternalId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueExternalId *string

		// Act
		obj.SetExternalId(fernTestValueExternalId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetCustomerNumberAny_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueCustomerNumberAny *string

		// Act
		obj.SetCustomerNumberAny(fernTestValueCustomerNumberAny)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetPhoneNumberId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValuePhoneNumberId *string

		// Act
		obj.SetPhoneNumberId(fernTestValuePhoneNumberId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetPhoneNumberIdAny_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValuePhoneNumberIdAny []*string

		// Act
		obj.SetPhoneNumberIdAny(fernTestValuePhoneNumberIdAny)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetPage_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValuePage *float64

		// Act
		obj.SetPage(fernTestValuePage)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetSortOrder_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueSortOrder *ListSessionsRequestSortOrder

		// Act
		obj.SetSortOrder(fernTestValueSortOrder)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetLimit_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueLimit *float64

		// Act
		obj.SetLimit(fernTestValueLimit)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetCreatedAtGt_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueCreatedAtGt *time.Time

		// Act
		obj.SetCreatedAtGt(fernTestValueCreatedAtGt)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetCreatedAtLt_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueCreatedAtLt *time.Time

		// Act
		obj.SetCreatedAtLt(fernTestValueCreatedAtLt)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetCreatedAtGe_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueCreatedAtGe *time.Time

		// Act
		obj.SetCreatedAtGe(fernTestValueCreatedAtGe)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetCreatedAtLe_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueCreatedAtLe *time.Time

		// Act
		obj.SetCreatedAtLe(fernTestValueCreatedAtLe)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetUpdatedAtGt_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueUpdatedAtGt *time.Time

		// Act
		obj.SetUpdatedAtGt(fernTestValueUpdatedAtGt)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetUpdatedAtLt_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueUpdatedAtLt *time.Time

		// Act
		obj.SetUpdatedAtLt(fernTestValueUpdatedAtLt)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetUpdatedAtGe_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueUpdatedAtGe *time.Time

		// Act
		obj.SetUpdatedAtGe(fernTestValueUpdatedAtGe)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetUpdatedAtLe_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListSessionsRequest{}
		var fernTestValueUpdatedAtLe *time.Time

		// Act
		obj.SetUpdatedAtLe(fernTestValueUpdatedAtLe)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

}

func TestSettersSession(t *testing.T) {
	t.Run("SetId", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueId string
		obj.SetId(fernTestValueId)
		assert.Equal(t, fernTestValueId, obj.Id)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetOrgId", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueOrgId string
		obj.SetOrgId(fernTestValueOrgId)
		assert.Equal(t, fernTestValueOrgId, obj.OrgId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCreatedAt", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueCreatedAt time.Time
		obj.SetCreatedAt(fernTestValueCreatedAt)
		assert.Equal(t, fernTestValueCreatedAt, obj.CreatedAt)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetUpdatedAt", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueUpdatedAt time.Time
		obj.SetUpdatedAt(fernTestValueUpdatedAt)
		assert.Equal(t, fernTestValueUpdatedAt, obj.UpdatedAt)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCost", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueCost *float64
		obj.SetCost(fernTestValueCost)
		assert.Equal(t, fernTestValueCost, obj.Cost)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCosts", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueCosts []*SessionCostsItem
		obj.SetCosts(fernTestValueCosts)
		assert.Equal(t, fernTestValueCosts, obj.Costs)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetName", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueName *string
		obj.SetName(fernTestValueName)
		assert.Equal(t, fernTestValueName, obj.Name)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStatus", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueStatus *SessionStatus
		obj.SetStatus(fernTestValueStatus)
		assert.Equal(t, fernTestValueStatus, obj.Status)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetExpirationSeconds", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueExpirationSeconds *float64
		obj.SetExpirationSeconds(fernTestValueExpirationSeconds)
		assert.Equal(t, fernTestValueExpirationSeconds, obj.ExpirationSeconds)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetAssistantId", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueAssistantId *string
		obj.SetAssistantId(fernTestValueAssistantId)
		assert.Equal(t, fernTestValueAssistantId, obj.AssistantId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetAssistant", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueAssistant *CreateAssistantDto
		obj.SetAssistant(fernTestValueAssistant)
		assert.Equal(t, fernTestValueAssistant, obj.Assistant)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetAssistantOverrides", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueAssistantOverrides *AssistantOverrides
		obj.SetAssistantOverrides(fernTestValueAssistantOverrides)
		assert.Equal(t, fernTestValueAssistantOverrides, obj.AssistantOverrides)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSquadId", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueSquadId *string
		obj.SetSquadId(fernTestValueSquadId)
		assert.Equal(t, fernTestValueSquadId, obj.SquadId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSquad", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueSquad *CreateSquadDto
		obj.SetSquad(fernTestValueSquad)
		assert.Equal(t, fernTestValueSquad, obj.Squad)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMessages", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueMessages []*SessionMessagesItem
		obj.SetMessages(fernTestValueMessages)
		assert.Equal(t, fernTestValueMessages, obj.Messages)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCustomer", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueCustomer *CreateCustomerDto
		obj.SetCustomer(fernTestValueCustomer)
		assert.Equal(t, fernTestValueCustomer, obj.Customer)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCustomerId", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueCustomerId *string
		obj.SetCustomerId(fernTestValueCustomerId)
		assert.Equal(t, fernTestValueCustomerId, obj.CustomerId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetPhoneNumberId", func(t *testing.T) {
		obj := &Session{}
		var fernTestValuePhoneNumberId *string
		obj.SetPhoneNumberId(fernTestValuePhoneNumberId)
		assert.Equal(t, fernTestValuePhoneNumberId, obj.PhoneNumberId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetPhoneNumber", func(t *testing.T) {
		obj := &Session{}
		var fernTestValuePhoneNumber *ImportTwilioPhoneNumberDto
		obj.SetPhoneNumber(fernTestValuePhoneNumber)
		assert.Equal(t, fernTestValuePhoneNumber, obj.PhoneNumber)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetArtifact", func(t *testing.T) {
		obj := &Session{}
		var fernTestValueArtifact *Artifact
		obj.SetArtifact(fernTestValueArtifact)
		assert.Equal(t, fernTestValueArtifact, obj.Artifact)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersSession(t *testing.T) {
	t.Run("GetId", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected string
		obj.Id = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetId(), "getter should return the property value")
	})

	t.Run("GetId_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetId() // Should return zero value
	})

	t.Run("GetOrgId", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected string
		obj.OrgId = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetOrgId(), "getter should return the property value")
	})

	t.Run("GetOrgId_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetOrgId() // Should return zero value
	})

	t.Run("GetCreatedAt", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected time.Time
		obj.CreatedAt = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetCreatedAt(), "getter should return the property value")
	})

	t.Run("GetCreatedAt_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetCreatedAt() // Should return zero value
	})

	t.Run("GetUpdatedAt", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected time.Time
		obj.UpdatedAt = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetUpdatedAt(), "getter should return the property value")
	})

	t.Run("GetUpdatedAt_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetUpdatedAt() // Should return zero value
	})

	t.Run("GetCost", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected *float64
		obj.Cost = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetCost(), "getter should return the property value")
	})

	t.Run("GetCost_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.Cost = nil

		// Act & Assert
		assert.Nil(t, obj.GetCost(), "getter should return nil when property is nil")
	})

	t.Run("GetCost_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetCost() // Should return zero value
	})

	t.Run("GetCosts", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected []*SessionCostsItem
		obj.Costs = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetCosts(), "getter should return the property value")
	})

	t.Run("GetCosts_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.Costs = nil

		// Act & Assert
		assert.Nil(t, obj.GetCosts(), "getter should return nil when property is nil")
	})

	t.Run("GetCosts_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetCosts() // Should return zero value
	})

	t.Run("GetName", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected *string
		obj.Name = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetName(), "getter should return the property value")
	})

	t.Run("GetName_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.Name = nil

		// Act & Assert
		assert.Nil(t, obj.GetName(), "getter should return nil when property is nil")
	})

	t.Run("GetName_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetName() // Should return zero value
	})

	t.Run("GetStatus", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected *SessionStatus
		obj.Status = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetStatus(), "getter should return the property value")
	})

	t.Run("GetStatus_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.Status = nil

		// Act & Assert
		assert.Nil(t, obj.GetStatus(), "getter should return nil when property is nil")
	})

	t.Run("GetStatus_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetStatus() // Should return zero value
	})

	t.Run("GetExpirationSeconds", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected *float64
		obj.ExpirationSeconds = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetExpirationSeconds(), "getter should return the property value")
	})

	t.Run("GetExpirationSeconds_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.ExpirationSeconds = nil

		// Act & Assert
		assert.Nil(t, obj.GetExpirationSeconds(), "getter should return nil when property is nil")
	})

	t.Run("GetExpirationSeconds_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetExpirationSeconds() // Should return zero value
	})

	t.Run("GetAssistantId", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected *string
		obj.AssistantId = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetAssistantId(), "getter should return the property value")
	})

	t.Run("GetAssistantId_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.AssistantId = nil

		// Act & Assert
		assert.Nil(t, obj.GetAssistantId(), "getter should return nil when property is nil")
	})

	t.Run("GetAssistantId_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetAssistantId() // Should return zero value
	})

	t.Run("GetAssistant", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected *CreateAssistantDto
		obj.Assistant = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetAssistant(), "getter should return the property value")
	})

	t.Run("GetAssistant_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.Assistant = nil

		// Act & Assert
		assert.Nil(t, obj.GetAssistant(), "getter should return nil when property is nil")
	})

	t.Run("GetAssistant_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetAssistant() // Should return zero value
	})

	t.Run("GetAssistantOverrides", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected *AssistantOverrides
		obj.AssistantOverrides = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetAssistantOverrides(), "getter should return the property value")
	})

	t.Run("GetAssistantOverrides_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.AssistantOverrides = nil

		// Act & Assert
		assert.Nil(t, obj.GetAssistantOverrides(), "getter should return nil when property is nil")
	})

	t.Run("GetAssistantOverrides_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetAssistantOverrides() // Should return zero value
	})

	t.Run("GetSquadId", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected *string
		obj.SquadId = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetSquadId(), "getter should return the property value")
	})

	t.Run("GetSquadId_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.SquadId = nil

		// Act & Assert
		assert.Nil(t, obj.GetSquadId(), "getter should return nil when property is nil")
	})

	t.Run("GetSquadId_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetSquadId() // Should return zero value
	})

	t.Run("GetSquad", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected *CreateSquadDto
		obj.Squad = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetSquad(), "getter should return the property value")
	})

	t.Run("GetSquad_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.Squad = nil

		// Act & Assert
		assert.Nil(t, obj.GetSquad(), "getter should return nil when property is nil")
	})

	t.Run("GetSquad_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetSquad() // Should return zero value
	})

	t.Run("GetMessages", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected []*SessionMessagesItem
		obj.Messages = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetMessages(), "getter should return the property value")
	})

	t.Run("GetMessages_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.Messages = nil

		// Act & Assert
		assert.Nil(t, obj.GetMessages(), "getter should return nil when property is nil")
	})

	t.Run("GetMessages_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetMessages() // Should return zero value
	})

	t.Run("GetCustomer", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected *CreateCustomerDto
		obj.Customer = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetCustomer(), "getter should return the property value")
	})

	t.Run("GetCustomer_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.Customer = nil

		// Act & Assert
		assert.Nil(t, obj.GetCustomer(), "getter should return nil when property is nil")
	})

	t.Run("GetCustomer_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetCustomer() // Should return zero value
	})

	t.Run("GetCustomerId", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected *string
		obj.CustomerId = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetCustomerId(), "getter should return the property value")
	})

	t.Run("GetCustomerId_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.CustomerId = nil

		// Act & Assert
		assert.Nil(t, obj.GetCustomerId(), "getter should return nil when property is nil")
	})

	t.Run("GetCustomerId_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetCustomerId() // Should return zero value
	})

	t.Run("GetPhoneNumberId", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected *string
		obj.PhoneNumberId = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetPhoneNumberId(), "getter should return the property value")
	})

	t.Run("GetPhoneNumberId_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.PhoneNumberId = nil

		// Act & Assert
		assert.Nil(t, obj.GetPhoneNumberId(), "getter should return nil when property is nil")
	})

	t.Run("GetPhoneNumberId_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetPhoneNumberId() // Should return zero value
	})

	t.Run("GetPhoneNumber", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected *ImportTwilioPhoneNumberDto
		obj.PhoneNumber = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetPhoneNumber(), "getter should return the property value")
	})

	t.Run("GetPhoneNumber_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.PhoneNumber = nil

		// Act & Assert
		assert.Nil(t, obj.GetPhoneNumber(), "getter should return nil when property is nil")
	})

	t.Run("GetPhoneNumber_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetPhoneNumber() // Should return zero value
	})

	t.Run("GetArtifact", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var expected *Artifact
		obj.Artifact = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetArtifact(), "getter should return the property value")
	})

	t.Run("GetArtifact_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		obj.Artifact = nil

		// Act & Assert
		assert.Nil(t, obj.GetArtifact(), "getter should return nil when property is nil")
	})

	t.Run("GetArtifact_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetArtifact() // Should return zero value
	})

}

func TestSettersMarkExplicitSession(t *testing.T) {
	t.Run("SetId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueId string

		// Act
		obj.SetId(fernTestValueId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetOrgId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueOrgId string

		// Act
		obj.SetOrgId(fernTestValueOrgId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetCreatedAt_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueCreatedAt time.Time

		// Act
		obj.SetCreatedAt(fernTestValueCreatedAt)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetUpdatedAt_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueUpdatedAt time.Time

		// Act
		obj.SetUpdatedAt(fernTestValueUpdatedAt)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetCost_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueCost *float64

		// Act
		obj.SetCost(fernTestValueCost)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetCosts_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueCosts []*SessionCostsItem

		// Act
		obj.SetCosts(fernTestValueCosts)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetName_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueName *string

		// Act
		obj.SetName(fernTestValueName)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetStatus_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueStatus *SessionStatus

		// Act
		obj.SetStatus(fernTestValueStatus)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetExpirationSeconds_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueExpirationSeconds *float64

		// Act
		obj.SetExpirationSeconds(fernTestValueExpirationSeconds)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetAssistantId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueAssistantId *string

		// Act
		obj.SetAssistantId(fernTestValueAssistantId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetAssistant_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueAssistant *CreateAssistantDto

		// Act
		obj.SetAssistant(fernTestValueAssistant)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetAssistantOverrides_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueAssistantOverrides *AssistantOverrides

		// Act
		obj.SetAssistantOverrides(fernTestValueAssistantOverrides)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetSquadId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueSquadId *string

		// Act
		obj.SetSquadId(fernTestValueSquadId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetSquad_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueSquad *CreateSquadDto

		// Act
		obj.SetSquad(fernTestValueSquad)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetMessages_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueMessages []*SessionMessagesItem

		// Act
		obj.SetMessages(fernTestValueMessages)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetCustomer_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueCustomer *CreateCustomerDto

		// Act
		obj.SetCustomer(fernTestValueCustomer)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetCustomerId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueCustomerId *string

		// Act
		obj.SetCustomerId(fernTestValueCustomerId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetPhoneNumberId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValuePhoneNumberId *string

		// Act
		obj.SetPhoneNumberId(fernTestValuePhoneNumberId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetPhoneNumber_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValuePhoneNumber *ImportTwilioPhoneNumberDto

		// Act
		obj.SetPhoneNumber(fernTestValuePhoneNumber)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetArtifact_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}
		var fernTestValueArtifact *Artifact

		// Act
		obj.SetArtifact(fernTestValueArtifact)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

}

func TestSettersSessionCost(t *testing.T) {
	t.Run("SetCost", func(t *testing.T) {
		obj := &SessionCost{}
		var fernTestValueCost float64
		obj.SetCost(fernTestValueCost)
		assert.Equal(t, fernTestValueCost, obj.Cost)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersSessionCost(t *testing.T) {
	t.Run("GetCost", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionCost{}
		var expected float64
		obj.Cost = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetCost(), "getter should return the property value")
	})

	t.Run("GetCost_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionCost
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetCost() // Should return zero value
	})

}

func TestSettersMarkExplicitSessionCost(t *testing.T) {
	t.Run("SetCost_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionCost{}
		var fernTestValueCost float64

		// Act
		obj.SetCost(fernTestValueCost)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

}

func TestGettersSessionCostsItem(t *testing.T) {
	t.Run("GetType", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionCostsItem{}
		var expected string
		obj.Type = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetType(), "getter should return the property value")
	})

	t.Run("GetType_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionCostsItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetType() // Should return zero value
	})

	t.Run("GetModel", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionCostsItem{}
		var expected *ModelCost
		obj.Model = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetModel(), "getter should return the property value")
	})

	t.Run("GetModel_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionCostsItem{}
		obj.Model = nil

		// Act & Assert
		assert.Nil(t, obj.GetModel(), "getter should return nil when property is nil")
	})

	t.Run("GetModel_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionCostsItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetModel() // Should return zero value
	})

	t.Run("GetAnalysis", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionCostsItem{}
		var expected *AnalysisCost
		obj.Analysis = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetAnalysis(), "getter should return the property value")
	})

	t.Run("GetAnalysis_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionCostsItem{}
		obj.Analysis = nil

		// Act & Assert
		assert.Nil(t, obj.GetAnalysis(), "getter should return nil when property is nil")
	})

	t.Run("GetAnalysis_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionCostsItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetAnalysis() // Should return zero value
	})

	t.Run("GetSession", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionCostsItem{}
		var expected *SessionCost
		obj.Session = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetSession(), "getter should return the property value")
	})

	t.Run("GetSession_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionCostsItem{}
		obj.Session = nil

		// Act & Assert
		assert.Nil(t, obj.GetSession(), "getter should return nil when property is nil")
	})

	t.Run("GetSession_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionCostsItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetSession() // Should return zero value
	})

}

func TestGettersSessionMessagesItem(t *testing.T) {
	t.Run("GetSystemMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionMessagesItem{}
		var expected *SystemMessage
		obj.SystemMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetSystemMessage(), "getter should return the property value")
	})

	t.Run("GetSystemMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionMessagesItem{}
		obj.SystemMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetSystemMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetSystemMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetSystemMessage() // Should return zero value
	})

	t.Run("GetUserMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionMessagesItem{}
		var expected *UserMessage
		obj.UserMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetUserMessage(), "getter should return the property value")
	})

	t.Run("GetUserMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionMessagesItem{}
		obj.UserMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetUserMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetUserMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetUserMessage() // Should return zero value
	})

	t.Run("GetAssistantMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionMessagesItem{}
		var expected *AssistantMessage
		obj.AssistantMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetAssistantMessage(), "getter should return the property value")
	})

	t.Run("GetAssistantMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionMessagesItem{}
		obj.AssistantMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetAssistantMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetAssistantMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetAssistantMessage() // Should return zero value
	})

	t.Run("GetToolMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionMessagesItem{}
		var expected *ToolMessage
		obj.ToolMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetToolMessage(), "getter should return the property value")
	})

	t.Run("GetToolMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionMessagesItem{}
		obj.ToolMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetToolMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetToolMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetToolMessage() // Should return zero value
	})

	t.Run("GetDeveloperMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionMessagesItem{}
		var expected *DeveloperMessage
		obj.DeveloperMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetDeveloperMessage(), "getter should return the property value")
	})

	t.Run("GetDeveloperMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionMessagesItem{}
		obj.DeveloperMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetDeveloperMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetDeveloperMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetDeveloperMessage() // Should return zero value
	})

}

func TestSettersSessionPaginatedResponse(t *testing.T) {
	t.Run("SetResults", func(t *testing.T) {
		obj := &SessionPaginatedResponse{}
		var fernTestValueResults []*Session
		obj.SetResults(fernTestValueResults)
		assert.Equal(t, fernTestValueResults, obj.Results)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMetadata", func(t *testing.T) {
		obj := &SessionPaginatedResponse{}
		var fernTestValueMetadata *PaginationMeta
		obj.SetMetadata(fernTestValueMetadata)
		assert.Equal(t, fernTestValueMetadata, obj.Metadata)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersSessionPaginatedResponse(t *testing.T) {
	t.Run("GetResults", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionPaginatedResponse{}
		var expected []*Session
		obj.Results = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetResults(), "getter should return the property value")
	})

	t.Run("GetResults_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionPaginatedResponse{}
		obj.Results = nil

		// Act & Assert
		assert.Nil(t, obj.GetResults(), "getter should return nil when property is nil")
	})

	t.Run("GetResults_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionPaginatedResponse
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetResults() // Should return zero value
	})

	t.Run("GetMetadata", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionPaginatedResponse{}
		var expected *PaginationMeta
		obj.Metadata = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetMetadata(), "getter should return the property value")
	})

	t.Run("GetMetadata_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionPaginatedResponse{}
		obj.Metadata = nil

		// Act & Assert
		assert.Nil(t, obj.GetMetadata(), "getter should return nil when property is nil")
	})

	t.Run("GetMetadata_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionPaginatedResponse
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetMetadata() // Should return zero value
	})

}

func TestSettersMarkExplicitSessionPaginatedResponse(t *testing.T) {
	t.Run("SetResults_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionPaginatedResponse{}
		var fernTestValueResults []*Session

		// Act
		obj.SetResults(fernTestValueResults)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetMetadata_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionPaginatedResponse{}
		var fernTestValueMetadata *PaginationMeta

		// Act
		obj.SetMetadata(fernTestValueMetadata)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

}

func TestGettersCreateSessionDtoMessagesItem(t *testing.T) {
	t.Run("GetSystemMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDtoMessagesItem{}
		var expected *SystemMessage
		obj.SystemMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetSystemMessage(), "getter should return the property value")
	})

	t.Run("GetSystemMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDtoMessagesItem{}
		obj.SystemMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetSystemMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetSystemMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *CreateSessionDtoMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetSystemMessage() // Should return zero value
	})

	t.Run("GetUserMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDtoMessagesItem{}
		var expected *UserMessage
		obj.UserMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetUserMessage(), "getter should return the property value")
	})

	t.Run("GetUserMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDtoMessagesItem{}
		obj.UserMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetUserMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetUserMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *CreateSessionDtoMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetUserMessage() // Should return zero value
	})

	t.Run("GetAssistantMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDtoMessagesItem{}
		var expected *AssistantMessage
		obj.AssistantMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetAssistantMessage(), "getter should return the property value")
	})

	t.Run("GetAssistantMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDtoMessagesItem{}
		obj.AssistantMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetAssistantMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetAssistantMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *CreateSessionDtoMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetAssistantMessage() // Should return zero value
	})

	t.Run("GetToolMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDtoMessagesItem{}
		var expected *ToolMessage
		obj.ToolMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetToolMessage(), "getter should return the property value")
	})

	t.Run("GetToolMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDtoMessagesItem{}
		obj.ToolMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetToolMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetToolMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *CreateSessionDtoMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetToolMessage() // Should return zero value
	})

	t.Run("GetDeveloperMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDtoMessagesItem{}
		var expected *DeveloperMessage
		obj.DeveloperMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetDeveloperMessage(), "getter should return the property value")
	})

	t.Run("GetDeveloperMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateSessionDtoMessagesItem{}
		obj.DeveloperMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetDeveloperMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetDeveloperMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *CreateSessionDtoMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetDeveloperMessage() // Should return zero value
	})

}

func TestGettersUpdateSessionDtoMessagesItem(t *testing.T) {
	t.Run("GetSystemMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDtoMessagesItem{}
		var expected *SystemMessage
		obj.SystemMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetSystemMessage(), "getter should return the property value")
	})

	t.Run("GetSystemMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDtoMessagesItem{}
		obj.SystemMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetSystemMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetSystemMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *UpdateSessionDtoMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetSystemMessage() // Should return zero value
	})

	t.Run("GetUserMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDtoMessagesItem{}
		var expected *UserMessage
		obj.UserMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetUserMessage(), "getter should return the property value")
	})

	t.Run("GetUserMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDtoMessagesItem{}
		obj.UserMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetUserMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetUserMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *UpdateSessionDtoMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetUserMessage() // Should return zero value
	})

	t.Run("GetAssistantMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDtoMessagesItem{}
		var expected *AssistantMessage
		obj.AssistantMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetAssistantMessage(), "getter should return the property value")
	})

	t.Run("GetAssistantMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDtoMessagesItem{}
		obj.AssistantMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetAssistantMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetAssistantMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *UpdateSessionDtoMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetAssistantMessage() // Should return zero value
	})

	t.Run("GetToolMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDtoMessagesItem{}
		var expected *ToolMessage
		obj.ToolMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetToolMessage(), "getter should return the property value")
	})

	t.Run("GetToolMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDtoMessagesItem{}
		obj.ToolMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetToolMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetToolMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *UpdateSessionDtoMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetToolMessage() // Should return zero value
	})

	t.Run("GetDeveloperMessage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDtoMessagesItem{}
		var expected *DeveloperMessage
		obj.DeveloperMessage = expected

		// Act & Assert
		assert.Equal(t, expected, obj.GetDeveloperMessage(), "getter should return the property value")
	})

	t.Run("GetDeveloperMessage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDtoMessagesItem{}
		obj.DeveloperMessage = nil

		// Act & Assert
		assert.Nil(t, obj.GetDeveloperMessage(), "getter should return nil when property is nil")
	})

	t.Run("GetDeveloperMessage_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *UpdateSessionDtoMessagesItem
		// Should not panic - getters should handle nil receiver gracefully
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("Getter panicked on nil receiver: %v", r)
			}
		}()
		_ = obj.GetDeveloperMessage() // Should return zero value
	})

}

func TestSettersUpdateSessionDto(t *testing.T) {
	t.Run("SetId", func(t *testing.T) {
		obj := &UpdateSessionDto{}
		var fernTestValueId string
		obj.SetId(fernTestValueId)
		assert.Equal(t, fernTestValueId, obj.Id)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetName", func(t *testing.T) {
		obj := &UpdateSessionDto{}
		var fernTestValueName *string
		obj.SetName(fernTestValueName)
		assert.Equal(t, fernTestValueName, obj.Name)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStatus", func(t *testing.T) {
		obj := &UpdateSessionDto{}
		var fernTestValueStatus *UpdateSessionDtoStatus
		obj.SetStatus(fernTestValueStatus)
		assert.Equal(t, fernTestValueStatus, obj.Status)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetExpirationSeconds", func(t *testing.T) {
		obj := &UpdateSessionDto{}
		var fernTestValueExpirationSeconds *float64
		obj.SetExpirationSeconds(fernTestValueExpirationSeconds)
		assert.Equal(t, fernTestValueExpirationSeconds, obj.ExpirationSeconds)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMessages", func(t *testing.T) {
		obj := &UpdateSessionDto{}
		var fernTestValueMessages []*UpdateSessionDtoMessagesItem
		obj.SetMessages(fernTestValueMessages)
		assert.Equal(t, fernTestValueMessages, obj.Messages)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitUpdateSessionDto(t *testing.T) {
	t.Run("SetId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDto{}
		var fernTestValueId string

		// Act
		obj.SetId(fernTestValueId)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetName_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDto{}
		var fernTestValueName *string

		// Act
		obj.SetName(fernTestValueName)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetStatus_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDto{}
		var fernTestValueStatus *UpdateSessionDtoStatus

		// Act
		obj.SetStatus(fernTestValueStatus)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetExpirationSeconds_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDto{}
		var fernTestValueExpirationSeconds *float64

		// Act
		obj.SetExpirationSeconds(fernTestValueExpirationSeconds)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

	t.Run("SetMessages_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateSessionDto{}
		var fernTestValueMessages []*UpdateSessionDtoMessagesItem

		// Act
		obj.SetMessages(fernTestValueMessages)

		// Assert - object with explicitly set field can be marshaled/unmarshaled
		bytes, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed for test setup")

		// This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value
		// Detect if marshaled JSON is an object or primitive to use correct unmarshal target
		if len(bytes) > 0 && bytes[0] == '{' {
			// JSON object - unmarshal into map
			var unmarshaled map[string]interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		} else {
			// JSON primitive (string, number, boolean, null) - unmarshal into interface{}
			var unmarshaled interface{}
			err = json.Unmarshal(bytes, &unmarshaled)
			require.NoError(t, err, "unmarshaling should succeed for test verification")
		}

		// Note: This does not explicitly assert the presence of a specific JSON field
		// It verifies that setting a field via setter allows successful JSON round-trip
	})

}

func TestJSONMarshalingSession(t *testing.T) {
	t.Run("MarshalUnmarshal", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Session{}

		// Act - Marshal to JSON
		data, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed")
		assert.NotNil(t, data, "marshaled data should not be nil")
		assert.NotEmpty(t, data, "marshaled data should not be empty")

		// Unmarshal back and verify round-trip
		var unmarshaled Session
		err = json.Unmarshal(data, &unmarshaled)
		assert.NoError(t, err, "round-trip unmarshal should succeed")
	})

	t.Run("UnmarshalInvalidJSON", func(t *testing.T) {
		t.Parallel()
		var obj Session
		err := json.Unmarshal([]byte(`{invalid json}`), &obj)
		assert.Error(t, err, "unmarshaling invalid JSON should return an error")
	})

	t.Run("UnmarshalEmptyObject", func(t *testing.T) {
		t.Parallel()
		var obj Session
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

func TestJSONMarshalingSessionCost(t *testing.T) {
	t.Run("MarshalUnmarshal", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionCost{}

		// Act - Marshal to JSON
		data, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed")
		assert.NotNil(t, data, "marshaled data should not be nil")
		assert.NotEmpty(t, data, "marshaled data should not be empty")

		// Unmarshal back and verify round-trip
		var unmarshaled SessionCost
		err = json.Unmarshal(data, &unmarshaled)
		assert.NoError(t, err, "round-trip unmarshal should succeed")
	})

	t.Run("UnmarshalInvalidJSON", func(t *testing.T) {
		t.Parallel()
		var obj SessionCost
		err := json.Unmarshal([]byte(`{invalid json}`), &obj)
		assert.Error(t, err, "unmarshaling invalid JSON should return an error")
	})

	t.Run("UnmarshalEmptyObject", func(t *testing.T) {
		t.Parallel()
		var obj SessionCost
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

func TestJSONMarshalingSessionPaginatedResponse(t *testing.T) {
	t.Run("MarshalUnmarshal", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SessionPaginatedResponse{}

		// Act - Marshal to JSON
		data, err := json.Marshal(obj)
		require.NoError(t, err, "marshaling should succeed")
		assert.NotNil(t, data, "marshaled data should not be nil")
		assert.NotEmpty(t, data, "marshaled data should not be empty")

		// Unmarshal back and verify round-trip
		var unmarshaled SessionPaginatedResponse
		err = json.Unmarshal(data, &unmarshaled)
		assert.NoError(t, err, "round-trip unmarshal should succeed")
	})

	t.Run("UnmarshalInvalidJSON", func(t *testing.T) {
		t.Parallel()
		var obj SessionPaginatedResponse
		err := json.Unmarshal([]byte(`{invalid json}`), &obj)
		assert.Error(t, err, "unmarshaling invalid JSON should return an error")
	})

	t.Run("UnmarshalEmptyObject", func(t *testing.T) {
		t.Parallel()
		var obj SessionPaginatedResponse
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

func TestStringSession(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &Session{}
		result := obj.String()
		assert.NotEmpty(t, result, "String() should return a non-empty representation")
	})

	t.Run("StringMethod_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestStringSessionCost(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &SessionCost{}
		result := obj.String()
		assert.NotEmpty(t, result, "String() should return a non-empty representation")
	})

	t.Run("StringMethod_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionCost
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestStringSessionPaginatedResponse(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &SessionPaginatedResponse{}
		result := obj.String()
		assert.NotEmpty(t, result, "String() should return a non-empty representation")
	})

	t.Run("StringMethod_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionPaginatedResponse
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestEnumCreateSessionDtoStatus(t *testing.T) {
	t.Run("NewFromString_active", func(t *testing.T) {
		t.Parallel()
		val, err := NewCreateSessionDtoStatusFromString("active")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, CreateSessionDtoStatus("active"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_completed", func(t *testing.T) {
		t.Parallel()
		val, err := NewCreateSessionDtoStatusFromString("completed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, CreateSessionDtoStatus("completed"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_Invalid", func(t *testing.T) {
		_, err := NewCreateSessionDtoStatusFromString("invalid_value_that_does_not_exist")
		assert.Error(t, err)
	})

	t.Run("Ptr", func(t *testing.T) {
		val, err := NewCreateSessionDtoStatusFromString("active")
		assert.NoError(t, err)
		ptr := val.Ptr()
		assert.NotNil(t, ptr)
		assert.Equal(t, val, *ptr)
	})
}

func TestEnumListSessionsRequestSortOrder(t *testing.T) {
	t.Run("NewFromString_ASC", func(t *testing.T) {
		t.Parallel()
		val, err := NewListSessionsRequestSortOrderFromString("ASC")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ListSessionsRequestSortOrder("ASC"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_DESC", func(t *testing.T) {
		t.Parallel()
		val, err := NewListSessionsRequestSortOrderFromString("DESC")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ListSessionsRequestSortOrder("DESC"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_Invalid", func(t *testing.T) {
		_, err := NewListSessionsRequestSortOrderFromString("invalid_value_that_does_not_exist")
		assert.Error(t, err)
	})

	t.Run("Ptr", func(t *testing.T) {
		val, err := NewListSessionsRequestSortOrderFromString("ASC")
		assert.NoError(t, err)
		ptr := val.Ptr()
		assert.NotNil(t, ptr)
		assert.Equal(t, val, *ptr)
	})
}

func TestEnumSessionStatus(t *testing.T) {
	t.Run("NewFromString_active", func(t *testing.T) {
		t.Parallel()
		val, err := NewSessionStatusFromString("active")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, SessionStatus("active"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_completed", func(t *testing.T) {
		t.Parallel()
		val, err := NewSessionStatusFromString("completed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, SessionStatus("completed"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_Invalid", func(t *testing.T) {
		_, err := NewSessionStatusFromString("invalid_value_that_does_not_exist")
		assert.Error(t, err)
	})

	t.Run("Ptr", func(t *testing.T) {
		val, err := NewSessionStatusFromString("active")
		assert.NoError(t, err)
		ptr := val.Ptr()
		assert.NotNil(t, ptr)
		assert.Equal(t, val, *ptr)
	})
}

func TestEnumUpdateSessionDtoStatus(t *testing.T) {
	t.Run("NewFromString_active", func(t *testing.T) {
		t.Parallel()
		val, err := NewUpdateSessionDtoStatusFromString("active")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, UpdateSessionDtoStatus("active"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_completed", func(t *testing.T) {
		t.Parallel()
		val, err := NewUpdateSessionDtoStatusFromString("completed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, UpdateSessionDtoStatus("completed"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_Invalid", func(t *testing.T) {
		_, err := NewUpdateSessionDtoStatusFromString("invalid_value_that_does_not_exist")
		assert.Error(t, err)
	})

	t.Run("Ptr", func(t *testing.T) {
		val, err := NewUpdateSessionDtoStatusFromString("active")
		assert.NoError(t, err)
		ptr := val.Ptr()
		assert.NotNil(t, ptr)
		assert.Equal(t, val, *ptr)
	})
}

func TestExtraPropertiesSession(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &Session{}
		// Should not panic when calling GetExtraProperties()
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("GetExtraProperties() panicked: %v", r)
			}
		}()
		extraProps := obj.GetExtraProperties()
		// Result can be nil or an empty/non-empty map
		_ = extraProps
	})

	t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Session
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}

func TestExtraPropertiesSessionCost(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &SessionCost{}
		// Should not panic when calling GetExtraProperties()
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("GetExtraProperties() panicked: %v", r)
			}
		}()
		extraProps := obj.GetExtraProperties()
		// Result can be nil or an empty/non-empty map
		_ = extraProps
	})

	t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionCost
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}

func TestExtraPropertiesSessionPaginatedResponse(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &SessionPaginatedResponse{}
		// Should not panic when calling GetExtraProperties()
		defer func() {
			if r := recover(); r != nil {
				t.Errorf("GetExtraProperties() panicked: %v", r)
			}
		}()
		extraProps := obj.GetExtraProperties()
		// Result can be nil or an empty/non-empty map
		_ = extraProps
	})

	t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *SessionPaginatedResponse
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}