labor_test.go

// Code generated by Fern. DO NOT EDIT.

package square

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

func TestSettersBulkPublishScheduledShiftsRequest(t *testing.T) {
	t.Run("SetScheduledShifts", func(t *testing.T) {
		obj := &BulkPublishScheduledShiftsRequest{}
		var fernTestValueScheduledShifts map[string]*BulkPublishScheduledShiftsData
		obj.SetScheduledShifts(fernTestValueScheduledShifts)
		assert.Equal(t, fernTestValueScheduledShifts, obj.ScheduledShifts)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetScheduledShiftNotificationAudience", func(t *testing.T) {
		obj := &BulkPublishScheduledShiftsRequest{}
		var fernTestValueScheduledShiftNotificationAudience *ScheduledShiftNotificationAudience
		obj.SetScheduledShiftNotificationAudience(fernTestValueScheduledShiftNotificationAudience)
		assert.Equal(t, fernTestValueScheduledShiftNotificationAudience, obj.ScheduledShiftNotificationAudience)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitBulkPublishScheduledShiftsRequest(t *testing.T) {
	t.Run("SetScheduledShifts_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BulkPublishScheduledShiftsRequest{}
		var fernTestValueScheduledShifts map[string]*BulkPublishScheduledShiftsData

		// Act
		obj.SetScheduledShifts(fernTestValueScheduledShifts)

		// 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("SetScheduledShiftNotificationAudience_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BulkPublishScheduledShiftsRequest{}
		var fernTestValueScheduledShiftNotificationAudience *ScheduledShiftNotificationAudience

		// Act
		obj.SetScheduledShiftNotificationAudience(fernTestValueScheduledShiftNotificationAudience)

		// 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 TestSettersCreateScheduledShiftRequest(t *testing.T) {
	t.Run("SetIdempotencyKey", func(t *testing.T) {
		obj := &CreateScheduledShiftRequest{}
		var fernTestValueIdempotencyKey *string
		obj.SetIdempotencyKey(fernTestValueIdempotencyKey)
		assert.Equal(t, fernTestValueIdempotencyKey, obj.IdempotencyKey)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetScheduledShift", func(t *testing.T) {
		obj := &CreateScheduledShiftRequest{}
		var fernTestValueScheduledShift *ScheduledShift
		obj.SetScheduledShift(fernTestValueScheduledShift)
		assert.Equal(t, fernTestValueScheduledShift, obj.ScheduledShift)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitCreateScheduledShiftRequest(t *testing.T) {
	t.Run("SetIdempotencyKey_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateScheduledShiftRequest{}
		var fernTestValueIdempotencyKey *string

		// Act
		obj.SetIdempotencyKey(fernTestValueIdempotencyKey)

		// 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("SetScheduledShift_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateScheduledShiftRequest{}
		var fernTestValueScheduledShift *ScheduledShift

		// Act
		obj.SetScheduledShift(fernTestValueScheduledShift)

		// 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 TestSettersCreateTimecardRequest(t *testing.T) {
	t.Run("SetIdempotencyKey", func(t *testing.T) {
		obj := &CreateTimecardRequest{}
		var fernTestValueIdempotencyKey *string
		obj.SetIdempotencyKey(fernTestValueIdempotencyKey)
		assert.Equal(t, fernTestValueIdempotencyKey, obj.IdempotencyKey)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetTimecard", func(t *testing.T) {
		obj := &CreateTimecardRequest{}
		var fernTestValueTimecard *Timecard
		obj.SetTimecard(fernTestValueTimecard)
		assert.Equal(t, fernTestValueTimecard, obj.Timecard)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitCreateTimecardRequest(t *testing.T) {
	t.Run("SetIdempotencyKey_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateTimecardRequest{}
		var fernTestValueIdempotencyKey *string

		// Act
		obj.SetIdempotencyKey(fernTestValueIdempotencyKey)

		// 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("SetTimecard_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateTimecardRequest{}
		var fernTestValueTimecard *Timecard

		// Act
		obj.SetTimecard(fernTestValueTimecard)

		// 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 TestSettersDeleteTimecardRequest(t *testing.T) {
	t.Run("SetID", func(t *testing.T) {
		obj := &DeleteTimecardRequest{}
		var fernTestValueID string
		obj.SetID(fernTestValueID)
		assert.Equal(t, fernTestValueID, obj.ID)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitDeleteTimecardRequest(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DeleteTimecardRequest{}
		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 TestSettersPublishScheduledShiftRequest(t *testing.T) {
	t.Run("SetID", func(t *testing.T) {
		obj := &PublishScheduledShiftRequest{}
		var fernTestValueID string
		obj.SetID(fernTestValueID)
		assert.Equal(t, fernTestValueID, obj.ID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetIdempotencyKey", func(t *testing.T) {
		obj := &PublishScheduledShiftRequest{}
		var fernTestValueIdempotencyKey string
		obj.SetIdempotencyKey(fernTestValueIdempotencyKey)
		assert.Equal(t, fernTestValueIdempotencyKey, obj.IdempotencyKey)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetVersion", func(t *testing.T) {
		obj := &PublishScheduledShiftRequest{}
		var fernTestValueVersion *int
		obj.SetVersion(fernTestValueVersion)
		assert.Equal(t, fernTestValueVersion, obj.Version)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetScheduledShiftNotificationAudience", func(t *testing.T) {
		obj := &PublishScheduledShiftRequest{}
		var fernTestValueScheduledShiftNotificationAudience *ScheduledShiftNotificationAudience
		obj.SetScheduledShiftNotificationAudience(fernTestValueScheduledShiftNotificationAudience)
		assert.Equal(t, fernTestValueScheduledShiftNotificationAudience, obj.ScheduledShiftNotificationAudience)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitPublishScheduledShiftRequest(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PublishScheduledShiftRequest{}
		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("SetIdempotencyKey_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PublishScheduledShiftRequest{}
		var fernTestValueIdempotencyKey string

		// Act
		obj.SetIdempotencyKey(fernTestValueIdempotencyKey)

		// 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("SetVersion_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PublishScheduledShiftRequest{}
		var fernTestValueVersion *int

		// Act
		obj.SetVersion(fernTestValueVersion)

		// 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("SetScheduledShiftNotificationAudience_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PublishScheduledShiftRequest{}
		var fernTestValueScheduledShiftNotificationAudience *ScheduledShiftNotificationAudience

		// Act
		obj.SetScheduledShiftNotificationAudience(fernTestValueScheduledShiftNotificationAudience)

		// 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 TestSettersRetrieveScheduledShiftRequest(t *testing.T) {
	t.Run("SetID", func(t *testing.T) {
		obj := &RetrieveScheduledShiftRequest{}
		var fernTestValueID string
		obj.SetID(fernTestValueID)
		assert.Equal(t, fernTestValueID, obj.ID)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitRetrieveScheduledShiftRequest(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RetrieveScheduledShiftRequest{}
		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 TestSettersRetrieveTimecardRequest(t *testing.T) {
	t.Run("SetID", func(t *testing.T) {
		obj := &RetrieveTimecardRequest{}
		var fernTestValueID string
		obj.SetID(fernTestValueID)
		assert.Equal(t, fernTestValueID, obj.ID)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitRetrieveTimecardRequest(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RetrieveTimecardRequest{}
		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 TestSettersSearchScheduledShiftsRequest(t *testing.T) {
	t.Run("SetQuery", func(t *testing.T) {
		obj := &SearchScheduledShiftsRequest{}
		var fernTestValueQuery *ScheduledShiftQuery
		obj.SetQuery(fernTestValueQuery)
		assert.Equal(t, fernTestValueQuery, obj.Query)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetCursor", func(t *testing.T) {
		obj := &SearchScheduledShiftsRequest{}
		var fernTestValueCursor *string
		obj.SetCursor(fernTestValueCursor)
		assert.Equal(t, fernTestValueCursor, obj.Cursor)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitSearchScheduledShiftsRequest(t *testing.T) {
	t.Run("SetQuery_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchScheduledShiftsRequest{}
		var fernTestValueQuery *ScheduledShiftQuery

		// Act
		obj.SetQuery(fernTestValueQuery)

		// 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 := &SearchScheduledShiftsRequest{}
		var fernTestValueLimit *int

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

		// Act
		obj.SetCursor(fernTestValueCursor)

		// 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 TestSettersSearchTimecardsRequest(t *testing.T) {
	t.Run("SetQuery", func(t *testing.T) {
		obj := &SearchTimecardsRequest{}
		var fernTestValueQuery *TimecardQuery
		obj.SetQuery(fernTestValueQuery)
		assert.Equal(t, fernTestValueQuery, obj.Query)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetCursor", func(t *testing.T) {
		obj := &SearchTimecardsRequest{}
		var fernTestValueCursor *string
		obj.SetCursor(fernTestValueCursor)
		assert.Equal(t, fernTestValueCursor, obj.Cursor)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitSearchTimecardsRequest(t *testing.T) {
	t.Run("SetQuery_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchTimecardsRequest{}
		var fernTestValueQuery *TimecardQuery

		// Act
		obj.SetQuery(fernTestValueQuery)

		// 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 := &SearchTimecardsRequest{}
		var fernTestValueLimit *int

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

		// Act
		obj.SetCursor(fernTestValueCursor)

		// 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 TestSettersUpdateScheduledShiftRequest(t *testing.T) {
	t.Run("SetID", func(t *testing.T) {
		obj := &UpdateScheduledShiftRequest{}
		var fernTestValueID string
		obj.SetID(fernTestValueID)
		assert.Equal(t, fernTestValueID, obj.ID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetScheduledShift", func(t *testing.T) {
		obj := &UpdateScheduledShiftRequest{}
		var fernTestValueScheduledShift *ScheduledShift
		obj.SetScheduledShift(fernTestValueScheduledShift)
		assert.Equal(t, fernTestValueScheduledShift, obj.ScheduledShift)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitUpdateScheduledShiftRequest(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateScheduledShiftRequest{}
		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("SetScheduledShift_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateScheduledShiftRequest{}
		var fernTestValueScheduledShift *ScheduledShift

		// Act
		obj.SetScheduledShift(fernTestValueScheduledShift)

		// 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 TestSettersUpdateTimecardRequest(t *testing.T) {
	t.Run("SetID", func(t *testing.T) {
		obj := &UpdateTimecardRequest{}
		var fernTestValueID string
		obj.SetID(fernTestValueID)
		assert.Equal(t, fernTestValueID, obj.ID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetTimecard", func(t *testing.T) {
		obj := &UpdateTimecardRequest{}
		var fernTestValueTimecard *Timecard
		obj.SetTimecard(fernTestValueTimecard)
		assert.Equal(t, fernTestValueTimecard, obj.Timecard)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitUpdateTimecardRequest(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateTimecardRequest{}
		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("SetTimecard_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateTimecardRequest{}
		var fernTestValueTimecard *Timecard

		// Act
		obj.SetTimecard(fernTestValueTimecard)

		// 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 TestSettersBulkPublishScheduledShiftsData(t *testing.T) {
	t.Run("SetVersion", func(t *testing.T) {
		obj := &BulkPublishScheduledShiftsData{}
		var fernTestValueVersion *int
		obj.SetVersion(fernTestValueVersion)
		assert.Equal(t, fernTestValueVersion, obj.Version)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersBulkPublishScheduledShiftsData(t *testing.T) {
	t.Run("GetVersion", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BulkPublishScheduledShiftsData{}
		var expected *int
		obj.Version = expected

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

	t.Run("GetVersion_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BulkPublishScheduledShiftsData{}
		obj.Version = nil

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

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

}

func TestSettersMarkExplicitBulkPublishScheduledShiftsData(t *testing.T) {
	t.Run("SetVersion_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BulkPublishScheduledShiftsData{}
		var fernTestValueVersion *int

		// Act
		obj.SetVersion(fernTestValueVersion)

		// 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 TestSettersBulkPublishScheduledShiftsResponse(t *testing.T) {
	t.Run("SetResponses", func(t *testing.T) {
		obj := &BulkPublishScheduledShiftsResponse{}
		var fernTestValueResponses map[string]*PublishScheduledShiftResponse
		obj.SetResponses(fernTestValueResponses)
		assert.Equal(t, fernTestValueResponses, obj.Responses)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetErrors", func(t *testing.T) {
		obj := &BulkPublishScheduledShiftsResponse{}
		var fernTestValueErrors []*Error
		obj.SetErrors(fernTestValueErrors)
		assert.Equal(t, fernTestValueErrors, obj.Errors)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersBulkPublishScheduledShiftsResponse(t *testing.T) {
	t.Run("GetResponses", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BulkPublishScheduledShiftsResponse{}
		var expected map[string]*PublishScheduledShiftResponse
		obj.Responses = expected

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

	t.Run("GetResponses_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BulkPublishScheduledShiftsResponse{}
		obj.Responses = nil

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

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

	t.Run("GetErrors", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BulkPublishScheduledShiftsResponse{}
		var expected []*Error
		obj.Errors = expected

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

	t.Run("GetErrors_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BulkPublishScheduledShiftsResponse{}
		obj.Errors = nil

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

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

}

func TestSettersMarkExplicitBulkPublishScheduledShiftsResponse(t *testing.T) {
	t.Run("SetResponses_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BulkPublishScheduledShiftsResponse{}
		var fernTestValueResponses map[string]*PublishScheduledShiftResponse

		// Act
		obj.SetResponses(fernTestValueResponses)

		// 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("SetErrors_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BulkPublishScheduledShiftsResponse{}
		var fernTestValueErrors []*Error

		// Act
		obj.SetErrors(fernTestValueErrors)

		// 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 TestSettersCreateScheduledShiftResponse(t *testing.T) {
	t.Run("SetScheduledShift", func(t *testing.T) {
		obj := &CreateScheduledShiftResponse{}
		var fernTestValueScheduledShift *ScheduledShift
		obj.SetScheduledShift(fernTestValueScheduledShift)
		assert.Equal(t, fernTestValueScheduledShift, obj.ScheduledShift)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetErrors", func(t *testing.T) {
		obj := &CreateScheduledShiftResponse{}
		var fernTestValueErrors []*Error
		obj.SetErrors(fernTestValueErrors)
		assert.Equal(t, fernTestValueErrors, obj.Errors)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersCreateScheduledShiftResponse(t *testing.T) {
	t.Run("GetScheduledShift", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateScheduledShiftResponse{}
		var expected *ScheduledShift
		obj.ScheduledShift = expected

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

	t.Run("GetScheduledShift_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateScheduledShiftResponse{}
		obj.ScheduledShift = nil

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

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

	t.Run("GetErrors", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateScheduledShiftResponse{}
		var expected []*Error
		obj.Errors = expected

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

	t.Run("GetErrors_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateScheduledShiftResponse{}
		obj.Errors = nil

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

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

}

func TestSettersMarkExplicitCreateScheduledShiftResponse(t *testing.T) {
	t.Run("SetScheduledShift_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateScheduledShiftResponse{}
		var fernTestValueScheduledShift *ScheduledShift

		// Act
		obj.SetScheduledShift(fernTestValueScheduledShift)

		// 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("SetErrors_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateScheduledShiftResponse{}
		var fernTestValueErrors []*Error

		// Act
		obj.SetErrors(fernTestValueErrors)

		// 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 TestSettersCreateTimecardResponse(t *testing.T) {
	t.Run("SetTimecard", func(t *testing.T) {
		obj := &CreateTimecardResponse{}
		var fernTestValueTimecard *Timecard
		obj.SetTimecard(fernTestValueTimecard)
		assert.Equal(t, fernTestValueTimecard, obj.Timecard)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetErrors", func(t *testing.T) {
		obj := &CreateTimecardResponse{}
		var fernTestValueErrors []*Error
		obj.SetErrors(fernTestValueErrors)
		assert.Equal(t, fernTestValueErrors, obj.Errors)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersCreateTimecardResponse(t *testing.T) {
	t.Run("GetTimecard", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateTimecardResponse{}
		var expected *Timecard
		obj.Timecard = expected

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

	t.Run("GetTimecard_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateTimecardResponse{}
		obj.Timecard = nil

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

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

	t.Run("GetErrors", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateTimecardResponse{}
		var expected []*Error
		obj.Errors = expected

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

	t.Run("GetErrors_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateTimecardResponse{}
		obj.Errors = nil

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

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

}

func TestSettersMarkExplicitCreateTimecardResponse(t *testing.T) {
	t.Run("SetTimecard_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateTimecardResponse{}
		var fernTestValueTimecard *Timecard

		// Act
		obj.SetTimecard(fernTestValueTimecard)

		// 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("SetErrors_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CreateTimecardResponse{}
		var fernTestValueErrors []*Error

		// Act
		obj.SetErrors(fernTestValueErrors)

		// 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 TestSettersDeleteTimecardResponse(t *testing.T) {
	t.Run("SetErrors", func(t *testing.T) {
		obj := &DeleteTimecardResponse{}
		var fernTestValueErrors []*Error
		obj.SetErrors(fernTestValueErrors)
		assert.Equal(t, fernTestValueErrors, obj.Errors)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDeleteTimecardResponse(t *testing.T) {
	t.Run("GetErrors", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DeleteTimecardResponse{}
		var expected []*Error
		obj.Errors = expected

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

	t.Run("GetErrors_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DeleteTimecardResponse{}
		obj.Errors = nil

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

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

}

func TestSettersMarkExplicitDeleteTimecardResponse(t *testing.T) {
	t.Run("SetErrors_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DeleteTimecardResponse{}
		var fernTestValueErrors []*Error

		// Act
		obj.SetErrors(fernTestValueErrors)

		// 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 TestSettersPublishScheduledShiftResponse(t *testing.T) {
	t.Run("SetScheduledShift", func(t *testing.T) {
		obj := &PublishScheduledShiftResponse{}
		var fernTestValueScheduledShift *ScheduledShift
		obj.SetScheduledShift(fernTestValueScheduledShift)
		assert.Equal(t, fernTestValueScheduledShift, obj.ScheduledShift)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetErrors", func(t *testing.T) {
		obj := &PublishScheduledShiftResponse{}
		var fernTestValueErrors []*Error
		obj.SetErrors(fernTestValueErrors)
		assert.Equal(t, fernTestValueErrors, obj.Errors)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersPublishScheduledShiftResponse(t *testing.T) {
	t.Run("GetScheduledShift", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PublishScheduledShiftResponse{}
		var expected *ScheduledShift
		obj.ScheduledShift = expected

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

	t.Run("GetScheduledShift_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PublishScheduledShiftResponse{}
		obj.ScheduledShift = nil

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

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

	t.Run("GetErrors", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PublishScheduledShiftResponse{}
		var expected []*Error
		obj.Errors = expected

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

	t.Run("GetErrors_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PublishScheduledShiftResponse{}
		obj.Errors = nil

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

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

}

func TestSettersMarkExplicitPublishScheduledShiftResponse(t *testing.T) {
	t.Run("SetScheduledShift_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PublishScheduledShiftResponse{}
		var fernTestValueScheduledShift *ScheduledShift

		// Act
		obj.SetScheduledShift(fernTestValueScheduledShift)

		// 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("SetErrors_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PublishScheduledShiftResponse{}
		var fernTestValueErrors []*Error

		// Act
		obj.SetErrors(fernTestValueErrors)

		// 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 TestSettersRetrieveScheduledShiftResponse(t *testing.T) {
	t.Run("SetScheduledShift", func(t *testing.T) {
		obj := &RetrieveScheduledShiftResponse{}
		var fernTestValueScheduledShift *ScheduledShift
		obj.SetScheduledShift(fernTestValueScheduledShift)
		assert.Equal(t, fernTestValueScheduledShift, obj.ScheduledShift)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetErrors", func(t *testing.T) {
		obj := &RetrieveScheduledShiftResponse{}
		var fernTestValueErrors []*Error
		obj.SetErrors(fernTestValueErrors)
		assert.Equal(t, fernTestValueErrors, obj.Errors)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersRetrieveScheduledShiftResponse(t *testing.T) {
	t.Run("GetScheduledShift", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RetrieveScheduledShiftResponse{}
		var expected *ScheduledShift
		obj.ScheduledShift = expected

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

	t.Run("GetScheduledShift_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RetrieveScheduledShiftResponse{}
		obj.ScheduledShift = nil

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

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

	t.Run("GetErrors", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RetrieveScheduledShiftResponse{}
		var expected []*Error
		obj.Errors = expected

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

	t.Run("GetErrors_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RetrieveScheduledShiftResponse{}
		obj.Errors = nil

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

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

}

func TestSettersMarkExplicitRetrieveScheduledShiftResponse(t *testing.T) {
	t.Run("SetScheduledShift_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RetrieveScheduledShiftResponse{}
		var fernTestValueScheduledShift *ScheduledShift

		// Act
		obj.SetScheduledShift(fernTestValueScheduledShift)

		// 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("SetErrors_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RetrieveScheduledShiftResponse{}
		var fernTestValueErrors []*Error

		// Act
		obj.SetErrors(fernTestValueErrors)

		// 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 TestSettersRetrieveTimecardResponse(t *testing.T) {
	t.Run("SetTimecard", func(t *testing.T) {
		obj := &RetrieveTimecardResponse{}
		var fernTestValueTimecard *Timecard
		obj.SetTimecard(fernTestValueTimecard)
		assert.Equal(t, fernTestValueTimecard, obj.Timecard)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetErrors", func(t *testing.T) {
		obj := &RetrieveTimecardResponse{}
		var fernTestValueErrors []*Error
		obj.SetErrors(fernTestValueErrors)
		assert.Equal(t, fernTestValueErrors, obj.Errors)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersRetrieveTimecardResponse(t *testing.T) {
	t.Run("GetTimecard", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RetrieveTimecardResponse{}
		var expected *Timecard
		obj.Timecard = expected

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

	t.Run("GetTimecard_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RetrieveTimecardResponse{}
		obj.Timecard = nil

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

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

	t.Run("GetErrors", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RetrieveTimecardResponse{}
		var expected []*Error
		obj.Errors = expected

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

	t.Run("GetErrors_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RetrieveTimecardResponse{}
		obj.Errors = nil

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

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

}

func TestSettersMarkExplicitRetrieveTimecardResponse(t *testing.T) {
	t.Run("SetTimecard_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RetrieveTimecardResponse{}
		var fernTestValueTimecard *Timecard

		// Act
		obj.SetTimecard(fernTestValueTimecard)

		// 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("SetErrors_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RetrieveTimecardResponse{}
		var fernTestValueErrors []*Error

		// Act
		obj.SetErrors(fernTestValueErrors)

		// 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 TestSettersScheduledShift(t *testing.T) {
	t.Run("SetID", func(t *testing.T) {
		obj := &ScheduledShift{}
		var fernTestValueID *string
		obj.SetID(fernTestValueID)
		assert.Equal(t, fernTestValueID, obj.ID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetDraftShiftDetails", func(t *testing.T) {
		obj := &ScheduledShift{}
		var fernTestValueDraftShiftDetails *ScheduledShiftDetails
		obj.SetDraftShiftDetails(fernTestValueDraftShiftDetails)
		assert.Equal(t, fernTestValueDraftShiftDetails, obj.DraftShiftDetails)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetPublishedShiftDetails", func(t *testing.T) {
		obj := &ScheduledShift{}
		var fernTestValuePublishedShiftDetails *ScheduledShiftDetails
		obj.SetPublishedShiftDetails(fernTestValuePublishedShiftDetails)
		assert.Equal(t, fernTestValuePublishedShiftDetails, obj.PublishedShiftDetails)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetVersion", func(t *testing.T) {
		obj := &ScheduledShift{}
		var fernTestValueVersion *int
		obj.SetVersion(fernTestValueVersion)
		assert.Equal(t, fernTestValueVersion, obj.Version)
		assert.NotNil(t, obj.explicitFields)
	})

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

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

}

func TestGettersScheduledShift(t *testing.T) {
	t.Run("GetID", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShift{}
		var expected *string
		obj.ID = expected

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

	t.Run("GetID_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShift{}
		obj.ID = nil

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

	t.Run("GetID_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *ScheduledShift
		// 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("GetDraftShiftDetails", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShift{}
		var expected *ScheduledShiftDetails
		obj.DraftShiftDetails = expected

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

	t.Run("GetDraftShiftDetails_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShift{}
		obj.DraftShiftDetails = nil

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

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

	t.Run("GetPublishedShiftDetails", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShift{}
		var expected *ScheduledShiftDetails
		obj.PublishedShiftDetails = expected

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

	t.Run("GetPublishedShiftDetails_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShift{}
		obj.PublishedShiftDetails = nil

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

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

	t.Run("GetVersion", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShift{}
		var expected *int
		obj.Version = expected

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

	t.Run("GetVersion_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShift{}
		obj.Version = nil

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

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

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

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

	t.Run("GetCreatedAt_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShift{}
		obj.CreatedAt = nil

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

	t.Run("GetCreatedAt_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *ScheduledShift
		// 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 := &ScheduledShift{}
		var expected *string
		obj.UpdatedAt = expected

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

	t.Run("GetUpdatedAt_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShift{}
		obj.UpdatedAt = nil

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

	t.Run("GetUpdatedAt_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *ScheduledShift
		// 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
	})

}

func TestSettersMarkExplicitScheduledShift(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShift{}
		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("SetDraftShiftDetails_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShift{}
		var fernTestValueDraftShiftDetails *ScheduledShiftDetails

		// Act
		obj.SetDraftShiftDetails(fernTestValueDraftShiftDetails)

		// 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("SetPublishedShiftDetails_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShift{}
		var fernTestValuePublishedShiftDetails *ScheduledShiftDetails

		// Act
		obj.SetPublishedShiftDetails(fernTestValuePublishedShiftDetails)

		// 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("SetVersion_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShift{}
		var fernTestValueVersion *int

		// Act
		obj.SetVersion(fernTestValueVersion)

		// 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 := &ScheduledShift{}
		var fernTestValueCreatedAt *string

		// 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 := &ScheduledShift{}
		var fernTestValueUpdatedAt *string

		// 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
	})

}

func TestSettersScheduledShiftDetails(t *testing.T) {
	t.Run("SetTeamMemberID", func(t *testing.T) {
		obj := &ScheduledShiftDetails{}
		var fernTestValueTeamMemberID *string
		obj.SetTeamMemberID(fernTestValueTeamMemberID)
		assert.Equal(t, fernTestValueTeamMemberID, obj.TeamMemberID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetLocationID", func(t *testing.T) {
		obj := &ScheduledShiftDetails{}
		var fernTestValueLocationID *string
		obj.SetLocationID(fernTestValueLocationID)
		assert.Equal(t, fernTestValueLocationID, obj.LocationID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetJobID", func(t *testing.T) {
		obj := &ScheduledShiftDetails{}
		var fernTestValueJobID *string
		obj.SetJobID(fernTestValueJobID)
		assert.Equal(t, fernTestValueJobID, obj.JobID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStartAt", func(t *testing.T) {
		obj := &ScheduledShiftDetails{}
		var fernTestValueStartAt *string
		obj.SetStartAt(fernTestValueStartAt)
		assert.Equal(t, fernTestValueStartAt, obj.StartAt)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetEndAt", func(t *testing.T) {
		obj := &ScheduledShiftDetails{}
		var fernTestValueEndAt *string
		obj.SetEndAt(fernTestValueEndAt)
		assert.Equal(t, fernTestValueEndAt, obj.EndAt)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetNotes", func(t *testing.T) {
		obj := &ScheduledShiftDetails{}
		var fernTestValueNotes *string
		obj.SetNotes(fernTestValueNotes)
		assert.Equal(t, fernTestValueNotes, obj.Notes)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetIsDeleted", func(t *testing.T) {
		obj := &ScheduledShiftDetails{}
		var fernTestValueIsDeleted *bool
		obj.SetIsDeleted(fernTestValueIsDeleted)
		assert.Equal(t, fernTestValueIsDeleted, obj.IsDeleted)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetTimezone", func(t *testing.T) {
		obj := &ScheduledShiftDetails{}
		var fernTestValueTimezone *string
		obj.SetTimezone(fernTestValueTimezone)
		assert.Equal(t, fernTestValueTimezone, obj.Timezone)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersScheduledShiftDetails(t *testing.T) {
	t.Run("GetTeamMemberID", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		var expected *string
		obj.TeamMemberID = expected

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

	t.Run("GetTeamMemberID_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		obj.TeamMemberID = nil

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

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

	t.Run("GetLocationID", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		var expected *string
		obj.LocationID = expected

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

	t.Run("GetLocationID_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		obj.LocationID = nil

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

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

	t.Run("GetJobID", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		var expected *string
		obj.JobID = expected

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

	t.Run("GetJobID_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		obj.JobID = nil

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

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

	t.Run("GetStartAt", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		var expected *string
		obj.StartAt = expected

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

	t.Run("GetStartAt_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		obj.StartAt = nil

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

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

	t.Run("GetEndAt", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		var expected *string
		obj.EndAt = expected

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

	t.Run("GetEndAt_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		obj.EndAt = nil

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

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

	t.Run("GetNotes", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		var expected *string
		obj.Notes = expected

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

	t.Run("GetNotes_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		obj.Notes = nil

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

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

	t.Run("GetIsDeleted", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		var expected *bool
		obj.IsDeleted = expected

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

	t.Run("GetIsDeleted_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		obj.IsDeleted = nil

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

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

	t.Run("GetTimezone", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		var expected *string
		obj.Timezone = expected

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

	t.Run("GetTimezone_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		obj.Timezone = nil

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

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

}

func TestSettersMarkExplicitScheduledShiftDetails(t *testing.T) {
	t.Run("SetTeamMemberID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		var fernTestValueTeamMemberID *string

		// Act
		obj.SetTeamMemberID(fernTestValueTeamMemberID)

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

		// Act
		obj.SetLocationID(fernTestValueLocationID)

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

		// Act
		obj.SetJobID(fernTestValueJobID)

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

		// Act
		obj.SetStartAt(fernTestValueStartAt)

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

		// Act
		obj.SetEndAt(fernTestValueEndAt)

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

		// Act
		obj.SetNotes(fernTestValueNotes)

		// 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("SetIsDeleted_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftDetails{}
		var fernTestValueIsDeleted *bool

		// Act
		obj.SetIsDeleted(fernTestValueIsDeleted)

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

		// Act
		obj.SetTimezone(fernTestValueTimezone)

		// 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 TestSettersScheduledShiftFilter(t *testing.T) {
	t.Run("SetLocationIDs", func(t *testing.T) {
		obj := &ScheduledShiftFilter{}
		var fernTestValueLocationIDs []string
		obj.SetLocationIDs(fernTestValueLocationIDs)
		assert.Equal(t, fernTestValueLocationIDs, obj.LocationIDs)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStart", func(t *testing.T) {
		obj := &ScheduledShiftFilter{}
		var fernTestValueStart *TimeRange
		obj.SetStart(fernTestValueStart)
		assert.Equal(t, fernTestValueStart, obj.Start)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetEnd", func(t *testing.T) {
		obj := &ScheduledShiftFilter{}
		var fernTestValueEnd *TimeRange
		obj.SetEnd(fernTestValueEnd)
		assert.Equal(t, fernTestValueEnd, obj.End)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetWorkday", func(t *testing.T) {
		obj := &ScheduledShiftFilter{}
		var fernTestValueWorkday *ScheduledShiftWorkday
		obj.SetWorkday(fernTestValueWorkday)
		assert.Equal(t, fernTestValueWorkday, obj.Workday)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetTeamMemberIDs", func(t *testing.T) {
		obj := &ScheduledShiftFilter{}
		var fernTestValueTeamMemberIDs []string
		obj.SetTeamMemberIDs(fernTestValueTeamMemberIDs)
		assert.Equal(t, fernTestValueTeamMemberIDs, obj.TeamMemberIDs)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetAssignmentStatus", func(t *testing.T) {
		obj := &ScheduledShiftFilter{}
		var fernTestValueAssignmentStatus *ScheduledShiftFilterAssignmentStatus
		obj.SetAssignmentStatus(fernTestValueAssignmentStatus)
		assert.Equal(t, fernTestValueAssignmentStatus, obj.AssignmentStatus)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetScheduledShiftStatuses", func(t *testing.T) {
		obj := &ScheduledShiftFilter{}
		var fernTestValueScheduledShiftStatuses []ScheduledShiftFilterScheduledShiftStatus
		obj.SetScheduledShiftStatuses(fernTestValueScheduledShiftStatuses)
		assert.Equal(t, fernTestValueScheduledShiftStatuses, obj.ScheduledShiftStatuses)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersScheduledShiftFilter(t *testing.T) {
	t.Run("GetLocationIDs", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		var expected []string
		obj.LocationIDs = expected

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

	t.Run("GetLocationIDs_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		obj.LocationIDs = nil

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

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

	t.Run("GetStart", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		var expected *TimeRange
		obj.Start = expected

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

	t.Run("GetStart_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		obj.Start = nil

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

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

	t.Run("GetEnd", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		var expected *TimeRange
		obj.End = expected

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

	t.Run("GetEnd_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		obj.End = nil

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

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

	t.Run("GetWorkday", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		var expected *ScheduledShiftWorkday
		obj.Workday = expected

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

	t.Run("GetWorkday_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		obj.Workday = nil

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

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

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

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

	t.Run("GetTeamMemberIDs_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		obj.TeamMemberIDs = nil

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

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

	t.Run("GetAssignmentStatus", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		var expected *ScheduledShiftFilterAssignmentStatus
		obj.AssignmentStatus = expected

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

	t.Run("GetAssignmentStatus_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		obj.AssignmentStatus = nil

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

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

	t.Run("GetScheduledShiftStatuses", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		var expected []ScheduledShiftFilterScheduledShiftStatus
		obj.ScheduledShiftStatuses = expected

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

	t.Run("GetScheduledShiftStatuses_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		obj.ScheduledShiftStatuses = nil

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

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

}

func TestSettersMarkExplicitScheduledShiftFilter(t *testing.T) {
	t.Run("SetLocationIDs_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		var fernTestValueLocationIDs []string

		// Act
		obj.SetLocationIDs(fernTestValueLocationIDs)

		// 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("SetStart_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		var fernTestValueStart *TimeRange

		// Act
		obj.SetStart(fernTestValueStart)

		// 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("SetEnd_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		var fernTestValueEnd *TimeRange

		// Act
		obj.SetEnd(fernTestValueEnd)

		// 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("SetWorkday_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		var fernTestValueWorkday *ScheduledShiftWorkday

		// Act
		obj.SetWorkday(fernTestValueWorkday)

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

		// Act
		obj.SetTeamMemberIDs(fernTestValueTeamMemberIDs)

		// 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("SetAssignmentStatus_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		var fernTestValueAssignmentStatus *ScheduledShiftFilterAssignmentStatus

		// Act
		obj.SetAssignmentStatus(fernTestValueAssignmentStatus)

		// 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("SetScheduledShiftStatuses_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftFilter{}
		var fernTestValueScheduledShiftStatuses []ScheduledShiftFilterScheduledShiftStatus

		// Act
		obj.SetScheduledShiftStatuses(fernTestValueScheduledShiftStatuses)

		// 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 TestSettersScheduledShiftQuery(t *testing.T) {
	t.Run("SetFilter", func(t *testing.T) {
		obj := &ScheduledShiftQuery{}
		var fernTestValueFilter *ScheduledShiftFilter
		obj.SetFilter(fernTestValueFilter)
		assert.Equal(t, fernTestValueFilter, obj.Filter)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSort", func(t *testing.T) {
		obj := &ScheduledShiftQuery{}
		var fernTestValueSort *ScheduledShiftSort
		obj.SetSort(fernTestValueSort)
		assert.Equal(t, fernTestValueSort, obj.Sort)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersScheduledShiftQuery(t *testing.T) {
	t.Run("GetFilter", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftQuery{}
		var expected *ScheduledShiftFilter
		obj.Filter = expected

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

	t.Run("GetFilter_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftQuery{}
		obj.Filter = nil

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

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

	t.Run("GetSort", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftQuery{}
		var expected *ScheduledShiftSort
		obj.Sort = expected

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

	t.Run("GetSort_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftQuery{}
		obj.Sort = nil

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

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

}

func TestSettersMarkExplicitScheduledShiftQuery(t *testing.T) {
	t.Run("SetFilter_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftQuery{}
		var fernTestValueFilter *ScheduledShiftFilter

		// Act
		obj.SetFilter(fernTestValueFilter)

		// 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("SetSort_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftQuery{}
		var fernTestValueSort *ScheduledShiftSort

		// Act
		obj.SetSort(fernTestValueSort)

		// 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 TestSettersScheduledShiftSort(t *testing.T) {
	t.Run("SetField", func(t *testing.T) {
		obj := &ScheduledShiftSort{}
		var fernTestValueField *ScheduledShiftSortField
		obj.SetField(fernTestValueField)
		assert.Equal(t, fernTestValueField, obj.Field)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetOrder", func(t *testing.T) {
		obj := &ScheduledShiftSort{}
		var fernTestValueOrder *SortOrder
		obj.SetOrder(fernTestValueOrder)
		assert.Equal(t, fernTestValueOrder, obj.Order)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersScheduledShiftSort(t *testing.T) {
	t.Run("GetField", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftSort{}
		var expected *ScheduledShiftSortField
		obj.Field = expected

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

	t.Run("GetField_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftSort{}
		obj.Field = nil

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

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

	t.Run("GetOrder", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftSort{}
		var expected *SortOrder
		obj.Order = expected

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

	t.Run("GetOrder_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftSort{}
		obj.Order = nil

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

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

}

func TestSettersMarkExplicitScheduledShiftSort(t *testing.T) {
	t.Run("SetField_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftSort{}
		var fernTestValueField *ScheduledShiftSortField

		// Act
		obj.SetField(fernTestValueField)

		// 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("SetOrder_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftSort{}
		var fernTestValueOrder *SortOrder

		// Act
		obj.SetOrder(fernTestValueOrder)

		// 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 TestSettersScheduledShiftWorkday(t *testing.T) {
	t.Run("SetDateRange", func(t *testing.T) {
		obj := &ScheduledShiftWorkday{}
		var fernTestValueDateRange *DateRange
		obj.SetDateRange(fernTestValueDateRange)
		assert.Equal(t, fernTestValueDateRange, obj.DateRange)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMatchScheduledShiftsBy", func(t *testing.T) {
		obj := &ScheduledShiftWorkday{}
		var fernTestValueMatchScheduledShiftsBy *ScheduledShiftWorkdayMatcher
		obj.SetMatchScheduledShiftsBy(fernTestValueMatchScheduledShiftsBy)
		assert.Equal(t, fernTestValueMatchScheduledShiftsBy, obj.MatchScheduledShiftsBy)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetDefaultTimezone", func(t *testing.T) {
		obj := &ScheduledShiftWorkday{}
		var fernTestValueDefaultTimezone *string
		obj.SetDefaultTimezone(fernTestValueDefaultTimezone)
		assert.Equal(t, fernTestValueDefaultTimezone, obj.DefaultTimezone)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersScheduledShiftWorkday(t *testing.T) {
	t.Run("GetDateRange", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftWorkday{}
		var expected *DateRange
		obj.DateRange = expected

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

	t.Run("GetDateRange_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftWorkday{}
		obj.DateRange = nil

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

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

	t.Run("GetMatchScheduledShiftsBy", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftWorkday{}
		var expected *ScheduledShiftWorkdayMatcher
		obj.MatchScheduledShiftsBy = expected

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

	t.Run("GetMatchScheduledShiftsBy_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftWorkday{}
		obj.MatchScheduledShiftsBy = nil

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

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

	t.Run("GetDefaultTimezone", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftWorkday{}
		var expected *string
		obj.DefaultTimezone = expected

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

	t.Run("GetDefaultTimezone_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftWorkday{}
		obj.DefaultTimezone = nil

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

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

}

func TestSettersMarkExplicitScheduledShiftWorkday(t *testing.T) {
	t.Run("SetDateRange_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftWorkday{}
		var fernTestValueDateRange *DateRange

		// Act
		obj.SetDateRange(fernTestValueDateRange)

		// 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("SetMatchScheduledShiftsBy_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ScheduledShiftWorkday{}
		var fernTestValueMatchScheduledShiftsBy *ScheduledShiftWorkdayMatcher

		// Act
		obj.SetMatchScheduledShiftsBy(fernTestValueMatchScheduledShiftsBy)

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

		// Act
		obj.SetDefaultTimezone(fernTestValueDefaultTimezone)

		// 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 TestSettersSearchScheduledShiftsResponse(t *testing.T) {
	t.Run("SetScheduledShifts", func(t *testing.T) {
		obj := &SearchScheduledShiftsResponse{}
		var fernTestValueScheduledShifts []*ScheduledShift
		obj.SetScheduledShifts(fernTestValueScheduledShifts)
		assert.Equal(t, fernTestValueScheduledShifts, obj.ScheduledShifts)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCursor", func(t *testing.T) {
		obj := &SearchScheduledShiftsResponse{}
		var fernTestValueCursor *string
		obj.SetCursor(fernTestValueCursor)
		assert.Equal(t, fernTestValueCursor, obj.Cursor)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetErrors", func(t *testing.T) {
		obj := &SearchScheduledShiftsResponse{}
		var fernTestValueErrors []*Error
		obj.SetErrors(fernTestValueErrors)
		assert.Equal(t, fernTestValueErrors, obj.Errors)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersSearchScheduledShiftsResponse(t *testing.T) {
	t.Run("GetScheduledShifts", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchScheduledShiftsResponse{}
		var expected []*ScheduledShift
		obj.ScheduledShifts = expected

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

	t.Run("GetScheduledShifts_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchScheduledShiftsResponse{}
		obj.ScheduledShifts = nil

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

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

	t.Run("GetCursor", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchScheduledShiftsResponse{}
		var expected *string
		obj.Cursor = expected

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

	t.Run("GetCursor_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchScheduledShiftsResponse{}
		obj.Cursor = nil

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

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

	t.Run("GetErrors", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchScheduledShiftsResponse{}
		var expected []*Error
		obj.Errors = expected

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

	t.Run("GetErrors_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchScheduledShiftsResponse{}
		obj.Errors = nil

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

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

}

func TestSettersMarkExplicitSearchScheduledShiftsResponse(t *testing.T) {
	t.Run("SetScheduledShifts_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchScheduledShiftsResponse{}
		var fernTestValueScheduledShifts []*ScheduledShift

		// Act
		obj.SetScheduledShifts(fernTestValueScheduledShifts)

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

		// Act
		obj.SetCursor(fernTestValueCursor)

		// 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("SetErrors_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchScheduledShiftsResponse{}
		var fernTestValueErrors []*Error

		// Act
		obj.SetErrors(fernTestValueErrors)

		// 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 TestSettersSearchTimecardsResponse(t *testing.T) {
	t.Run("SetTimecards", func(t *testing.T) {
		obj := &SearchTimecardsResponse{}
		var fernTestValueTimecards []*Timecard
		obj.SetTimecards(fernTestValueTimecards)
		assert.Equal(t, fernTestValueTimecards, obj.Timecards)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCursor", func(t *testing.T) {
		obj := &SearchTimecardsResponse{}
		var fernTestValueCursor *string
		obj.SetCursor(fernTestValueCursor)
		assert.Equal(t, fernTestValueCursor, obj.Cursor)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetErrors", func(t *testing.T) {
		obj := &SearchTimecardsResponse{}
		var fernTestValueErrors []*Error
		obj.SetErrors(fernTestValueErrors)
		assert.Equal(t, fernTestValueErrors, obj.Errors)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersSearchTimecardsResponse(t *testing.T) {
	t.Run("GetTimecards", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchTimecardsResponse{}
		var expected []*Timecard
		obj.Timecards = expected

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

	t.Run("GetTimecards_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchTimecardsResponse{}
		obj.Timecards = nil

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

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

	t.Run("GetCursor", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchTimecardsResponse{}
		var expected *string
		obj.Cursor = expected

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

	t.Run("GetCursor_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchTimecardsResponse{}
		obj.Cursor = nil

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

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

	t.Run("GetErrors", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchTimecardsResponse{}
		var expected []*Error
		obj.Errors = expected

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

	t.Run("GetErrors_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchTimecardsResponse{}
		obj.Errors = nil

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

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

}

func TestSettersMarkExplicitSearchTimecardsResponse(t *testing.T) {
	t.Run("SetTimecards_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchTimecardsResponse{}
		var fernTestValueTimecards []*Timecard

		// Act
		obj.SetTimecards(fernTestValueTimecards)

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

		// Act
		obj.SetCursor(fernTestValueCursor)

		// 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("SetErrors_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SearchTimecardsResponse{}
		var fernTestValueErrors []*Error

		// Act
		obj.SetErrors(fernTestValueErrors)

		// 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 TestSettersTimecard(t *testing.T) {
	t.Run("SetID", func(t *testing.T) {
		obj := &Timecard{}
		var fernTestValueID *string
		obj.SetID(fernTestValueID)
		assert.Equal(t, fernTestValueID, obj.ID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetLocationID", func(t *testing.T) {
		obj := &Timecard{}
		var fernTestValueLocationID string
		obj.SetLocationID(fernTestValueLocationID)
		assert.Equal(t, fernTestValueLocationID, obj.LocationID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetTimezone", func(t *testing.T) {
		obj := &Timecard{}
		var fernTestValueTimezone *string
		obj.SetTimezone(fernTestValueTimezone)
		assert.Equal(t, fernTestValueTimezone, obj.Timezone)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStartAt", func(t *testing.T) {
		obj := &Timecard{}
		var fernTestValueStartAt string
		obj.SetStartAt(fernTestValueStartAt)
		assert.Equal(t, fernTestValueStartAt, obj.StartAt)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetEndAt", func(t *testing.T) {
		obj := &Timecard{}
		var fernTestValueEndAt *string
		obj.SetEndAt(fernTestValueEndAt)
		assert.Equal(t, fernTestValueEndAt, obj.EndAt)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetWage", func(t *testing.T) {
		obj := &Timecard{}
		var fernTestValueWage *TimecardWage
		obj.SetWage(fernTestValueWage)
		assert.Equal(t, fernTestValueWage, obj.Wage)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetBreaks", func(t *testing.T) {
		obj := &Timecard{}
		var fernTestValueBreaks []*Break
		obj.SetBreaks(fernTestValueBreaks)
		assert.Equal(t, fernTestValueBreaks, obj.Breaks)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetVersion", func(t *testing.T) {
		obj := &Timecard{}
		var fernTestValueVersion *int
		obj.SetVersion(fernTestValueVersion)
		assert.Equal(t, fernTestValueVersion, obj.Version)
		assert.NotNil(t, obj.explicitFields)
	})

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

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

	t.Run("SetTeamMemberID", func(t *testing.T) {
		obj := &Timecard{}
		var fernTestValueTeamMemberID string
		obj.SetTeamMemberID(fernTestValueTeamMemberID)
		assert.Equal(t, fernTestValueTeamMemberID, obj.TeamMemberID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetDeclaredCashTipMoney", func(t *testing.T) {
		obj := &Timecard{}
		var fernTestValueDeclaredCashTipMoney *Money
		obj.SetDeclaredCashTipMoney(fernTestValueDeclaredCashTipMoney)
		assert.Equal(t, fernTestValueDeclaredCashTipMoney, obj.DeclaredCashTipMoney)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersTimecard(t *testing.T) {
	t.Run("GetID", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var expected *string
		obj.ID = expected

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

	t.Run("GetID_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		obj.ID = nil

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

	t.Run("GetID_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Timecard
		// 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("GetLocationID", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var expected string
		obj.LocationID = expected

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

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

	t.Run("GetTimezone", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var expected *string
		obj.Timezone = expected

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

	t.Run("GetTimezone_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		obj.Timezone = nil

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

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

	t.Run("GetStartAt", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var expected string
		obj.StartAt = expected

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

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

	t.Run("GetEndAt", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var expected *string
		obj.EndAt = expected

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

	t.Run("GetEndAt_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		obj.EndAt = nil

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

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

	t.Run("GetWage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var expected *TimecardWage
		obj.Wage = expected

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

	t.Run("GetWage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		obj.Wage = nil

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

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

	t.Run("GetBreaks", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var expected []*Break
		obj.Breaks = expected

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

	t.Run("GetBreaks_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		obj.Breaks = nil

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

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

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

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

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

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

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

	t.Run("GetVersion", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var expected *int
		obj.Version = expected

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

	t.Run("GetVersion_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		obj.Version = nil

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

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

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

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

	t.Run("GetCreatedAt_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		obj.CreatedAt = nil

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

	t.Run("GetCreatedAt_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Timecard
		// 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 := &Timecard{}
		var expected *string
		obj.UpdatedAt = expected

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

	t.Run("GetUpdatedAt_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		obj.UpdatedAt = nil

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

	t.Run("GetUpdatedAt_NilReceiver", func(t *testing.T) {
		t.Parallel()
		var obj *Timecard
		// 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("GetTeamMemberID", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var expected string
		obj.TeamMemberID = expected

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

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

	t.Run("GetDeclaredCashTipMoney", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var expected *Money
		obj.DeclaredCashTipMoney = expected

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

	t.Run("GetDeclaredCashTipMoney_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		obj.DeclaredCashTipMoney = nil

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

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

}

func TestSettersMarkExplicitTimecard(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		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("SetLocationID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var fernTestValueLocationID string

		// Act
		obj.SetLocationID(fernTestValueLocationID)

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

		// Act
		obj.SetTimezone(fernTestValueTimezone)

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

		// Act
		obj.SetStartAt(fernTestValueStartAt)

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

		// Act
		obj.SetEndAt(fernTestValueEndAt)

		// 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("SetWage_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var fernTestValueWage *TimecardWage

		// Act
		obj.SetWage(fernTestValueWage)

		// 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("SetBreaks_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var fernTestValueBreaks []*Break

		// Act
		obj.SetBreaks(fernTestValueBreaks)

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

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

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

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

		// Act
		obj.SetStatus(fernTestValueStatus)

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

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

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

	t.Run("SetVersion_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var fernTestValueVersion *int

		// Act
		obj.SetVersion(fernTestValueVersion)

		// 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 := &Timecard{}
		var fernTestValueCreatedAt *string

		// 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 := &Timecard{}
		var fernTestValueUpdatedAt *string

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

		// Act
		obj.SetTeamMemberID(fernTestValueTeamMemberID)

		// 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("SetDeclaredCashTipMoney_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Timecard{}
		var fernTestValueDeclaredCashTipMoney *Money

		// Act
		obj.SetDeclaredCashTipMoney(fernTestValueDeclaredCashTipMoney)

		// 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 TestSettersTimecardFilter(t *testing.T) {
	t.Run("SetLocationIDs", func(t *testing.T) {
		obj := &TimecardFilter{}
		var fernTestValueLocationIDs []string
		obj.SetLocationIDs(fernTestValueLocationIDs)
		assert.Equal(t, fernTestValueLocationIDs, obj.LocationIDs)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetStart", func(t *testing.T) {
		obj := &TimecardFilter{}
		var fernTestValueStart *TimeRange
		obj.SetStart(fernTestValueStart)
		assert.Equal(t, fernTestValueStart, obj.Start)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetEnd", func(t *testing.T) {
		obj := &TimecardFilter{}
		var fernTestValueEnd *TimeRange
		obj.SetEnd(fernTestValueEnd)
		assert.Equal(t, fernTestValueEnd, obj.End)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetWorkday", func(t *testing.T) {
		obj := &TimecardFilter{}
		var fernTestValueWorkday *TimecardWorkday
		obj.SetWorkday(fernTestValueWorkday)
		assert.Equal(t, fernTestValueWorkday, obj.Workday)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetTeamMemberIDs", func(t *testing.T) {
		obj := &TimecardFilter{}
		var fernTestValueTeamMemberIDs []string
		obj.SetTeamMemberIDs(fernTestValueTeamMemberIDs)
		assert.Equal(t, fernTestValueTeamMemberIDs, obj.TeamMemberIDs)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersTimecardFilter(t *testing.T) {
	t.Run("GetLocationIDs", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardFilter{}
		var expected []string
		obj.LocationIDs = expected

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

	t.Run("GetLocationIDs_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardFilter{}
		obj.LocationIDs = nil

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

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

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

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

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

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

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

	t.Run("GetStart", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardFilter{}
		var expected *TimeRange
		obj.Start = expected

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

	t.Run("GetStart_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardFilter{}
		obj.Start = nil

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

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

	t.Run("GetEnd", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardFilter{}
		var expected *TimeRange
		obj.End = expected

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

	t.Run("GetEnd_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardFilter{}
		obj.End = nil

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

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

	t.Run("GetWorkday", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardFilter{}
		var expected *TimecardWorkday
		obj.Workday = expected

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

	t.Run("GetWorkday_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardFilter{}
		obj.Workday = nil

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

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

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

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

	t.Run("GetTeamMemberIDs_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardFilter{}
		obj.TeamMemberIDs = nil

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

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

}

func TestSettersMarkExplicitTimecardFilter(t *testing.T) {
	t.Run("SetLocationIDs_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardFilter{}
		var fernTestValueLocationIDs []string

		// Act
		obj.SetLocationIDs(fernTestValueLocationIDs)

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

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

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

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

		// Act
		obj.SetStatus(fernTestValueStatus)

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

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

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

	t.Run("SetStart_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardFilter{}
		var fernTestValueStart *TimeRange

		// Act
		obj.SetStart(fernTestValueStart)

		// 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("SetEnd_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardFilter{}
		var fernTestValueEnd *TimeRange

		// Act
		obj.SetEnd(fernTestValueEnd)

		// 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("SetWorkday_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardFilter{}
		var fernTestValueWorkday *TimecardWorkday

		// Act
		obj.SetWorkday(fernTestValueWorkday)

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

		// Act
		obj.SetTeamMemberIDs(fernTestValueTeamMemberIDs)

		// 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 TestSettersTimecardQuery(t *testing.T) {
	t.Run("SetFilter", func(t *testing.T) {
		obj := &TimecardQuery{}
		var fernTestValueFilter *TimecardFilter
		obj.SetFilter(fernTestValueFilter)
		assert.Equal(t, fernTestValueFilter, obj.Filter)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSort", func(t *testing.T) {
		obj := &TimecardQuery{}
		var fernTestValueSort *TimecardSort
		obj.SetSort(fernTestValueSort)
		assert.Equal(t, fernTestValueSort, obj.Sort)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersTimecardQuery(t *testing.T) {
	t.Run("GetFilter", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardQuery{}
		var expected *TimecardFilter
		obj.Filter = expected

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

	t.Run("GetFilter_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardQuery{}
		obj.Filter = nil

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

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

	t.Run("GetSort", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardQuery{}
		var expected *TimecardSort
		obj.Sort = expected

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

	t.Run("GetSort_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardQuery{}
		obj.Sort = nil

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

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

}

func TestSettersMarkExplicitTimecardQuery(t *testing.T) {
	t.Run("SetFilter_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardQuery{}
		var fernTestValueFilter *TimecardFilter

		// Act
		obj.SetFilter(fernTestValueFilter)

		// 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("SetSort_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardQuery{}
		var fernTestValueSort *TimecardSort

		// Act
		obj.SetSort(fernTestValueSort)

		// 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 TestSettersTimecardSort(t *testing.T) {
	t.Run("SetField", func(t *testing.T) {
		obj := &TimecardSort{}
		var fernTestValueField *TimecardSortField
		obj.SetField(fernTestValueField)
		assert.Equal(t, fernTestValueField, obj.Field)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetOrder", func(t *testing.T) {
		obj := &TimecardSort{}
		var fernTestValueOrder *SortOrder
		obj.SetOrder(fernTestValueOrder)
		assert.Equal(t, fernTestValueOrder, obj.Order)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersTimecardSort(t *testing.T) {
	t.Run("GetField", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardSort{}
		var expected *TimecardSortField
		obj.Field = expected

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

	t.Run("GetField_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardSort{}
		obj.Field = nil

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

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

	t.Run("GetOrder", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardSort{}
		var expected *SortOrder
		obj.Order = expected

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

	t.Run("GetOrder_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardSort{}
		obj.Order = nil

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

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

}

func TestSettersMarkExplicitTimecardSort(t *testing.T) {
	t.Run("SetField_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardSort{}
		var fernTestValueField *TimecardSortField

		// Act
		obj.SetField(fernTestValueField)

		// 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("SetOrder_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardSort{}
		var fernTestValueOrder *SortOrder

		// Act
		obj.SetOrder(fernTestValueOrder)

		// 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 TestSettersTimecardWage(t *testing.T) {
	t.Run("SetTitle", func(t *testing.T) {
		obj := &TimecardWage{}
		var fernTestValueTitle *string
		obj.SetTitle(fernTestValueTitle)
		assert.Equal(t, fernTestValueTitle, obj.Title)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetHourlyRate", func(t *testing.T) {
		obj := &TimecardWage{}
		var fernTestValueHourlyRate *Money
		obj.SetHourlyRate(fernTestValueHourlyRate)
		assert.Equal(t, fernTestValueHourlyRate, obj.HourlyRate)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetJobID", func(t *testing.T) {
		obj := &TimecardWage{}
		var fernTestValueJobID *string
		obj.SetJobID(fernTestValueJobID)
		assert.Equal(t, fernTestValueJobID, obj.JobID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetTipEligible", func(t *testing.T) {
		obj := &TimecardWage{}
		var fernTestValueTipEligible *bool
		obj.SetTipEligible(fernTestValueTipEligible)
		assert.Equal(t, fernTestValueTipEligible, obj.TipEligible)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersTimecardWage(t *testing.T) {
	t.Run("GetTitle", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWage{}
		var expected *string
		obj.Title = expected

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

	t.Run("GetTitle_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWage{}
		obj.Title = nil

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

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

	t.Run("GetHourlyRate", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWage{}
		var expected *Money
		obj.HourlyRate = expected

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

	t.Run("GetHourlyRate_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWage{}
		obj.HourlyRate = nil

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

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

	t.Run("GetJobID", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWage{}
		var expected *string
		obj.JobID = expected

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

	t.Run("GetJobID_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWage{}
		obj.JobID = nil

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

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

	t.Run("GetTipEligible", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWage{}
		var expected *bool
		obj.TipEligible = expected

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

	t.Run("GetTipEligible_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWage{}
		obj.TipEligible = nil

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

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

}

func TestSettersMarkExplicitTimecardWage(t *testing.T) {
	t.Run("SetTitle_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWage{}
		var fernTestValueTitle *string

		// Act
		obj.SetTitle(fernTestValueTitle)

		// 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("SetHourlyRate_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWage{}
		var fernTestValueHourlyRate *Money

		// Act
		obj.SetHourlyRate(fernTestValueHourlyRate)

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

		// Act
		obj.SetJobID(fernTestValueJobID)

		// 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("SetTipEligible_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWage{}
		var fernTestValueTipEligible *bool

		// Act
		obj.SetTipEligible(fernTestValueTipEligible)

		// 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 TestSettersTimecardWorkday(t *testing.T) {
	t.Run("SetDateRange", func(t *testing.T) {
		obj := &TimecardWorkday{}
		var fernTestValueDateRange *DateRange
		obj.SetDateRange(fernTestValueDateRange)
		assert.Equal(t, fernTestValueDateRange, obj.DateRange)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMatchTimecardsBy", func(t *testing.T) {
		obj := &TimecardWorkday{}
		var fernTestValueMatchTimecardsBy *TimecardWorkdayMatcher
		obj.SetMatchTimecardsBy(fernTestValueMatchTimecardsBy)
		assert.Equal(t, fernTestValueMatchTimecardsBy, obj.MatchTimecardsBy)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetDefaultTimezone", func(t *testing.T) {
		obj := &TimecardWorkday{}
		var fernTestValueDefaultTimezone *string
		obj.SetDefaultTimezone(fernTestValueDefaultTimezone)
		assert.Equal(t, fernTestValueDefaultTimezone, obj.DefaultTimezone)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersTimecardWorkday(t *testing.T) {
	t.Run("GetDateRange", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWorkday{}
		var expected *DateRange
		obj.DateRange = expected

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

	t.Run("GetDateRange_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWorkday{}
		obj.DateRange = nil

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

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

	t.Run("GetMatchTimecardsBy", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWorkday{}
		var expected *TimecardWorkdayMatcher
		obj.MatchTimecardsBy = expected

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

	t.Run("GetMatchTimecardsBy_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWorkday{}
		obj.MatchTimecardsBy = nil

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

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

	t.Run("GetDefaultTimezone", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWorkday{}
		var expected *string
		obj.DefaultTimezone = expected

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

	t.Run("GetDefaultTimezone_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWorkday{}
		obj.DefaultTimezone = nil

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

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

}

func TestSettersMarkExplicitTimecardWorkday(t *testing.T) {
	t.Run("SetDateRange_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWorkday{}
		var fernTestValueDateRange *DateRange

		// Act
		obj.SetDateRange(fernTestValueDateRange)

		// 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("SetMatchTimecardsBy_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TimecardWorkday{}
		var fernTestValueMatchTimecardsBy *TimecardWorkdayMatcher

		// Act
		obj.SetMatchTimecardsBy(fernTestValueMatchTimecardsBy)

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

		// Act
		obj.SetDefaultTimezone(fernTestValueDefaultTimezone)

		// 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 TestSettersUpdateScheduledShiftResponse(t *testing.T) {
	t.Run("SetScheduledShift", func(t *testing.T) {
		obj := &UpdateScheduledShiftResponse{}
		var fernTestValueScheduledShift *ScheduledShift
		obj.SetScheduledShift(fernTestValueScheduledShift)
		assert.Equal(t, fernTestValueScheduledShift, obj.ScheduledShift)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetErrors", func(t *testing.T) {
		obj := &UpdateScheduledShiftResponse{}
		var fernTestValueErrors []*Error
		obj.SetErrors(fernTestValueErrors)
		assert.Equal(t, fernTestValueErrors, obj.Errors)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersUpdateScheduledShiftResponse(t *testing.T) {
	t.Run("GetScheduledShift", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateScheduledShiftResponse{}
		var expected *ScheduledShift
		obj.ScheduledShift = expected

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

	t.Run("GetScheduledShift_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateScheduledShiftResponse{}
		obj.ScheduledShift = nil

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

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

	t.Run("GetErrors", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateScheduledShiftResponse{}
		var expected []*Error
		obj.Errors = expected

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

	t.Run("GetErrors_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateScheduledShiftResponse{}
		obj.Errors = nil

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

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

}

func TestSettersMarkExplicitUpdateScheduledShiftResponse(t *testing.T) {
	t.Run("SetScheduledShift_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateScheduledShiftResponse{}
		var fernTestValueScheduledShift *ScheduledShift

		// Act
		obj.SetScheduledShift(fernTestValueScheduledShift)

		// 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("SetErrors_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateScheduledShiftResponse{}
		var fernTestValueErrors []*Error

		// Act
		obj.SetErrors(fernTestValueErrors)

		// 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 TestSettersUpdateTimecardResponse(t *testing.T) {
	t.Run("SetTimecard", func(t *testing.T) {
		obj := &UpdateTimecardResponse{}
		var fernTestValueTimecard *Timecard
		obj.SetTimecard(fernTestValueTimecard)
		assert.Equal(t, fernTestValueTimecard, obj.Timecard)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetErrors", func(t *testing.T) {
		obj := &UpdateTimecardResponse{}
		var fernTestValueErrors []*Error
		obj.SetErrors(fernTestValueErrors)
		assert.Equal(t, fernTestValueErrors, obj.Errors)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersUpdateTimecardResponse(t *testing.T) {
	t.Run("GetTimecard", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateTimecardResponse{}
		var expected *Timecard
		obj.Timecard = expected

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

	t.Run("GetTimecard_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateTimecardResponse{}
		obj.Timecard = nil

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

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

	t.Run("GetErrors", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateTimecardResponse{}
		var expected []*Error
		obj.Errors = expected

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

	t.Run("GetErrors_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateTimecardResponse{}
		obj.Errors = nil

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

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

}

func TestSettersMarkExplicitUpdateTimecardResponse(t *testing.T) {
	t.Run("SetTimecard_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateTimecardResponse{}
		var fernTestValueTimecard *Timecard

		// Act
		obj.SetTimecard(fernTestValueTimecard)

		// 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("SetErrors_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UpdateTimecardResponse{}
		var fernTestValueErrors []*Error

		// Act
		obj.SetErrors(fernTestValueErrors)

		// 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 TestJSONMarshalingBulkPublishScheduledShiftsData(t *testing.T) {
	t.Run("MarshalUnmarshal", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &BulkPublishScheduledShiftsData{}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestEnumScheduledShiftFilterAssignmentStatus(t *testing.T) {
	t.Run("NewFromString_ASSIGNED", func(t *testing.T) {
		t.Parallel()
		val, err := NewScheduledShiftFilterAssignmentStatusFromString("ASSIGNED")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ScheduledShiftFilterAssignmentStatus("ASSIGNED"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_UNASSIGNED", func(t *testing.T) {
		t.Parallel()
		val, err := NewScheduledShiftFilterAssignmentStatusFromString("UNASSIGNED")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ScheduledShiftFilterAssignmentStatus("UNASSIGNED"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumScheduledShiftFilterScheduledShiftStatus(t *testing.T) {
	t.Run("NewFromString_DRAFT", func(t *testing.T) {
		t.Parallel()
		val, err := NewScheduledShiftFilterScheduledShiftStatusFromString("DRAFT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ScheduledShiftFilterScheduledShiftStatus("DRAFT"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_PUBLISHED", func(t *testing.T) {
		t.Parallel()
		val, err := NewScheduledShiftFilterScheduledShiftStatusFromString("PUBLISHED")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ScheduledShiftFilterScheduledShiftStatus("PUBLISHED"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumScheduledShiftNotificationAudience(t *testing.T) {
	t.Run("NewFromString_ALL", func(t *testing.T) {
		t.Parallel()
		val, err := NewScheduledShiftNotificationAudienceFromString("ALL")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ScheduledShiftNotificationAudience("ALL"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_AFFECTED", func(t *testing.T) {
		t.Parallel()
		val, err := NewScheduledShiftNotificationAudienceFromString("AFFECTED")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ScheduledShiftNotificationAudience("AFFECTED"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_NONE", func(t *testing.T) {
		t.Parallel()
		val, err := NewScheduledShiftNotificationAudienceFromString("NONE")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ScheduledShiftNotificationAudience("NONE"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumScheduledShiftSortField(t *testing.T) {
	t.Run("NewFromString_START_AT", func(t *testing.T) {
		t.Parallel()
		val, err := NewScheduledShiftSortFieldFromString("START_AT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ScheduledShiftSortField("START_AT"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_END_AT", func(t *testing.T) {
		t.Parallel()
		val, err := NewScheduledShiftSortFieldFromString("END_AT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ScheduledShiftSortField("END_AT"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_CREATED_AT", func(t *testing.T) {
		t.Parallel()
		val, err := NewScheduledShiftSortFieldFromString("CREATED_AT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ScheduledShiftSortField("CREATED_AT"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_UPDATED_AT", func(t *testing.T) {
		t.Parallel()
		val, err := NewScheduledShiftSortFieldFromString("UPDATED_AT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ScheduledShiftSortField("UPDATED_AT"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumScheduledShiftWorkdayMatcher(t *testing.T) {
	t.Run("NewFromString_START_AT", func(t *testing.T) {
		t.Parallel()
		val, err := NewScheduledShiftWorkdayMatcherFromString("START_AT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ScheduledShiftWorkdayMatcher("START_AT"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_END_AT", func(t *testing.T) {
		t.Parallel()
		val, err := NewScheduledShiftWorkdayMatcherFromString("END_AT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ScheduledShiftWorkdayMatcher("END_AT"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_INTERSECTION", func(t *testing.T) {
		t.Parallel()
		val, err := NewScheduledShiftWorkdayMatcherFromString("INTERSECTION")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ScheduledShiftWorkdayMatcher("INTERSECTION"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumTimecardFilterStatus(t *testing.T) {
	t.Run("NewFromString_OPEN", func(t *testing.T) {
		t.Parallel()
		val, err := NewTimecardFilterStatusFromString("OPEN")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, TimecardFilterStatus("OPEN"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_CLOSED", func(t *testing.T) {
		t.Parallel()
		val, err := NewTimecardFilterStatusFromString("CLOSED")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, TimecardFilterStatus("CLOSED"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumTimecardSortField(t *testing.T) {
	t.Run("NewFromString_START_AT", func(t *testing.T) {
		t.Parallel()
		val, err := NewTimecardSortFieldFromString("START_AT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, TimecardSortField("START_AT"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_END_AT", func(t *testing.T) {
		t.Parallel()
		val, err := NewTimecardSortFieldFromString("END_AT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, TimecardSortField("END_AT"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_CREATED_AT", func(t *testing.T) {
		t.Parallel()
		val, err := NewTimecardSortFieldFromString("CREATED_AT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, TimecardSortField("CREATED_AT"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_UPDATED_AT", func(t *testing.T) {
		t.Parallel()
		val, err := NewTimecardSortFieldFromString("UPDATED_AT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, TimecardSortField("UPDATED_AT"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumTimecardStatus(t *testing.T) {
	t.Run("NewFromString_OPEN", func(t *testing.T) {
		t.Parallel()
		val, err := NewTimecardStatusFromString("OPEN")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, TimecardStatus("OPEN"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_CLOSED", func(t *testing.T) {
		t.Parallel()
		val, err := NewTimecardStatusFromString("CLOSED")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, TimecardStatus("CLOSED"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumTimecardWorkdayMatcher(t *testing.T) {
	t.Run("NewFromString_START_AT", func(t *testing.T) {
		t.Parallel()
		val, err := NewTimecardWorkdayMatcherFromString("START_AT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, TimecardWorkdayMatcher("START_AT"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_END_AT", func(t *testing.T) {
		t.Parallel()
		val, err := NewTimecardWorkdayMatcherFromString("END_AT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, TimecardWorkdayMatcher("END_AT"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_INTERSECTION", func(t *testing.T) {
		t.Parallel()
		val, err := NewTimecardWorkdayMatcherFromString("INTERSECTION")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, TimecardWorkdayMatcher("INTERSECTION"), val, "enum value should match expected wire value")
	})

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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