structured_outputs_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 TestSettersStructuredOutputControllerFindAllRequest(t *testing.T) {
	t.Run("SetId", func(t *testing.T) {
		obj := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		var fernTestValueName *string
		obj.SetName(fernTestValueName)
		assert.Equal(t, fernTestValueName, obj.Name)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetPage", func(t *testing.T) {
		obj := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		var fernTestValueSortOrder *StructuredOutputControllerFindAllRequestSortOrder
		obj.SetSortOrder(fernTestValueSortOrder)
		assert.Equal(t, fernTestValueSortOrder, obj.SortOrder)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetLimit", func(t *testing.T) {
		obj := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		var fernTestValueUpdatedAtLe *time.Time
		obj.SetUpdatedAtLe(fernTestValueUpdatedAtLe)
		assert.Equal(t, fernTestValueUpdatedAtLe, obj.UpdatedAtLe)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitStructuredOutputControllerFindAllRequest(t *testing.T) {
	t.Run("SetId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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("SetPage_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		var fernTestValueSortOrder *StructuredOutputControllerFindAllRequestSortOrder

		// 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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 := &StructuredOutputControllerFindAllRequest{}
		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 TestSettersStructuredOutputControllerFindOneRequest(t *testing.T) {
	t.Run("SetId", func(t *testing.T) {
		obj := &StructuredOutputControllerFindOneRequest{}
		var fernTestValueId string
		obj.SetId(fernTestValueId)
		assert.Equal(t, fernTestValueId, obj.Id)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitStructuredOutputControllerFindOneRequest(t *testing.T) {
	t.Run("SetId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputControllerFindOneRequest{}
		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 TestSettersStructuredOutputControllerRemoveRequest(t *testing.T) {
	t.Run("SetId", func(t *testing.T) {
		obj := &StructuredOutputControllerRemoveRequest{}
		var fernTestValueId string
		obj.SetId(fernTestValueId)
		assert.Equal(t, fernTestValueId, obj.Id)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitStructuredOutputControllerRemoveRequest(t *testing.T) {
	t.Run("SetId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputControllerRemoveRequest{}
		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 TestSettersStructuredOutputRunDto(t *testing.T) {
	t.Run("SetPreviewEnabled", func(t *testing.T) {
		obj := &StructuredOutputRunDto{}
		var fernTestValuePreviewEnabled *bool
		obj.SetPreviewEnabled(fernTestValuePreviewEnabled)
		assert.Equal(t, fernTestValuePreviewEnabled, obj.PreviewEnabled)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStructuredOutputId", func(t *testing.T) {
		obj := &StructuredOutputRunDto{}
		var fernTestValueStructuredOutputId *string
		obj.SetStructuredOutputId(fernTestValueStructuredOutputId)
		assert.Equal(t, fernTestValueStructuredOutputId, obj.StructuredOutputId)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStructuredOutput", func(t *testing.T) {
		obj := &StructuredOutputRunDto{}
		var fernTestValueStructuredOutput *CreateStructuredOutputDto
		obj.SetStructuredOutput(fernTestValueStructuredOutput)
		assert.Equal(t, fernTestValueStructuredOutput, obj.StructuredOutput)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCallIds", func(t *testing.T) {
		obj := &StructuredOutputRunDto{}
		var fernTestValueCallIds []string
		obj.SetCallIds(fernTestValueCallIds)
		assert.Equal(t, fernTestValueCallIds, obj.CallIds)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitStructuredOutputRunDto(t *testing.T) {
	t.Run("SetPreviewEnabled_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputRunDto{}
		var fernTestValuePreviewEnabled *bool

		// Act
		obj.SetPreviewEnabled(fernTestValuePreviewEnabled)

		// 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("SetStructuredOutputId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputRunDto{}
		var fernTestValueStructuredOutputId *string

		// Act
		obj.SetStructuredOutputId(fernTestValueStructuredOutputId)

		// 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("SetStructuredOutput_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputRunDto{}
		var fernTestValueStructuredOutput *CreateStructuredOutputDto

		// Act
		obj.SetStructuredOutput(fernTestValueStructuredOutput)

		// 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("SetCallIds_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputRunDto{}
		var fernTestValueCallIds []string

		// Act
		obj.SetCallIds(fernTestValueCallIds)

		// 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 TestSettersUpdateStructuredOutputDto(t *testing.T) {
	t.Run("SetId", func(t *testing.T) {
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueId string
		obj.SetId(fernTestValueId)
		assert.Equal(t, fernTestValueId, obj.Id)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSchemaOverride", func(t *testing.T) {
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueSchemaOverride string
		obj.SetSchemaOverride(fernTestValueSchemaOverride)
		assert.Equal(t, fernTestValueSchemaOverride, obj.SchemaOverride)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetType", func(t *testing.T) {
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueType *UpdateStructuredOutputDtoType
		obj.SetType(fernTestValueType)
		assert.Equal(t, fernTestValueType, obj.Type)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetRegex", func(t *testing.T) {
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueRegex *string
		obj.SetRegex(fernTestValueRegex)
		assert.Equal(t, fernTestValueRegex, obj.Regex)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetModel", func(t *testing.T) {
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueModel *UpdateStructuredOutputDtoModel
		obj.SetModel(fernTestValueModel)
		assert.Equal(t, fernTestValueModel, obj.Model)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCompliancePlan", func(t *testing.T) {
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueCompliancePlan *ComplianceOverride
		obj.SetCompliancePlan(fernTestValueCompliancePlan)
		assert.Equal(t, fernTestValueCompliancePlan, obj.CompliancePlan)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetDescription", func(t *testing.T) {
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueDescription *string
		obj.SetDescription(fernTestValueDescription)
		assert.Equal(t, fernTestValueDescription, obj.Description)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetAssistantIds", func(t *testing.T) {
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueAssistantIds []string
		obj.SetAssistantIds(fernTestValueAssistantIds)
		assert.Equal(t, fernTestValueAssistantIds, obj.AssistantIds)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetWorkflowIds", func(t *testing.T) {
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueWorkflowIds []string
		obj.SetWorkflowIds(fernTestValueWorkflowIds)
		assert.Equal(t, fernTestValueWorkflowIds, obj.WorkflowIds)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSchema", func(t *testing.T) {
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueSchema *JsonSchema
		obj.SetSchema(fernTestValueSchema)
		assert.Equal(t, fernTestValueSchema, obj.Schema)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitUpdateStructuredOutputDto(t *testing.T) {
	t.Run("SetId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDto{}
		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("SetSchemaOverride_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueSchemaOverride string

		// Act
		obj.SetSchemaOverride(fernTestValueSchemaOverride)

		// 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("SetType_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueType *UpdateStructuredOutputDtoType

		// Act
		obj.SetType(fernTestValueType)

		// 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("SetRegex_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueRegex *string

		// Act
		obj.SetRegex(fernTestValueRegex)

		// 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("SetModel_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueModel *UpdateStructuredOutputDtoModel

		// Act
		obj.SetModel(fernTestValueModel)

		// 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("SetCompliancePlan_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueCompliancePlan *ComplianceOverride

		// Act
		obj.SetCompliancePlan(fernTestValueCompliancePlan)

		// 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 := &UpdateStructuredOutputDto{}
		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("SetDescription_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueDescription *string

		// Act
		obj.SetDescription(fernTestValueDescription)

		// 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("SetAssistantIds_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueAssistantIds []string

		// Act
		obj.SetAssistantIds(fernTestValueAssistantIds)

		// 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("SetWorkflowIds_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueWorkflowIds []string

		// Act
		obj.SetWorkflowIds(fernTestValueWorkflowIds)

		// 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("SetSchema_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDto{}
		var fernTestValueSchema *JsonSchema

		// Act
		obj.SetSchema(fernTestValueSchema)

		// 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 TestSettersStructuredOutput(t *testing.T) {
	t.Run("SetType", func(t *testing.T) {
		obj := &StructuredOutput{}
		var fernTestValueType *StructuredOutputType
		obj.SetType(fernTestValueType)
		assert.Equal(t, fernTestValueType, obj.Type)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetRegex", func(t *testing.T) {
		obj := &StructuredOutput{}
		var fernTestValueRegex *string
		obj.SetRegex(fernTestValueRegex)
		assert.Equal(t, fernTestValueRegex, obj.Regex)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetModel", func(t *testing.T) {
		obj := &StructuredOutput{}
		var fernTestValueModel *StructuredOutputModel
		obj.SetModel(fernTestValueModel)
		assert.Equal(t, fernTestValueModel, obj.Model)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCompliancePlan", func(t *testing.T) {
		obj := &StructuredOutput{}
		var fernTestValueCompliancePlan *ComplianceOverride
		obj.SetCompliancePlan(fernTestValueCompliancePlan)
		assert.Equal(t, fernTestValueCompliancePlan, obj.CompliancePlan)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetId", func(t *testing.T) {
		obj := &StructuredOutput{}
		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 := &StructuredOutput{}
		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 := &StructuredOutput{}
		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 := &StructuredOutput{}
		var fernTestValueUpdatedAt time.Time
		obj.SetUpdatedAt(fernTestValueUpdatedAt)
		assert.Equal(t, fernTestValueUpdatedAt, obj.UpdatedAt)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetDescription", func(t *testing.T) {
		obj := &StructuredOutput{}
		var fernTestValueDescription *string
		obj.SetDescription(fernTestValueDescription)
		assert.Equal(t, fernTestValueDescription, obj.Description)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetAssistantIds", func(t *testing.T) {
		obj := &StructuredOutput{}
		var fernTestValueAssistantIds []string
		obj.SetAssistantIds(fernTestValueAssistantIds)
		assert.Equal(t, fernTestValueAssistantIds, obj.AssistantIds)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetWorkflowIds", func(t *testing.T) {
		obj := &StructuredOutput{}
		var fernTestValueWorkflowIds []string
		obj.SetWorkflowIds(fernTestValueWorkflowIds)
		assert.Equal(t, fernTestValueWorkflowIds, obj.WorkflowIds)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSchema", func(t *testing.T) {
		obj := &StructuredOutput{}
		var fernTestValueSchema *JsonSchema
		obj.SetSchema(fernTestValueSchema)
		assert.Equal(t, fernTestValueSchema, obj.Schema)
		assert.NotNil(t, obj.explicitFields)
	})

}

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

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

	t.Run("GetType_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		obj.Type = nil

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

	t.Run("GetType_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *StructuredOutput
		// 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("GetRegex", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var expected *string
		obj.Regex = expected

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

	t.Run("GetRegex_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		obj.Regex = nil

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

	t.Run("GetRegex_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *StructuredOutput
		// 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.GetRegex() // Should return zero value
	})

	t.Run("GetModel", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var expected *StructuredOutputModel
		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 := &StructuredOutput{}
		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 *StructuredOutput
		// 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("GetCompliancePlan", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var expected *ComplianceOverride
		obj.CompliancePlan = expected

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

	t.Run("GetCompliancePlan_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		obj.CompliancePlan = nil

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

	t.Run("GetCompliancePlan_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *StructuredOutput
		// 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.GetCompliancePlan() // Should return zero value
	})

	t.Run("GetId", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		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 *StructuredOutput
		// 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 := &StructuredOutput{}
		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 *StructuredOutput
		// 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 := &StructuredOutput{}
		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 *StructuredOutput
		// 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 := &StructuredOutput{}
		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 *StructuredOutput
		// 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("GetName", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var expected string
		obj.Name = expected

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

	t.Run("GetName_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *StructuredOutput
		// 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("GetDescription", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var expected *string
		obj.Description = expected

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

	t.Run("GetDescription_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		obj.Description = nil

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

	t.Run("GetDescription_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *StructuredOutput
		// 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.GetDescription() // Should return zero value
	})

	t.Run("GetAssistantIds", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var expected []string
		obj.AssistantIds = expected

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

	t.Run("GetAssistantIds_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		obj.AssistantIds = nil

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

	t.Run("GetAssistantIds_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *StructuredOutput
		// 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.GetAssistantIds() // Should return zero value
	})

	t.Run("GetWorkflowIds", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var expected []string
		obj.WorkflowIds = expected

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

	t.Run("GetWorkflowIds_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		obj.WorkflowIds = nil

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

	t.Run("GetWorkflowIds_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *StructuredOutput
		// 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.GetWorkflowIds() // Should return zero value
	})

	t.Run("GetSchema", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var expected *JsonSchema
		obj.Schema = expected

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

	t.Run("GetSchema_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		obj.Schema = nil

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

	t.Run("GetSchema_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *StructuredOutput
		// 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.GetSchema() // Should return zero value
	})

}

func TestSettersMarkExplicitStructuredOutput(t *testing.T) {
	t.Run("SetType_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var fernTestValueType *StructuredOutputType

		// Act
		obj.SetType(fernTestValueType)

		// 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("SetRegex_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var fernTestValueRegex *string

		// Act
		obj.SetRegex(fernTestValueRegex)

		// 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("SetModel_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var fernTestValueModel *StructuredOutputModel

		// Act
		obj.SetModel(fernTestValueModel)

		// 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("SetCompliancePlan_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var fernTestValueCompliancePlan *ComplianceOverride

		// Act
		obj.SetCompliancePlan(fernTestValueCompliancePlan)

		// 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("SetId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		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 := &StructuredOutput{}
		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 := &StructuredOutput{}
		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 := &StructuredOutput{}
		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("SetName_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		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("SetDescription_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var fernTestValueDescription *string

		// Act
		obj.SetDescription(fernTestValueDescription)

		// 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("SetAssistantIds_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var fernTestValueAssistantIds []string

		// Act
		obj.SetAssistantIds(fernTestValueAssistantIds)

		// 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("SetWorkflowIds_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var fernTestValueWorkflowIds []string

		// Act
		obj.SetWorkflowIds(fernTestValueWorkflowIds)

		// 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("SetSchema_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutput{}
		var fernTestValueSchema *JsonSchema

		// Act
		obj.SetSchema(fernTestValueSchema)

		// 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 TestGettersStructuredOutputModel(t *testing.T) {
	t.Run("GetProvider", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputModel{}
		var expected string
		obj.Provider = expected

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

	t.Run("GetProvider_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *StructuredOutputModel
		// 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.GetProvider() // Should return zero value
	})

	t.Run("GetOpenai", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputModel{}
		var expected *WorkflowOpenAiModel
		obj.Openai = expected

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

	t.Run("GetOpenai_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputModel{}
		obj.Openai = nil

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

	t.Run("GetOpenai_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *StructuredOutputModel
		// 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.GetOpenai() // Should return zero value
	})

	t.Run("GetAnthropic", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputModel{}
		var expected *WorkflowAnthropicModel
		obj.Anthropic = expected

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

	t.Run("GetAnthropic_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputModel{}
		obj.Anthropic = nil

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

	t.Run("GetAnthropic_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *StructuredOutputModel
		// 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.GetAnthropic() // Should return zero value
	})

	t.Run("GetAnthropicBedrock", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputModel{}
		var expected *WorkflowAnthropicBedrockModel
		obj.AnthropicBedrock = expected

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

	t.Run("GetAnthropicBedrock_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputModel{}
		obj.AnthropicBedrock = nil

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

	t.Run("GetAnthropicBedrock_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *StructuredOutputModel
		// 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.GetAnthropicBedrock() // Should return zero value
	})

	t.Run("GetGoogle", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputModel{}
		var expected *WorkflowGoogleModel
		obj.Google = expected

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

	t.Run("GetGoogle_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputModel{}
		obj.Google = nil

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

	t.Run("GetGoogle_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *StructuredOutputModel
		// 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.GetGoogle() // Should return zero value
	})

	t.Run("GetCustomLlm", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputModel{}
		var expected *WorkflowCustomModel
		obj.CustomLlm = expected

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

	t.Run("GetCustomLlm_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputModel{}
		obj.CustomLlm = nil

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

	t.Run("GetCustomLlm_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *StructuredOutputModel
		// 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.GetCustomLlm() // Should return zero value
	})

}

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

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

}

func TestGettersStructuredOutputPaginatedResponse(t *testing.T) {
	t.Run("GetResults", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputPaginatedResponse{}
		var expected []*StructuredOutput
		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 := &StructuredOutputPaginatedResponse{}
		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 *StructuredOutputPaginatedResponse
		// 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 := &StructuredOutputPaginatedResponse{}
		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 := &StructuredOutputPaginatedResponse{}
		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 *StructuredOutputPaginatedResponse
		// 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 TestSettersMarkExplicitStructuredOutputPaginatedResponse(t *testing.T) {
	t.Run("SetResults_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &StructuredOutputPaginatedResponse{}
		var fernTestValueResults []*StructuredOutput

		// 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 := &StructuredOutputPaginatedResponse{}
		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 TestGettersUpdateStructuredOutputDtoModel(t *testing.T) {
	t.Run("GetProvider", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDtoModel{}
		var expected string
		obj.Provider = expected

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

	t.Run("GetProvider_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *UpdateStructuredOutputDtoModel
		// 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.GetProvider() // Should return zero value
	})

	t.Run("GetOpenai", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDtoModel{}
		var expected *WorkflowOpenAiModel
		obj.Openai = expected

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

	t.Run("GetOpenai_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDtoModel{}
		obj.Openai = nil

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

	t.Run("GetOpenai_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *UpdateStructuredOutputDtoModel
		// 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.GetOpenai() // Should return zero value
	})

	t.Run("GetAnthropic", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDtoModel{}
		var expected *WorkflowAnthropicModel
		obj.Anthropic = expected

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

	t.Run("GetAnthropic_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDtoModel{}
		obj.Anthropic = nil

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

	t.Run("GetAnthropic_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *UpdateStructuredOutputDtoModel
		// 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.GetAnthropic() // Should return zero value
	})

	t.Run("GetAnthropicBedrock", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDtoModel{}
		var expected *WorkflowAnthropicBedrockModel
		obj.AnthropicBedrock = expected

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

	t.Run("GetAnthropicBedrock_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDtoModel{}
		obj.AnthropicBedrock = nil

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

	t.Run("GetAnthropicBedrock_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *UpdateStructuredOutputDtoModel
		// 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.GetAnthropicBedrock() // Should return zero value
	})

	t.Run("GetGoogle", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDtoModel{}
		var expected *WorkflowGoogleModel
		obj.Google = expected

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

	t.Run("GetGoogle_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDtoModel{}
		obj.Google = nil

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

	t.Run("GetGoogle_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *UpdateStructuredOutputDtoModel
		// 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.GetGoogle() // Should return zero value
	})

	t.Run("GetCustomLlm", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDtoModel{}
		var expected *WorkflowCustomModel
		obj.CustomLlm = expected

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

	t.Run("GetCustomLlm_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateStructuredOutputDtoModel{}
		obj.CustomLlm = nil

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

	t.Run("GetCustomLlm_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *UpdateStructuredOutputDtoModel
		// 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.GetCustomLlm() // Should return zero value
	})

}

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

		// 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 StructuredOutput
		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 StructuredOutput
		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 StructuredOutput
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

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

		// 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 StructuredOutputPaginatedResponse
		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 StructuredOutputPaginatedResponse
		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 StructuredOutputPaginatedResponse
		err := json.Unmarshal([]byte(`{}`), &obj)
		assert.NoError(t, err, "unmarshaling empty object should succeed")
	})
}

func TestStringStructuredOutput(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &StructuredOutput{}
		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 *StructuredOutput
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

func TestStringStructuredOutputPaginatedResponse(t *testing.T) {
	t.Run("StringMethod", func(t *testing.T) {
		t.Parallel()
		obj := &StructuredOutputPaginatedResponse{}
		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 *StructuredOutputPaginatedResponse
		result := obj.String()
		assert.Equal(t, "<nil>", result, "String() should return <nil> for nil receiver")
	})
}

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

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

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

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

func TestEnumStructuredOutputType(t *testing.T) {
	t.Run("NewFromString_ai", func(t *testing.T) {
		t.Parallel()
		val, err := NewStructuredOutputTypeFromString("ai")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, StructuredOutputType("ai"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_regex", func(t *testing.T) {
		t.Parallel()
		val, err := NewStructuredOutputTypeFromString("regex")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, StructuredOutputType("regex"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumUpdateStructuredOutputDtoType(t *testing.T) {
	t.Run("NewFromString_ai", func(t *testing.T) {
		t.Parallel()
		val, err := NewUpdateStructuredOutputDtoTypeFromString("ai")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, UpdateStructuredOutputDtoType("ai"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_regex", func(t *testing.T) {
		t.Parallel()
		val, err := NewUpdateStructuredOutputDtoTypeFromString("regex")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, UpdateStructuredOutputDtoType("regex"), val, "enum value should match expected wire value")
	})

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

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

func TestExtraPropertiesStructuredOutput(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &StructuredOutput{}
		// 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 *StructuredOutput
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}

func TestExtraPropertiesStructuredOutputPaginatedResponse(t *testing.T) {
	t.Run("GetExtraProperties", func(t *testing.T) {
		t.Parallel()
		obj := &StructuredOutputPaginatedResponse{}
		// 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 *StructuredOutputPaginatedResponse
		extraProps := obj.GetExtraProperties()
		assert.Nil(t, extraProps, "nil receiver should return nil without panicking")
	})
}