documents_test.go

// Code generated by Fern. DO NOT EDIT.

package cloudpdf

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

func TestSettersDocumentsCommitRequest(t *testing.T) {
	t.Run("SetTenantID", func(t *testing.T) {
		obj := &DocumentsCommitRequest{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetID", func(t *testing.T) {
		obj := &DocumentsCommitRequest{}
		var fernTestValueID string
		obj.SetID(fernTestValueID)
		assert.Equal(t, fernTestValueID, obj.ID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSha256", func(t *testing.T) {
		obj := &DocumentsCommitRequest{}
		var fernTestValueSha256 string
		obj.SetSha256(fernTestValueSha256)
		assert.Equal(t, fernTestValueSha256, obj.Sha256)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitDocumentsCommitRequest(t *testing.T) {
	t.Run("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommitRequest{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

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

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

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

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

		// Act
		obj.SetSha256(fernTestValueSha256)

		// 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 TestSettersDeleteDocumentsRequest(t *testing.T) {
	t.Run("SetTenantID", func(t *testing.T) {
		obj := &DeleteDocumentsRequest{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetID", func(t *testing.T) {
		obj := &DeleteDocumentsRequest{}
		var fernTestValueID string
		obj.SetID(fernTestValueID)
		assert.Equal(t, fernTestValueID, obj.ID)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitDeleteDocumentsRequest(t *testing.T) {
	t.Run("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DeleteDocumentsRequest{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

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

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

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

	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DeleteDocumentsRequest{}
		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 TestSettersDownloadDocumentsRequest(t *testing.T) {
	t.Run("SetTenantID", func(t *testing.T) {
		obj := &DownloadDocumentsRequest{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetID", func(t *testing.T) {
		obj := &DownloadDocumentsRequest{}
		var fernTestValueID string
		obj.SetID(fernTestValueID)
		assert.Equal(t, fernTestValueID, obj.ID)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitDownloadDocumentsRequest(t *testing.T) {
	t.Run("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DownloadDocumentsRequest{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

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

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

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

	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DownloadDocumentsRequest{}
		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 TestSettersGetDocumentsRequest(t *testing.T) {
	t.Run("SetTenantID", func(t *testing.T) {
		obj := &GetDocumentsRequest{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetID", func(t *testing.T) {
		obj := &GetDocumentsRequest{}
		var fernTestValueID string
		obj.SetID(fernTestValueID)
		assert.Equal(t, fernTestValueID, obj.ID)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitGetDocumentsRequest(t *testing.T) {
	t.Run("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GetDocumentsRequest{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

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

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

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

	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GetDocumentsRequest{}
		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 TestSettersDocumentsImportFromRequest(t *testing.T) {
	t.Run("SetTenantID", func(t *testing.T) {
		obj := &DocumentsImportFromRequest{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSource", func(t *testing.T) {
		obj := &DocumentsImportFromRequest{}
		var fernTestValueSource *DocumentsImportFromRequestSource
		obj.SetSource(fernTestValueSource)
		assert.Equal(t, fernTestValueSource, obj.Source)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetExpected", func(t *testing.T) {
		obj := &DocumentsImportFromRequest{}
		var fernTestValueExpected *DocumentsImportFromRequestExpected
		obj.SetExpected(fernTestValueExpected)
		assert.Equal(t, fernTestValueExpected, obj.Expected)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMetadata", func(t *testing.T) {
		obj := &DocumentsImportFromRequest{}
		var fernTestValueMetadata map[string]any
		obj.SetMetadata(fernTestValueMetadata)
		assert.Equal(t, fernTestValueMetadata, obj.Metadata)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetDedupMode", func(t *testing.T) {
		obj := &DocumentsImportFromRequest{}
		var fernTestValueDedupMode *DocumentsImportFromRequestDedupMode
		obj.SetDedupMode(fernTestValueDedupMode)
		assert.Equal(t, fernTestValueDedupMode, obj.DedupMode)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetDocID", func(t *testing.T) {
		obj := &DocumentsImportFromRequest{}
		var fernTestValueDocID *string
		obj.SetDocID(fernTestValueDocID)
		assert.Equal(t, fernTestValueDocID, obj.DocID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMode", func(t *testing.T) {
		obj := &DocumentsImportFromRequest{}
		var fernTestValueMode *DocumentsImportFromRequestMode
		obj.SetMode(fernTestValueMode)
		assert.Equal(t, fernTestValueMode, obj.Mode)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitDocumentsImportFromRequest(t *testing.T) {
	t.Run("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequest{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

		// 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("SetSource_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequest{}
		var fernTestValueSource *DocumentsImportFromRequestSource

		// Act
		obj.SetSource(fernTestValueSource)

		// 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("SetExpected_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequest{}
		var fernTestValueExpected *DocumentsImportFromRequestExpected

		// Act
		obj.SetExpected(fernTestValueExpected)

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

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

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

	t.Run("SetMetadata_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequest{}
		var fernTestValueMetadata map[string]any

		// Act
		obj.SetMetadata(fernTestValueMetadata)

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

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

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

	t.Run("SetIdempotencyKey_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequest{}
		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("SetDedupMode_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequest{}
		var fernTestValueDedupMode *DocumentsImportFromRequestDedupMode

		// Act
		obj.SetDedupMode(fernTestValueDedupMode)

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

		// Act
		obj.SetDocID(fernTestValueDocID)

		// 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("SetMode_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequest{}
		var fernTestValueMode *DocumentsImportFromRequestMode

		// Act
		obj.SetMode(fernTestValueMode)

		// 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 TestSettersDocumentsInitRequest(t *testing.T) {
	t.Run("SetTenantID", func(t *testing.T) {
		obj := &DocumentsInitRequest{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetContentLength", func(t *testing.T) {
		obj := &DocumentsInitRequest{}
		var fernTestValueContentLength float64
		obj.SetContentLength(fernTestValueContentLength)
		assert.Equal(t, fernTestValueContentLength, obj.ContentLength)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetContentSha256", func(t *testing.T) {
		obj := &DocumentsInitRequest{}
		var fernTestValueContentSha256 string
		obj.SetContentSha256(fernTestValueContentSha256)
		assert.Equal(t, fernTestValueContentSha256, obj.ContentSha256)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMetadata", func(t *testing.T) {
		obj := &DocumentsInitRequest{}
		var fernTestValueMetadata map[string]any
		obj.SetMetadata(fernTestValueMetadata)
		assert.Equal(t, fernTestValueMetadata, obj.Metadata)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetDedupMode", func(t *testing.T) {
		obj := &DocumentsInitRequest{}
		var fernTestValueDedupMode *DocumentsInitRequestDedupMode
		obj.SetDedupMode(fernTestValueDedupMode)
		assert.Equal(t, fernTestValueDedupMode, obj.DedupMode)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetDocID", func(t *testing.T) {
		obj := &DocumentsInitRequest{}
		var fernTestValueDocID *string
		obj.SetDocID(fernTestValueDocID)
		assert.Equal(t, fernTestValueDocID, obj.DocID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetUploadTTLSec", func(t *testing.T) {
		obj := &DocumentsInitRequest{}
		var fernTestValueUploadTTLSec *float64
		obj.SetUploadTTLSec(fernTestValueUploadTTLSec)
		assert.Equal(t, fernTestValueUploadTTLSec, obj.UploadTTLSec)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetUploadPreference", func(t *testing.T) {
		obj := &DocumentsInitRequest{}
		var fernTestValueUploadPreference *DocumentsInitRequestUploadPreference
		obj.SetUploadPreference(fernTestValueUploadPreference)
		assert.Equal(t, fernTestValueUploadPreference, obj.UploadPreference)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitDocumentsInitRequest(t *testing.T) {
	t.Run("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInitRequest{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

		// 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("SetContentLength_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInitRequest{}
		var fernTestValueContentLength float64

		// Act
		obj.SetContentLength(fernTestValueContentLength)

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

		// Act
		obj.SetContentSha256(fernTestValueContentSha256)

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

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

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

	t.Run("SetMetadata_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInitRequest{}
		var fernTestValueMetadata map[string]any

		// Act
		obj.SetMetadata(fernTestValueMetadata)

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

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

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

	t.Run("SetIdempotencyKey_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInitRequest{}
		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("SetDedupMode_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInitRequest{}
		var fernTestValueDedupMode *DocumentsInitRequestDedupMode

		// Act
		obj.SetDedupMode(fernTestValueDedupMode)

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

		// Act
		obj.SetDocID(fernTestValueDocID)

		// 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("SetUploadTTLSec_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInitRequest{}
		var fernTestValueUploadTTLSec *float64

		// Act
		obj.SetUploadTTLSec(fernTestValueUploadTTLSec)

		// 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("SetUploadPreference_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInitRequest{}
		var fernTestValueUploadPreference *DocumentsInitRequestUploadPreference

		// Act
		obj.SetUploadPreference(fernTestValueUploadPreference)

		// 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 TestSettersListDocumentsRequest(t *testing.T) {
	t.Run("SetTenantID", func(t *testing.T) {
		obj := &ListDocumentsRequest{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetLimit", func(t *testing.T) {
		obj := &ListDocumentsRequest{}
		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 := &ListDocumentsRequest{}
		var fernTestValueCursor *string
		obj.SetCursor(fernTestValueCursor)
		assert.Equal(t, fernTestValueCursor, obj.Cursor)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetState", func(t *testing.T) {
		obj := &ListDocumentsRequest{}
		var fernTestValueState *ListDocumentsRequestState
		obj.SetState(fernTestValueState)
		assert.Equal(t, fernTestValueState, obj.State)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitListDocumentsRequest(t *testing.T) {
	t.Run("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListDocumentsRequest{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

		// 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 := &ListDocumentsRequest{}
		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 := &ListDocumentsRequest{}
		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("SetState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ListDocumentsRequest{}
		var fernTestValueState *ListDocumentsRequestState

		// Act
		obj.SetState(fernTestValueState)

		// 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 TestSettersThumbnailDocumentsRequest(t *testing.T) {
	t.Run("SetTenantID", func(t *testing.T) {
		obj := &ThumbnailDocumentsRequest{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetID", func(t *testing.T) {
		obj := &ThumbnailDocumentsRequest{}
		var fernTestValueID string
		obj.SetID(fernTestValueID)
		assert.Equal(t, fernTestValueID, obj.ID)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitThumbnailDocumentsRequest(t *testing.T) {
	t.Run("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ThumbnailDocumentsRequest{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

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

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

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

	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ThumbnailDocumentsRequest{}
		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 TestSettersDocumentsCommit200Response(t *testing.T) {
	t.Run("SetDocument", func(t *testing.T) {
		obj := &DocumentsCommit200Response{}
		var fernTestValueDocument *DocumentsCommit200ResponseDocument
		obj.SetDocument(fernTestValueDocument)
		assert.Equal(t, fernTestValueDocument, obj.Document)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsCommit200Response(t *testing.T) {
	t.Run("GetDocument", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200Response{}
		var expected *DocumentsCommit200ResponseDocument
		obj.Document = expected

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

	t.Run("GetDocument_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200Response{}
		obj.Document = nil

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

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

}

func TestSettersMarkExplicitDocumentsCommit200Response(t *testing.T) {
	t.Run("SetDocument_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200Response{}
		var fernTestValueDocument *DocumentsCommit200ResponseDocument

		// Act
		obj.SetDocument(fernTestValueDocument)

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

	t.Run("SetTenantID", func(t *testing.T) {
		obj := &DocumentsCommit200ResponseDocument{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetState", func(t *testing.T) {
		obj := &DocumentsCommit200ResponseDocument{}
		var fernTestValueState DocumentsCommit200ResponseDocumentState
		obj.SetState(fernTestValueState)
		assert.Equal(t, fernTestValueState, obj.State)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetBaseSha", func(t *testing.T) {
		obj := &DocumentsCommit200ResponseDocument{}
		var fernTestValueBaseSha *string
		obj.SetBaseSha(fernTestValueBaseSha)
		assert.Equal(t, fernTestValueBaseSha, obj.BaseSha)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStorageSizeBytes", func(t *testing.T) {
		obj := &DocumentsCommit200ResponseDocument{}
		var fernTestValueStorageSizeBytes *float64
		obj.SetStorageSizeBytes(fernTestValueStorageSizeBytes)
		assert.Equal(t, fernTestValueStorageSizeBytes, obj.StorageSizeBytes)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMetadata", func(t *testing.T) {
		obj := &DocumentsCommit200ResponseDocument{}
		var fernTestValueMetadata map[string]any
		obj.SetMetadata(fernTestValueMetadata)
		assert.Equal(t, fernTestValueMetadata, obj.Metadata)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetFailureReason", func(t *testing.T) {
		obj := &DocumentsCommit200ResponseDocument{}
		var fernTestValueFailureReason *string
		obj.SetFailureReason(fernTestValueFailureReason)
		assert.Equal(t, fernTestValueFailureReason, obj.FailureReason)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetThumbnailState", func(t *testing.T) {
		obj := &DocumentsCommit200ResponseDocument{}
		var fernTestValueThumbnailState *DocumentsCommit200ResponseDocumentThumbnailState
		obj.SetThumbnailState(fernTestValueThumbnailState)
		assert.Equal(t, fernTestValueThumbnailState, obj.ThumbnailState)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetThumbnailURL", func(t *testing.T) {
		obj := &DocumentsCommit200ResponseDocument{}
		var fernTestValueThumbnailURL *string
		obj.SetThumbnailURL(fernTestValueThumbnailURL)
		assert.Equal(t, fernTestValueThumbnailURL, obj.ThumbnailURL)
		assert.NotNil(t, obj.explicitFields)
	})

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

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

	t.Run("SetCreatedBy", func(t *testing.T) {
		obj := &DocumentsCommit200ResponseDocument{}
		var fernTestValueCreatedBy *string
		obj.SetCreatedBy(fernTestValueCreatedBy)
		assert.Equal(t, fernTestValueCreatedBy, obj.CreatedBy)
		assert.NotNil(t, obj.explicitFields)
	})

}

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

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

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

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

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

	t.Run("GetState", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		var expected DocumentsCommit200ResponseDocumentState
		obj.State = expected

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

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

	t.Run("GetBaseSha", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		var expected *string
		obj.BaseSha = expected

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

	t.Run("GetBaseSha_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		obj.BaseSha = nil

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

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

	t.Run("GetStorageSizeBytes", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		var expected *float64
		obj.StorageSizeBytes = expected

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

	t.Run("GetStorageSizeBytes_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		obj.StorageSizeBytes = nil

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

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

	t.Run("GetMetadata", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		var expected map[string]any
		obj.Metadata = expected

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

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

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

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

	t.Run("GetIdempotencyKey", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		var expected *string
		obj.IdempotencyKey = expected

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

	t.Run("GetIdempotencyKey_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		obj.IdempotencyKey = nil

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

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

	t.Run("GetFailureReason", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		var expected *string
		obj.FailureReason = expected

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

	t.Run("GetFailureReason_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		obj.FailureReason = nil

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

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

	t.Run("GetThumbnailState", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		var expected *DocumentsCommit200ResponseDocumentThumbnailState
		obj.ThumbnailState = expected

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

	t.Run("GetThumbnailState_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		obj.ThumbnailState = nil

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

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

	t.Run("GetThumbnailURL", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		var expected *string
		obj.ThumbnailURL = expected

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

	t.Run("GetThumbnailURL_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		obj.ThumbnailURL = nil

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

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

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

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

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

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

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

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

	t.Run("GetCreatedBy_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		obj.CreatedBy = nil

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

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

}

func TestSettersMarkExplicitDocumentsCommit200ResponseDocument(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		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("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

		// 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("SetState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		var fernTestValueState DocumentsCommit200ResponseDocumentState

		// Act
		obj.SetState(fernTestValueState)

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

		// Act
		obj.SetBaseSha(fernTestValueBaseSha)

		// 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("SetStorageSizeBytes_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		var fernTestValueStorageSizeBytes *float64

		// Act
		obj.SetStorageSizeBytes(fernTestValueStorageSizeBytes)

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

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

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

	t.Run("SetMetadata_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		var fernTestValueMetadata map[string]any

		// Act
		obj.SetMetadata(fernTestValueMetadata)

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

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

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

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

		// Act
		obj.SetFailureReason(fernTestValueFailureReason)

		// 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("SetThumbnailState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsCommit200ResponseDocument{}
		var fernTestValueThumbnailState *DocumentsCommit200ResponseDocumentThumbnailState

		// Act
		obj.SetThumbnailState(fernTestValueThumbnailState)

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

		// Act
		obj.SetThumbnailURL(fernTestValueThumbnailURL)

		// 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 := &DocumentsCommit200ResponseDocument{}
		var fernTestValueCreatedAt float64

		// 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 := &DocumentsCommit200ResponseDocument{}
		var fernTestValueUpdatedAt float64

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

		// Act
		obj.SetCreatedBy(fernTestValueCreatedBy)

		// 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 TestSettersDocumentsGet200Response(t *testing.T) {
	t.Run("SetDocument", func(t *testing.T) {
		obj := &DocumentsGet200Response{}
		var fernTestValueDocument *DocumentsGet200ResponseDocument
		obj.SetDocument(fernTestValueDocument)
		assert.Equal(t, fernTestValueDocument, obj.Document)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsGet200Response(t *testing.T) {
	t.Run("GetDocument", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200Response{}
		var expected *DocumentsGet200ResponseDocument
		obj.Document = expected

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

	t.Run("GetDocument_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200Response{}
		obj.Document = nil

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

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

}

func TestSettersMarkExplicitDocumentsGet200Response(t *testing.T) {
	t.Run("SetDocument_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200Response{}
		var fernTestValueDocument *DocumentsGet200ResponseDocument

		// Act
		obj.SetDocument(fernTestValueDocument)

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

	t.Run("SetTenantID", func(t *testing.T) {
		obj := &DocumentsGet200ResponseDocument{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetState", func(t *testing.T) {
		obj := &DocumentsGet200ResponseDocument{}
		var fernTestValueState DocumentsGet200ResponseDocumentState
		obj.SetState(fernTestValueState)
		assert.Equal(t, fernTestValueState, obj.State)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetBaseSha", func(t *testing.T) {
		obj := &DocumentsGet200ResponseDocument{}
		var fernTestValueBaseSha *string
		obj.SetBaseSha(fernTestValueBaseSha)
		assert.Equal(t, fernTestValueBaseSha, obj.BaseSha)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStorageSizeBytes", func(t *testing.T) {
		obj := &DocumentsGet200ResponseDocument{}
		var fernTestValueStorageSizeBytes *float64
		obj.SetStorageSizeBytes(fernTestValueStorageSizeBytes)
		assert.Equal(t, fernTestValueStorageSizeBytes, obj.StorageSizeBytes)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMetadata", func(t *testing.T) {
		obj := &DocumentsGet200ResponseDocument{}
		var fernTestValueMetadata map[string]any
		obj.SetMetadata(fernTestValueMetadata)
		assert.Equal(t, fernTestValueMetadata, obj.Metadata)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetFailureReason", func(t *testing.T) {
		obj := &DocumentsGet200ResponseDocument{}
		var fernTestValueFailureReason *string
		obj.SetFailureReason(fernTestValueFailureReason)
		assert.Equal(t, fernTestValueFailureReason, obj.FailureReason)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetThumbnailState", func(t *testing.T) {
		obj := &DocumentsGet200ResponseDocument{}
		var fernTestValueThumbnailState *DocumentsGet200ResponseDocumentThumbnailState
		obj.SetThumbnailState(fernTestValueThumbnailState)
		assert.Equal(t, fernTestValueThumbnailState, obj.ThumbnailState)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetThumbnailURL", func(t *testing.T) {
		obj := &DocumentsGet200ResponseDocument{}
		var fernTestValueThumbnailURL *string
		obj.SetThumbnailURL(fernTestValueThumbnailURL)
		assert.Equal(t, fernTestValueThumbnailURL, obj.ThumbnailURL)
		assert.NotNil(t, obj.explicitFields)
	})

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

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

	t.Run("SetCreatedBy", func(t *testing.T) {
		obj := &DocumentsGet200ResponseDocument{}
		var fernTestValueCreatedBy *string
		obj.SetCreatedBy(fernTestValueCreatedBy)
		assert.Equal(t, fernTestValueCreatedBy, obj.CreatedBy)
		assert.NotNil(t, obj.explicitFields)
	})

}

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

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

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

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

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

	t.Run("GetState", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		var expected DocumentsGet200ResponseDocumentState
		obj.State = expected

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

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

	t.Run("GetBaseSha", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		var expected *string
		obj.BaseSha = expected

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

	t.Run("GetBaseSha_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		obj.BaseSha = nil

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

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

	t.Run("GetStorageSizeBytes", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		var expected *float64
		obj.StorageSizeBytes = expected

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

	t.Run("GetStorageSizeBytes_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		obj.StorageSizeBytes = nil

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

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

	t.Run("GetMetadata", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		var expected map[string]any
		obj.Metadata = expected

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

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

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

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

	t.Run("GetIdempotencyKey", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		var expected *string
		obj.IdempotencyKey = expected

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

	t.Run("GetIdempotencyKey_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		obj.IdempotencyKey = nil

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

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

	t.Run("GetFailureReason", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		var expected *string
		obj.FailureReason = expected

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

	t.Run("GetFailureReason_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		obj.FailureReason = nil

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

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

	t.Run("GetThumbnailState", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		var expected *DocumentsGet200ResponseDocumentThumbnailState
		obj.ThumbnailState = expected

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

	t.Run("GetThumbnailState_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		obj.ThumbnailState = nil

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

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

	t.Run("GetThumbnailURL", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		var expected *string
		obj.ThumbnailURL = expected

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

	t.Run("GetThumbnailURL_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		obj.ThumbnailURL = nil

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

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

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

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

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

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

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

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

	t.Run("GetCreatedBy_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		obj.CreatedBy = nil

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

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

}

func TestSettersMarkExplicitDocumentsGet200ResponseDocument(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		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("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

		// 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("SetState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		var fernTestValueState DocumentsGet200ResponseDocumentState

		// Act
		obj.SetState(fernTestValueState)

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

		// Act
		obj.SetBaseSha(fernTestValueBaseSha)

		// 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("SetStorageSizeBytes_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		var fernTestValueStorageSizeBytes *float64

		// Act
		obj.SetStorageSizeBytes(fernTestValueStorageSizeBytes)

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

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

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

	t.Run("SetMetadata_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		var fernTestValueMetadata map[string]any

		// Act
		obj.SetMetadata(fernTestValueMetadata)

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

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

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

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

		// Act
		obj.SetFailureReason(fernTestValueFailureReason)

		// 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("SetThumbnailState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsGet200ResponseDocument{}
		var fernTestValueThumbnailState *DocumentsGet200ResponseDocumentThumbnailState

		// Act
		obj.SetThumbnailState(fernTestValueThumbnailState)

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

		// Act
		obj.SetThumbnailURL(fernTestValueThumbnailURL)

		// 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 := &DocumentsGet200ResponseDocument{}
		var fernTestValueCreatedAt float64

		// 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 := &DocumentsGet200ResponseDocument{}
		var fernTestValueUpdatedAt float64

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

		// Act
		obj.SetCreatedBy(fernTestValueCreatedBy)

		// 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 TestSettersDocumentsImportFrom200Response(t *testing.T) {
	t.Run("SetTag", func(t *testing.T) {
		obj := &DocumentsImportFrom200Response{}
		var fernTestValueTag DocumentsImportFrom200ResponseTag
		obj.SetTag(fernTestValueTag)
		assert.Equal(t, fernTestValueTag, obj.Tag)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetDocument", func(t *testing.T) {
		obj := &DocumentsImportFrom200Response{}
		var fernTestValueDocument *DocumentsImportFrom200ResponseDocument
		obj.SetDocument(fernTestValueDocument)
		assert.Equal(t, fernTestValueDocument, obj.Document)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsImportFrom200Response(t *testing.T) {
	t.Run("GetTag", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200Response{}
		var expected DocumentsImportFrom200ResponseTag
		obj.Tag = expected

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

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

	t.Run("GetDocument", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200Response{}
		var expected *DocumentsImportFrom200ResponseDocument
		obj.Document = expected

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

	t.Run("GetDocument_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200Response{}
		obj.Document = nil

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

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

}

func TestSettersMarkExplicitDocumentsImportFrom200Response(t *testing.T) {
	t.Run("SetTag_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200Response{}
		var fernTestValueTag DocumentsImportFrom200ResponseTag

		// Act
		obj.SetTag(fernTestValueTag)

		// 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("SetDocument_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200Response{}
		var fernTestValueDocument *DocumentsImportFrom200ResponseDocument

		// Act
		obj.SetDocument(fernTestValueDocument)

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

	t.Run("SetTenantID", func(t *testing.T) {
		obj := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetState", func(t *testing.T) {
		obj := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueState DocumentsImportFrom200ResponseDocumentState
		obj.SetState(fernTestValueState)
		assert.Equal(t, fernTestValueState, obj.State)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetBaseSha", func(t *testing.T) {
		obj := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueBaseSha *string
		obj.SetBaseSha(fernTestValueBaseSha)
		assert.Equal(t, fernTestValueBaseSha, obj.BaseSha)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStorageSizeBytes", func(t *testing.T) {
		obj := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueStorageSizeBytes *float64
		obj.SetStorageSizeBytes(fernTestValueStorageSizeBytes)
		assert.Equal(t, fernTestValueStorageSizeBytes, obj.StorageSizeBytes)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMetadata", func(t *testing.T) {
		obj := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueMetadata map[string]any
		obj.SetMetadata(fernTestValueMetadata)
		assert.Equal(t, fernTestValueMetadata, obj.Metadata)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetFailureReason", func(t *testing.T) {
		obj := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueFailureReason *string
		obj.SetFailureReason(fernTestValueFailureReason)
		assert.Equal(t, fernTestValueFailureReason, obj.FailureReason)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetThumbnailState", func(t *testing.T) {
		obj := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueThumbnailState *DocumentsImportFrom200ResponseDocumentThumbnailState
		obj.SetThumbnailState(fernTestValueThumbnailState)
		assert.Equal(t, fernTestValueThumbnailState, obj.ThumbnailState)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetThumbnailURL", func(t *testing.T) {
		obj := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueThumbnailURL *string
		obj.SetThumbnailURL(fernTestValueThumbnailURL)
		assert.Equal(t, fernTestValueThumbnailURL, obj.ThumbnailURL)
		assert.NotNil(t, obj.explicitFields)
	})

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

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

	t.Run("SetCreatedBy", func(t *testing.T) {
		obj := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueCreatedBy *string
		obj.SetCreatedBy(fernTestValueCreatedBy)
		assert.Equal(t, fernTestValueCreatedBy, obj.CreatedBy)
		assert.NotNil(t, obj.explicitFields)
	})

}

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

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

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

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

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

	t.Run("GetState", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		var expected DocumentsImportFrom200ResponseDocumentState
		obj.State = expected

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

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

	t.Run("GetBaseSha", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		var expected *string
		obj.BaseSha = expected

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

	t.Run("GetBaseSha_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		obj.BaseSha = nil

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

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

	t.Run("GetStorageSizeBytes", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		var expected *float64
		obj.StorageSizeBytes = expected

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

	t.Run("GetStorageSizeBytes_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		obj.StorageSizeBytes = nil

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

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

	t.Run("GetMetadata", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		var expected map[string]any
		obj.Metadata = expected

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

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

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

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

	t.Run("GetIdempotencyKey", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		var expected *string
		obj.IdempotencyKey = expected

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

	t.Run("GetIdempotencyKey_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		obj.IdempotencyKey = nil

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

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

	t.Run("GetFailureReason", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		var expected *string
		obj.FailureReason = expected

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

	t.Run("GetFailureReason_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		obj.FailureReason = nil

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

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

	t.Run("GetThumbnailState", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		var expected *DocumentsImportFrom200ResponseDocumentThumbnailState
		obj.ThumbnailState = expected

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

	t.Run("GetThumbnailState_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		obj.ThumbnailState = nil

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

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

	t.Run("GetThumbnailURL", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		var expected *string
		obj.ThumbnailURL = expected

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

	t.Run("GetThumbnailURL_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		obj.ThumbnailURL = nil

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

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

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

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

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

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

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

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

	t.Run("GetCreatedBy_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		obj.CreatedBy = nil

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

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

}

func TestSettersMarkExplicitDocumentsImportFrom200ResponseDocument(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		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("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

		// 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("SetState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueState DocumentsImportFrom200ResponseDocumentState

		// Act
		obj.SetState(fernTestValueState)

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

		// Act
		obj.SetBaseSha(fernTestValueBaseSha)

		// 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("SetStorageSizeBytes_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueStorageSizeBytes *float64

		// Act
		obj.SetStorageSizeBytes(fernTestValueStorageSizeBytes)

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

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

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

	t.Run("SetMetadata_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueMetadata map[string]any

		// Act
		obj.SetMetadata(fernTestValueMetadata)

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

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

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

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

		// Act
		obj.SetFailureReason(fernTestValueFailureReason)

		// 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("SetThumbnailState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueThumbnailState *DocumentsImportFrom200ResponseDocumentThumbnailState

		// Act
		obj.SetThumbnailState(fernTestValueThumbnailState)

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

		// Act
		obj.SetThumbnailURL(fernTestValueThumbnailURL)

		// 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 := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueCreatedAt float64

		// 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 := &DocumentsImportFrom200ResponseDocument{}
		var fernTestValueUpdatedAt float64

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

		// Act
		obj.SetCreatedBy(fernTestValueCreatedBy)

		// 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 TestGettersDocumentsInit200Response(t *testing.T) {
	t.Run("GetTag", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200Response{}
		var expected string
		obj.Tag = expected

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

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

	t.Run("GetCreated", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200Response{}
		var expected *DocumentsInit200ResponseCreated
		obj.Created = expected

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

	t.Run("GetCreated_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200Response{}
		obj.Created = nil

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

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

	t.Run("GetResumed", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200Response{}
		var expected *DocumentsInit200ResponseResumed
		obj.Resumed = expected

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

	t.Run("GetResumed_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200Response{}
		obj.Resumed = nil

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

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

	t.Run("GetDeduped", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200Response{}
		var expected *DocumentsInit200ResponseDeduped
		obj.Deduped = expected

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

	t.Run("GetDeduped_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200Response{}
		obj.Deduped = nil

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

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

}

func TestSettersDocumentsInit200ResponseCreated(t *testing.T) {
	t.Run("SetDocument", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreated{}
		var fernTestValueDocument *DocumentsInit200ResponseCreatedDocument
		obj.SetDocument(fernTestValueDocument)
		assert.Equal(t, fernTestValueDocument, obj.Document)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetUpload", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreated{}
		var fernTestValueUpload *DocumentsInit200ResponseCreatedUpload
		obj.SetUpload(fernTestValueUpload)
		assert.Equal(t, fernTestValueUpload, obj.Upload)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsInit200ResponseCreated(t *testing.T) {
	t.Run("GetDocument", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreated{}
		var expected *DocumentsInit200ResponseCreatedDocument
		obj.Document = expected

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

	t.Run("GetDocument_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreated{}
		obj.Document = nil

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

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

	t.Run("GetUpload", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreated{}
		var expected *DocumentsInit200ResponseCreatedUpload
		obj.Upload = expected

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

	t.Run("GetUpload_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreated{}
		obj.Upload = nil

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

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

}

func TestSettersMarkExplicitDocumentsInit200ResponseCreated(t *testing.T) {
	t.Run("SetDocument_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreated{}
		var fernTestValueDocument *DocumentsInit200ResponseCreatedDocument

		// Act
		obj.SetDocument(fernTestValueDocument)

		// 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("SetUpload_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreated{}
		var fernTestValueUpload *DocumentsInit200ResponseCreatedUpload

		// Act
		obj.SetUpload(fernTestValueUpload)

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

	t.Run("SetTenantID", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetState", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueState DocumentsInit200ResponseCreatedDocumentState
		obj.SetState(fernTestValueState)
		assert.Equal(t, fernTestValueState, obj.State)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetBaseSha", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueBaseSha *string
		obj.SetBaseSha(fernTestValueBaseSha)
		assert.Equal(t, fernTestValueBaseSha, obj.BaseSha)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStorageSizeBytes", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueStorageSizeBytes *float64
		obj.SetStorageSizeBytes(fernTestValueStorageSizeBytes)
		assert.Equal(t, fernTestValueStorageSizeBytes, obj.StorageSizeBytes)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMetadata", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueMetadata map[string]any
		obj.SetMetadata(fernTestValueMetadata)
		assert.Equal(t, fernTestValueMetadata, obj.Metadata)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetFailureReason", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueFailureReason *string
		obj.SetFailureReason(fernTestValueFailureReason)
		assert.Equal(t, fernTestValueFailureReason, obj.FailureReason)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetThumbnailState", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueThumbnailState *DocumentsInit200ResponseCreatedDocumentThumbnailState
		obj.SetThumbnailState(fernTestValueThumbnailState)
		assert.Equal(t, fernTestValueThumbnailState, obj.ThumbnailState)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetThumbnailURL", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueThumbnailURL *string
		obj.SetThumbnailURL(fernTestValueThumbnailURL)
		assert.Equal(t, fernTestValueThumbnailURL, obj.ThumbnailURL)
		assert.NotNil(t, obj.explicitFields)
	})

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

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

	t.Run("SetCreatedBy", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueCreatedBy *string
		obj.SetCreatedBy(fernTestValueCreatedBy)
		assert.Equal(t, fernTestValueCreatedBy, obj.CreatedBy)
		assert.NotNil(t, obj.explicitFields)
	})

}

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

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

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

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

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

	t.Run("GetState", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var expected DocumentsInit200ResponseCreatedDocumentState
		obj.State = expected

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

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

	t.Run("GetBaseSha", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var expected *string
		obj.BaseSha = expected

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

	t.Run("GetBaseSha_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		obj.BaseSha = nil

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

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

	t.Run("GetStorageSizeBytes", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var expected *float64
		obj.StorageSizeBytes = expected

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

	t.Run("GetStorageSizeBytes_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		obj.StorageSizeBytes = nil

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

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

	t.Run("GetMetadata", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var expected map[string]any
		obj.Metadata = expected

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

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

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

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

	t.Run("GetIdempotencyKey", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var expected *string
		obj.IdempotencyKey = expected

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

	t.Run("GetIdempotencyKey_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		obj.IdempotencyKey = nil

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

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

	t.Run("GetFailureReason", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var expected *string
		obj.FailureReason = expected

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

	t.Run("GetFailureReason_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		obj.FailureReason = nil

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

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

	t.Run("GetThumbnailState", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var expected *DocumentsInit200ResponseCreatedDocumentThumbnailState
		obj.ThumbnailState = expected

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

	t.Run("GetThumbnailState_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		obj.ThumbnailState = nil

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

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

	t.Run("GetThumbnailURL", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var expected *string
		obj.ThumbnailURL = expected

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

	t.Run("GetThumbnailURL_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		obj.ThumbnailURL = nil

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

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

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

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

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

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

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

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

	t.Run("GetCreatedBy_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		obj.CreatedBy = nil

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

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

}

func TestSettersMarkExplicitDocumentsInit200ResponseCreatedDocument(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		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("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

		// 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("SetState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueState DocumentsInit200ResponseCreatedDocumentState

		// Act
		obj.SetState(fernTestValueState)

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

		// Act
		obj.SetBaseSha(fernTestValueBaseSha)

		// 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("SetStorageSizeBytes_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueStorageSizeBytes *float64

		// Act
		obj.SetStorageSizeBytes(fernTestValueStorageSizeBytes)

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

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

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

	t.Run("SetMetadata_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueMetadata map[string]any

		// Act
		obj.SetMetadata(fernTestValueMetadata)

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

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

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

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

		// Act
		obj.SetFailureReason(fernTestValueFailureReason)

		// 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("SetThumbnailState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueThumbnailState *DocumentsInit200ResponseCreatedDocumentThumbnailState

		// Act
		obj.SetThumbnailState(fernTestValueThumbnailState)

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

		// Act
		obj.SetThumbnailURL(fernTestValueThumbnailURL)

		// 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 := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueCreatedAt float64

		// 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 := &DocumentsInit200ResponseCreatedDocument{}
		var fernTestValueUpdatedAt float64

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

		// Act
		obj.SetCreatedBy(fernTestValueCreatedBy)

		// 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 TestGettersDocumentsInit200ResponseCreatedUpload(t *testing.T) {
	t.Run("GetKind", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUpload{}
		var expected string
		obj.Kind = expected

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

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

	t.Run("GetPresigned", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUpload{}
		var expected *DocumentsInit200ResponseCreatedUploadPresigned
		obj.Presigned = expected

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

	t.Run("GetPresigned_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUpload{}
		obj.Presigned = nil

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

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

	t.Run("GetProxy", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUpload{}
		var expected *DocumentsInit200ResponseCreatedUploadProxy
		obj.Proxy = expected

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

	t.Run("GetProxy_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUpload{}
		obj.Proxy = nil

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

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

}

func TestSettersDocumentsInit200ResponseCreatedUploadPresigned(t *testing.T) {
	t.Run("SetPresigned", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedUploadPresigned{}
		var fernTestValuePresigned *DocumentsInit200ResponseCreatedUploadPresignedPresigned
		obj.SetPresigned(fernTestValuePresigned)
		assert.Equal(t, fernTestValuePresigned, obj.Presigned)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetKey", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedUploadPresigned{}
		var fernTestValueKey string
		obj.SetKey(fernTestValueKey)
		assert.Equal(t, fernTestValueKey, obj.Key)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsInit200ResponseCreatedUploadPresigned(t *testing.T) {
	t.Run("GetPresigned", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadPresigned{}
		var expected *DocumentsInit200ResponseCreatedUploadPresignedPresigned
		obj.Presigned = expected

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

	t.Run("GetPresigned_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadPresigned{}
		obj.Presigned = nil

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

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

	t.Run("GetKey", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadPresigned{}
		var expected string
		obj.Key = expected

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

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

}

func TestSettersMarkExplicitDocumentsInit200ResponseCreatedUploadPresigned(t *testing.T) {
	t.Run("SetPresigned_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadPresigned{}
		var fernTestValuePresigned *DocumentsInit200ResponseCreatedUploadPresignedPresigned

		// Act
		obj.SetPresigned(fernTestValuePresigned)

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

		// Act
		obj.SetKey(fernTestValueKey)

		// 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 TestSettersDocumentsInit200ResponseCreatedUploadPresignedPresigned(t *testing.T) {
	t.Run("SetURL", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedUploadPresignedPresigned{}
		var fernTestValueURL string
		obj.SetURL(fernTestValueURL)
		assert.Equal(t, fernTestValueURL, obj.URL)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetHeaders", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedUploadPresignedPresigned{}
		var fernTestValueHeaders map[string]string
		obj.SetHeaders(fernTestValueHeaders)
		assert.Equal(t, fernTestValueHeaders, obj.Headers)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMethod", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedUploadPresignedPresigned{}
		var fernTestValueMethod DocumentsInit200ResponseCreatedUploadPresignedPresignedMethod
		obj.SetMethod(fernTestValueMethod)
		assert.Equal(t, fernTestValueMethod, obj.Method)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetExpiresAt", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedUploadPresignedPresigned{}
		var fernTestValueExpiresAt float64
		obj.SetExpiresAt(fernTestValueExpiresAt)
		assert.Equal(t, fernTestValueExpiresAt, obj.ExpiresAt)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsInit200ResponseCreatedUploadPresignedPresigned(t *testing.T) {
	t.Run("GetURL", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadPresignedPresigned{}
		var expected string
		obj.URL = expected

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

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

	t.Run("GetHeaders", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadPresignedPresigned{}
		var expected map[string]string
		obj.Headers = expected

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

	t.Run("GetHeaders_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadPresignedPresigned{}
		obj.Headers = nil

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

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

	t.Run("GetMethod", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadPresignedPresigned{}
		var expected DocumentsInit200ResponseCreatedUploadPresignedPresignedMethod
		obj.Method = expected

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

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

	t.Run("GetExpiresAt", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadPresignedPresigned{}
		var expected float64
		obj.ExpiresAt = expected

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

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

}

func TestSettersMarkExplicitDocumentsInit200ResponseCreatedUploadPresignedPresigned(t *testing.T) {
	t.Run("SetURL_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadPresignedPresigned{}
		var fernTestValueURL string

		// Act
		obj.SetURL(fernTestValueURL)

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

		// Act
		obj.SetHeaders(fernTestValueHeaders)

		// 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("SetMethod_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadPresignedPresigned{}
		var fernTestValueMethod DocumentsInit200ResponseCreatedUploadPresignedPresignedMethod

		// Act
		obj.SetMethod(fernTestValueMethod)

		// 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("SetExpiresAt_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadPresignedPresigned{}
		var fernTestValueExpiresAt float64

		// Act
		obj.SetExpiresAt(fernTestValueExpiresAt)

		// 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 TestSettersDocumentsInit200ResponseCreatedUploadProxy(t *testing.T) {
	t.Run("SetURL", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedUploadProxy{}
		var fernTestValueURL string
		obj.SetURL(fernTestValueURL)
		assert.Equal(t, fernTestValueURL, obj.URL)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetKey", func(t *testing.T) {
		obj := &DocumentsInit200ResponseCreatedUploadProxy{}
		var fernTestValueKey string
		obj.SetKey(fernTestValueKey)
		assert.Equal(t, fernTestValueKey, obj.Key)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsInit200ResponseCreatedUploadProxy(t *testing.T) {
	t.Run("GetURL", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadProxy{}
		var expected string
		obj.URL = expected

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

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

	t.Run("GetKey", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadProxy{}
		var expected string
		obj.Key = expected

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

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

}

func TestSettersMarkExplicitDocumentsInit200ResponseCreatedUploadProxy(t *testing.T) {
	t.Run("SetURL_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseCreatedUploadProxy{}
		var fernTestValueURL string

		// Act
		obj.SetURL(fernTestValueURL)

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

		// Act
		obj.SetKey(fernTestValueKey)

		// 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 TestSettersDocumentsInit200ResponseDeduped(t *testing.T) {
	t.Run("SetDocument", func(t *testing.T) {
		obj := &DocumentsInit200ResponseDeduped{}
		var fernTestValueDocument *DocumentsInit200ResponseDedupedDocument
		obj.SetDocument(fernTestValueDocument)
		assert.Equal(t, fernTestValueDocument, obj.Document)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsInit200ResponseDeduped(t *testing.T) {
	t.Run("GetDocument", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDeduped{}
		var expected *DocumentsInit200ResponseDedupedDocument
		obj.Document = expected

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

	t.Run("GetDocument_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDeduped{}
		obj.Document = nil

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

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

}

func TestSettersMarkExplicitDocumentsInit200ResponseDeduped(t *testing.T) {
	t.Run("SetDocument_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDeduped{}
		var fernTestValueDocument *DocumentsInit200ResponseDedupedDocument

		// Act
		obj.SetDocument(fernTestValueDocument)

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

	t.Run("SetTenantID", func(t *testing.T) {
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetState", func(t *testing.T) {
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueState DocumentsInit200ResponseDedupedDocumentState
		obj.SetState(fernTestValueState)
		assert.Equal(t, fernTestValueState, obj.State)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetBaseSha", func(t *testing.T) {
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueBaseSha *string
		obj.SetBaseSha(fernTestValueBaseSha)
		assert.Equal(t, fernTestValueBaseSha, obj.BaseSha)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStorageSizeBytes", func(t *testing.T) {
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueStorageSizeBytes *float64
		obj.SetStorageSizeBytes(fernTestValueStorageSizeBytes)
		assert.Equal(t, fernTestValueStorageSizeBytes, obj.StorageSizeBytes)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMetadata", func(t *testing.T) {
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueMetadata map[string]any
		obj.SetMetadata(fernTestValueMetadata)
		assert.Equal(t, fernTestValueMetadata, obj.Metadata)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetFailureReason", func(t *testing.T) {
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueFailureReason *string
		obj.SetFailureReason(fernTestValueFailureReason)
		assert.Equal(t, fernTestValueFailureReason, obj.FailureReason)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetThumbnailState", func(t *testing.T) {
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueThumbnailState *DocumentsInit200ResponseDedupedDocumentThumbnailState
		obj.SetThumbnailState(fernTestValueThumbnailState)
		assert.Equal(t, fernTestValueThumbnailState, obj.ThumbnailState)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetThumbnailURL", func(t *testing.T) {
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueThumbnailURL *string
		obj.SetThumbnailURL(fernTestValueThumbnailURL)
		assert.Equal(t, fernTestValueThumbnailURL, obj.ThumbnailURL)
		assert.NotNil(t, obj.explicitFields)
	})

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

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

	t.Run("SetCreatedBy", func(t *testing.T) {
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueCreatedBy *string
		obj.SetCreatedBy(fernTestValueCreatedBy)
		assert.Equal(t, fernTestValueCreatedBy, obj.CreatedBy)
		assert.NotNil(t, obj.explicitFields)
	})

}

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

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

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

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

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

	t.Run("GetState", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var expected DocumentsInit200ResponseDedupedDocumentState
		obj.State = expected

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

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

	t.Run("GetBaseSha", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var expected *string
		obj.BaseSha = expected

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

	t.Run("GetBaseSha_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		obj.BaseSha = nil

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

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

	t.Run("GetStorageSizeBytes", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var expected *float64
		obj.StorageSizeBytes = expected

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

	t.Run("GetStorageSizeBytes_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		obj.StorageSizeBytes = nil

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

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

	t.Run("GetMetadata", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var expected map[string]any
		obj.Metadata = expected

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

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

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

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

	t.Run("GetIdempotencyKey", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var expected *string
		obj.IdempotencyKey = expected

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

	t.Run("GetIdempotencyKey_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		obj.IdempotencyKey = nil

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

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

	t.Run("GetFailureReason", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var expected *string
		obj.FailureReason = expected

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

	t.Run("GetFailureReason_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		obj.FailureReason = nil

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

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

	t.Run("GetThumbnailState", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var expected *DocumentsInit200ResponseDedupedDocumentThumbnailState
		obj.ThumbnailState = expected

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

	t.Run("GetThumbnailState_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		obj.ThumbnailState = nil

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

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

	t.Run("GetThumbnailURL", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var expected *string
		obj.ThumbnailURL = expected

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

	t.Run("GetThumbnailURL_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		obj.ThumbnailURL = nil

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

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

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

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

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

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

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

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

	t.Run("GetCreatedBy_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		obj.CreatedBy = nil

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

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

}

func TestSettersMarkExplicitDocumentsInit200ResponseDedupedDocument(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		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("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

		// 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("SetState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueState DocumentsInit200ResponseDedupedDocumentState

		// Act
		obj.SetState(fernTestValueState)

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

		// Act
		obj.SetBaseSha(fernTestValueBaseSha)

		// 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("SetStorageSizeBytes_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueStorageSizeBytes *float64

		// Act
		obj.SetStorageSizeBytes(fernTestValueStorageSizeBytes)

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

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

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

	t.Run("SetMetadata_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueMetadata map[string]any

		// Act
		obj.SetMetadata(fernTestValueMetadata)

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

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

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

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

		// Act
		obj.SetFailureReason(fernTestValueFailureReason)

		// 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("SetThumbnailState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueThumbnailState *DocumentsInit200ResponseDedupedDocumentThumbnailState

		// Act
		obj.SetThumbnailState(fernTestValueThumbnailState)

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

		// Act
		obj.SetThumbnailURL(fernTestValueThumbnailURL)

		// 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 := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueCreatedAt float64

		// 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 := &DocumentsInit200ResponseDedupedDocument{}
		var fernTestValueUpdatedAt float64

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

		// Act
		obj.SetCreatedBy(fernTestValueCreatedBy)

		// 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 TestSettersDocumentsInit200ResponseResumed(t *testing.T) {
	t.Run("SetDocument", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumed{}
		var fernTestValueDocument *DocumentsInit200ResponseResumedDocument
		obj.SetDocument(fernTestValueDocument)
		assert.Equal(t, fernTestValueDocument, obj.Document)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetUpload", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumed{}
		var fernTestValueUpload *DocumentsInit200ResponseResumedUpload
		obj.SetUpload(fernTestValueUpload)
		assert.Equal(t, fernTestValueUpload, obj.Upload)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsInit200ResponseResumed(t *testing.T) {
	t.Run("GetDocument", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumed{}
		var expected *DocumentsInit200ResponseResumedDocument
		obj.Document = expected

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

	t.Run("GetDocument_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumed{}
		obj.Document = nil

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

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

	t.Run("GetUpload", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumed{}
		var expected *DocumentsInit200ResponseResumedUpload
		obj.Upload = expected

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

	t.Run("GetUpload_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumed{}
		obj.Upload = nil

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

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

}

func TestSettersMarkExplicitDocumentsInit200ResponseResumed(t *testing.T) {
	t.Run("SetDocument_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumed{}
		var fernTestValueDocument *DocumentsInit200ResponseResumedDocument

		// Act
		obj.SetDocument(fernTestValueDocument)

		// 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("SetUpload_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumed{}
		var fernTestValueUpload *DocumentsInit200ResponseResumedUpload

		// Act
		obj.SetUpload(fernTestValueUpload)

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

	t.Run("SetTenantID", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetState", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueState DocumentsInit200ResponseResumedDocumentState
		obj.SetState(fernTestValueState)
		assert.Equal(t, fernTestValueState, obj.State)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetBaseSha", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueBaseSha *string
		obj.SetBaseSha(fernTestValueBaseSha)
		assert.Equal(t, fernTestValueBaseSha, obj.BaseSha)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStorageSizeBytes", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueStorageSizeBytes *float64
		obj.SetStorageSizeBytes(fernTestValueStorageSizeBytes)
		assert.Equal(t, fernTestValueStorageSizeBytes, obj.StorageSizeBytes)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMetadata", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueMetadata map[string]any
		obj.SetMetadata(fernTestValueMetadata)
		assert.Equal(t, fernTestValueMetadata, obj.Metadata)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetFailureReason", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueFailureReason *string
		obj.SetFailureReason(fernTestValueFailureReason)
		assert.Equal(t, fernTestValueFailureReason, obj.FailureReason)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetThumbnailState", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueThumbnailState *DocumentsInit200ResponseResumedDocumentThumbnailState
		obj.SetThumbnailState(fernTestValueThumbnailState)
		assert.Equal(t, fernTestValueThumbnailState, obj.ThumbnailState)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetThumbnailURL", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueThumbnailURL *string
		obj.SetThumbnailURL(fernTestValueThumbnailURL)
		assert.Equal(t, fernTestValueThumbnailURL, obj.ThumbnailURL)
		assert.NotNil(t, obj.explicitFields)
	})

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

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

	t.Run("SetCreatedBy", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueCreatedBy *string
		obj.SetCreatedBy(fernTestValueCreatedBy)
		assert.Equal(t, fernTestValueCreatedBy, obj.CreatedBy)
		assert.NotNil(t, obj.explicitFields)
	})

}

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

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

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

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

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

	t.Run("GetState", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		var expected DocumentsInit200ResponseResumedDocumentState
		obj.State = expected

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

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

	t.Run("GetBaseSha", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		var expected *string
		obj.BaseSha = expected

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

	t.Run("GetBaseSha_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		obj.BaseSha = nil

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

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

	t.Run("GetStorageSizeBytes", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		var expected *float64
		obj.StorageSizeBytes = expected

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

	t.Run("GetStorageSizeBytes_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		obj.StorageSizeBytes = nil

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

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

	t.Run("GetMetadata", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		var expected map[string]any
		obj.Metadata = expected

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

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

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

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

	t.Run("GetIdempotencyKey", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		var expected *string
		obj.IdempotencyKey = expected

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

	t.Run("GetIdempotencyKey_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		obj.IdempotencyKey = nil

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

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

	t.Run("GetFailureReason", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		var expected *string
		obj.FailureReason = expected

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

	t.Run("GetFailureReason_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		obj.FailureReason = nil

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

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

	t.Run("GetThumbnailState", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		var expected *DocumentsInit200ResponseResumedDocumentThumbnailState
		obj.ThumbnailState = expected

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

	t.Run("GetThumbnailState_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		obj.ThumbnailState = nil

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

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

	t.Run("GetThumbnailURL", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		var expected *string
		obj.ThumbnailURL = expected

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

	t.Run("GetThumbnailURL_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		obj.ThumbnailURL = nil

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

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

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

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

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

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

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

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

	t.Run("GetCreatedBy_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		obj.CreatedBy = nil

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

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

}

func TestSettersMarkExplicitDocumentsInit200ResponseResumedDocument(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		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("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

		// 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("SetState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueState DocumentsInit200ResponseResumedDocumentState

		// Act
		obj.SetState(fernTestValueState)

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

		// Act
		obj.SetBaseSha(fernTestValueBaseSha)

		// 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("SetStorageSizeBytes_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueStorageSizeBytes *float64

		// Act
		obj.SetStorageSizeBytes(fernTestValueStorageSizeBytes)

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

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

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

	t.Run("SetMetadata_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueMetadata map[string]any

		// Act
		obj.SetMetadata(fernTestValueMetadata)

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

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

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

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

		// Act
		obj.SetFailureReason(fernTestValueFailureReason)

		// 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("SetThumbnailState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueThumbnailState *DocumentsInit200ResponseResumedDocumentThumbnailState

		// Act
		obj.SetThumbnailState(fernTestValueThumbnailState)

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

		// Act
		obj.SetThumbnailURL(fernTestValueThumbnailURL)

		// 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 := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueCreatedAt float64

		// 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 := &DocumentsInit200ResponseResumedDocument{}
		var fernTestValueUpdatedAt float64

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

		// Act
		obj.SetCreatedBy(fernTestValueCreatedBy)

		// 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 TestGettersDocumentsInit200ResponseResumedUpload(t *testing.T) {
	t.Run("GetKind", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUpload{}
		var expected string
		obj.Kind = expected

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

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

	t.Run("GetPresigned", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUpload{}
		var expected *DocumentsInit200ResponseResumedUploadPresigned
		obj.Presigned = expected

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

	t.Run("GetPresigned_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUpload{}
		obj.Presigned = nil

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

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

	t.Run("GetProxy", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUpload{}
		var expected *DocumentsInit200ResponseResumedUploadProxy
		obj.Proxy = expected

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

	t.Run("GetProxy_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUpload{}
		obj.Proxy = nil

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

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

}

func TestSettersDocumentsInit200ResponseResumedUploadPresigned(t *testing.T) {
	t.Run("SetPresigned", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedUploadPresigned{}
		var fernTestValuePresigned *DocumentsInit200ResponseResumedUploadPresignedPresigned
		obj.SetPresigned(fernTestValuePresigned)
		assert.Equal(t, fernTestValuePresigned, obj.Presigned)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetKey", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedUploadPresigned{}
		var fernTestValueKey string
		obj.SetKey(fernTestValueKey)
		assert.Equal(t, fernTestValueKey, obj.Key)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsInit200ResponseResumedUploadPresigned(t *testing.T) {
	t.Run("GetPresigned", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadPresigned{}
		var expected *DocumentsInit200ResponseResumedUploadPresignedPresigned
		obj.Presigned = expected

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

	t.Run("GetPresigned_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadPresigned{}
		obj.Presigned = nil

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

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

	t.Run("GetKey", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadPresigned{}
		var expected string
		obj.Key = expected

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

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

}

func TestSettersMarkExplicitDocumentsInit200ResponseResumedUploadPresigned(t *testing.T) {
	t.Run("SetPresigned_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadPresigned{}
		var fernTestValuePresigned *DocumentsInit200ResponseResumedUploadPresignedPresigned

		// Act
		obj.SetPresigned(fernTestValuePresigned)

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

		// Act
		obj.SetKey(fernTestValueKey)

		// 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 TestSettersDocumentsInit200ResponseResumedUploadPresignedPresigned(t *testing.T) {
	t.Run("SetURL", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedUploadPresignedPresigned{}
		var fernTestValueURL string
		obj.SetURL(fernTestValueURL)
		assert.Equal(t, fernTestValueURL, obj.URL)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetHeaders", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedUploadPresignedPresigned{}
		var fernTestValueHeaders map[string]string
		obj.SetHeaders(fernTestValueHeaders)
		assert.Equal(t, fernTestValueHeaders, obj.Headers)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMethod", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedUploadPresignedPresigned{}
		var fernTestValueMethod DocumentsInit200ResponseResumedUploadPresignedPresignedMethod
		obj.SetMethod(fernTestValueMethod)
		assert.Equal(t, fernTestValueMethod, obj.Method)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetExpiresAt", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedUploadPresignedPresigned{}
		var fernTestValueExpiresAt float64
		obj.SetExpiresAt(fernTestValueExpiresAt)
		assert.Equal(t, fernTestValueExpiresAt, obj.ExpiresAt)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsInit200ResponseResumedUploadPresignedPresigned(t *testing.T) {
	t.Run("GetURL", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadPresignedPresigned{}
		var expected string
		obj.URL = expected

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

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

	t.Run("GetHeaders", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadPresignedPresigned{}
		var expected map[string]string
		obj.Headers = expected

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

	t.Run("GetHeaders_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadPresignedPresigned{}
		obj.Headers = nil

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

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

	t.Run("GetMethod", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadPresignedPresigned{}
		var expected DocumentsInit200ResponseResumedUploadPresignedPresignedMethod
		obj.Method = expected

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

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

	t.Run("GetExpiresAt", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadPresignedPresigned{}
		var expected float64
		obj.ExpiresAt = expected

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

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

}

func TestSettersMarkExplicitDocumentsInit200ResponseResumedUploadPresignedPresigned(t *testing.T) {
	t.Run("SetURL_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadPresignedPresigned{}
		var fernTestValueURL string

		// Act
		obj.SetURL(fernTestValueURL)

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

		// Act
		obj.SetHeaders(fernTestValueHeaders)

		// 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("SetMethod_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadPresignedPresigned{}
		var fernTestValueMethod DocumentsInit200ResponseResumedUploadPresignedPresignedMethod

		// Act
		obj.SetMethod(fernTestValueMethod)

		// 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("SetExpiresAt_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadPresignedPresigned{}
		var fernTestValueExpiresAt float64

		// Act
		obj.SetExpiresAt(fernTestValueExpiresAt)

		// 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 TestSettersDocumentsInit200ResponseResumedUploadProxy(t *testing.T) {
	t.Run("SetURL", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedUploadProxy{}
		var fernTestValueURL string
		obj.SetURL(fernTestValueURL)
		assert.Equal(t, fernTestValueURL, obj.URL)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetKey", func(t *testing.T) {
		obj := &DocumentsInit200ResponseResumedUploadProxy{}
		var fernTestValueKey string
		obj.SetKey(fernTestValueKey)
		assert.Equal(t, fernTestValueKey, obj.Key)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsInit200ResponseResumedUploadProxy(t *testing.T) {
	t.Run("GetURL", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadProxy{}
		var expected string
		obj.URL = expected

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

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

	t.Run("GetKey", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadProxy{}
		var expected string
		obj.Key = expected

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

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

}

func TestSettersMarkExplicitDocumentsInit200ResponseResumedUploadProxy(t *testing.T) {
	t.Run("SetURL_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsInit200ResponseResumedUploadProxy{}
		var fernTestValueURL string

		// Act
		obj.SetURL(fernTestValueURL)

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

		// Act
		obj.SetKey(fernTestValueKey)

		// 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 TestSettersDocumentsList200Response(t *testing.T) {
	t.Run("SetDocuments", func(t *testing.T) {
		obj := &DocumentsList200Response{}
		var fernTestValueDocuments []*DocumentsList200ResponseDocumentsItem
		obj.SetDocuments(fernTestValueDocuments)
		assert.Equal(t, fernTestValueDocuments, obj.Documents)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetNextCursor", func(t *testing.T) {
		obj := &DocumentsList200Response{}
		var fernTestValueNextCursor *string
		obj.SetNextCursor(fernTestValueNextCursor)
		assert.Equal(t, fernTestValueNextCursor, obj.NextCursor)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsList200Response(t *testing.T) {
	t.Run("GetDocuments", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200Response{}
		var expected []*DocumentsList200ResponseDocumentsItem
		obj.Documents = expected

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

	t.Run("GetDocuments_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200Response{}
		obj.Documents = nil

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

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

	t.Run("GetNextCursor", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200Response{}
		var expected *string
		obj.NextCursor = expected

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

	t.Run("GetNextCursor_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200Response{}
		obj.NextCursor = nil

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

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

}

func TestSettersMarkExplicitDocumentsList200Response(t *testing.T) {
	t.Run("SetDocuments_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200Response{}
		var fernTestValueDocuments []*DocumentsList200ResponseDocumentsItem

		// Act
		obj.SetDocuments(fernTestValueDocuments)

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

		// Act
		obj.SetNextCursor(fernTestValueNextCursor)

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

	t.Run("SetTenantID", func(t *testing.T) {
		obj := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetState", func(t *testing.T) {
		obj := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueState DocumentsList200ResponseDocumentsItemState
		obj.SetState(fernTestValueState)
		assert.Equal(t, fernTestValueState, obj.State)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetBaseSha", func(t *testing.T) {
		obj := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueBaseSha *string
		obj.SetBaseSha(fernTestValueBaseSha)
		assert.Equal(t, fernTestValueBaseSha, obj.BaseSha)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetStorageSizeBytes", func(t *testing.T) {
		obj := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueStorageSizeBytes *float64
		obj.SetStorageSizeBytes(fernTestValueStorageSizeBytes)
		assert.Equal(t, fernTestValueStorageSizeBytes, obj.StorageSizeBytes)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMetadata", func(t *testing.T) {
		obj := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueMetadata map[string]any
		obj.SetMetadata(fernTestValueMetadata)
		assert.Equal(t, fernTestValueMetadata, obj.Metadata)
		assert.NotNil(t, obj.explicitFields)
	})

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

	t.Run("SetFailureReason", func(t *testing.T) {
		obj := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueFailureReason *string
		obj.SetFailureReason(fernTestValueFailureReason)
		assert.Equal(t, fernTestValueFailureReason, obj.FailureReason)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetThumbnailState", func(t *testing.T) {
		obj := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueThumbnailState *DocumentsList200ResponseDocumentsItemThumbnailState
		obj.SetThumbnailState(fernTestValueThumbnailState)
		assert.Equal(t, fernTestValueThumbnailState, obj.ThumbnailState)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetThumbnailURL", func(t *testing.T) {
		obj := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueThumbnailURL *string
		obj.SetThumbnailURL(fernTestValueThumbnailURL)
		assert.Equal(t, fernTestValueThumbnailURL, obj.ThumbnailURL)
		assert.NotNil(t, obj.explicitFields)
	})

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

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

	t.Run("SetCreatedBy", func(t *testing.T) {
		obj := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueCreatedBy *string
		obj.SetCreatedBy(fernTestValueCreatedBy)
		assert.Equal(t, fernTestValueCreatedBy, obj.CreatedBy)
		assert.NotNil(t, obj.explicitFields)
	})

}

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

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

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

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

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

	t.Run("GetState", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		var expected DocumentsList200ResponseDocumentsItemState
		obj.State = expected

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

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

	t.Run("GetBaseSha", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		var expected *string
		obj.BaseSha = expected

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

	t.Run("GetBaseSha_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		obj.BaseSha = nil

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

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

	t.Run("GetStorageSizeBytes", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		var expected *float64
		obj.StorageSizeBytes = expected

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

	t.Run("GetStorageSizeBytes_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		obj.StorageSizeBytes = nil

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

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

	t.Run("GetMetadata", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		var expected map[string]any
		obj.Metadata = expected

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

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

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

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

	t.Run("GetIdempotencyKey", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		var expected *string
		obj.IdempotencyKey = expected

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

	t.Run("GetIdempotencyKey_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		obj.IdempotencyKey = nil

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

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

	t.Run("GetFailureReason", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		var expected *string
		obj.FailureReason = expected

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

	t.Run("GetFailureReason_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		obj.FailureReason = nil

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

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

	t.Run("GetThumbnailState", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		var expected *DocumentsList200ResponseDocumentsItemThumbnailState
		obj.ThumbnailState = expected

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

	t.Run("GetThumbnailState_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		obj.ThumbnailState = nil

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

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

	t.Run("GetThumbnailURL", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		var expected *string
		obj.ThumbnailURL = expected

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

	t.Run("GetThumbnailURL_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		obj.ThumbnailURL = nil

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

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

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

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

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

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

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

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

	t.Run("GetCreatedBy_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		obj.CreatedBy = nil

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

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

}

func TestSettersMarkExplicitDocumentsList200ResponseDocumentsItem(t *testing.T) {
	t.Run("SetID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		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("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

		// 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("SetState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueState DocumentsList200ResponseDocumentsItemState

		// Act
		obj.SetState(fernTestValueState)

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

		// Act
		obj.SetBaseSha(fernTestValueBaseSha)

		// 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("SetStorageSizeBytes_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueStorageSizeBytes *float64

		// Act
		obj.SetStorageSizeBytes(fernTestValueStorageSizeBytes)

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

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

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

	t.Run("SetMetadata_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueMetadata map[string]any

		// Act
		obj.SetMetadata(fernTestValueMetadata)

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

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

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

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

		// Act
		obj.SetFailureReason(fernTestValueFailureReason)

		// 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("SetThumbnailState_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueThumbnailState *DocumentsList200ResponseDocumentsItemThumbnailState

		// Act
		obj.SetThumbnailState(fernTestValueThumbnailState)

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

		// Act
		obj.SetThumbnailURL(fernTestValueThumbnailURL)

		// 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 := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueCreatedAt float64

		// 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 := &DocumentsList200ResponseDocumentsItem{}
		var fernTestValueUpdatedAt float64

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

		// Act
		obj.SetCreatedBy(fernTestValueCreatedBy)

		// 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 TestSettersDocumentsUploadProxy200Response(t *testing.T) {
	t.Run("SetSha256", func(t *testing.T) {
		obj := &DocumentsUploadProxy200Response{}
		var fernTestValueSha256 string
		obj.SetSha256(fernTestValueSha256)
		assert.Equal(t, fernTestValueSha256, obj.Sha256)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsUploadProxy200Response(t *testing.T) {
	t.Run("GetSha256", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsUploadProxy200Response{}
		var expected string
		obj.Sha256 = expected

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

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

}

func TestSettersMarkExplicitDocumentsUploadProxy200Response(t *testing.T) {
	t.Run("SetSha256_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsUploadProxy200Response{}
		var fernTestValueSha256 string

		// Act
		obj.SetSha256(fernTestValueSha256)

		// 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 TestSettersDocumentsImportFromRequestExpected(t *testing.T) {
	t.Run("SetSizeBytes", func(t *testing.T) {
		obj := &DocumentsImportFromRequestExpected{}
		var fernTestValueSizeBytes *int
		obj.SetSizeBytes(fernTestValueSizeBytes)
		assert.Equal(t, fernTestValueSizeBytes, obj.SizeBytes)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSha256", func(t *testing.T) {
		obj := &DocumentsImportFromRequestExpected{}
		var fernTestValueSha256 *string
		obj.SetSha256(fernTestValueSha256)
		assert.Equal(t, fernTestValueSha256, obj.Sha256)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsImportFromRequestExpected(t *testing.T) {
	t.Run("GetSizeBytes", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestExpected{}
		var expected *int
		obj.SizeBytes = expected

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

	t.Run("GetSizeBytes_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestExpected{}
		obj.SizeBytes = nil

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

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

	t.Run("GetSha256", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestExpected{}
		var expected *string
		obj.Sha256 = expected

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

	t.Run("GetSha256_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestExpected{}
		obj.Sha256 = nil

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

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

}

func TestSettersMarkExplicitDocumentsImportFromRequestExpected(t *testing.T) {
	t.Run("SetSizeBytes_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestExpected{}
		var fernTestValueSizeBytes *int

		// Act
		obj.SetSizeBytes(fernTestValueSizeBytes)

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

		// Act
		obj.SetSha256(fernTestValueSha256)

		// 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 TestGettersDocumentsImportFromRequestSource(t *testing.T) {
	t.Run("GetKind", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestSource{}
		var expected string
		obj.Kind = expected

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

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

	t.Run("GetURL", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestSource{}
		var expected *DocumentsImportFromRequestSourceURL
		obj.URL = expected

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

	t.Run("GetURL_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestSource{}
		obj.URL = nil

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

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

	t.Run("GetConnection", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestSource{}
		var expected *DocumentsImportFromRequestSourceConnection
		obj.Connection = expected

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

	t.Run("GetConnection_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestSource{}
		obj.Connection = nil

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

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

}

func TestSettersDocumentsImportFromRequestSourceConnection(t *testing.T) {
	t.Run("SetConnectionID", func(t *testing.T) {
		obj := &DocumentsImportFromRequestSourceConnection{}
		var fernTestValueConnectionID string
		obj.SetConnectionID(fernTestValueConnectionID)
		assert.Equal(t, fernTestValueConnectionID, obj.ConnectionID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetKey", func(t *testing.T) {
		obj := &DocumentsImportFromRequestSourceConnection{}
		var fernTestValueKey string
		obj.SetKey(fernTestValueKey)
		assert.Equal(t, fernTestValueKey, obj.Key)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetRevision", func(t *testing.T) {
		obj := &DocumentsImportFromRequestSourceConnection{}
		var fernTestValueRevision *string
		obj.SetRevision(fernTestValueRevision)
		assert.Equal(t, fernTestValueRevision, obj.Revision)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsImportFromRequestSourceConnection(t *testing.T) {
	t.Run("GetConnectionID", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestSourceConnection{}
		var expected string
		obj.ConnectionID = expected

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

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

	t.Run("GetKey", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestSourceConnection{}
		var expected string
		obj.Key = expected

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

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

	t.Run("GetRevision", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestSourceConnection{}
		var expected *string
		obj.Revision = expected

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

	t.Run("GetRevision_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestSourceConnection{}
		obj.Revision = nil

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

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

}

func TestSettersMarkExplicitDocumentsImportFromRequestSourceConnection(t *testing.T) {
	t.Run("SetConnectionID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestSourceConnection{}
		var fernTestValueConnectionID string

		// Act
		obj.SetConnectionID(fernTestValueConnectionID)

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

		// Act
		obj.SetKey(fernTestValueKey)

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

		// Act
		obj.SetRevision(fernTestValueRevision)

		// 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 TestSettersDocumentsImportFromRequestSourceURL(t *testing.T) {
	t.Run("SetURL", func(t *testing.T) {
		obj := &DocumentsImportFromRequestSourceURL{}
		var fernTestValueURL string
		obj.SetURL(fernTestValueURL)
		assert.Equal(t, fernTestValueURL, obj.URL)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersDocumentsImportFromRequestSourceURL(t *testing.T) {
	t.Run("GetURL", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestSourceURL{}
		var expected string
		obj.URL = expected

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

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

}

func TestSettersMarkExplicitDocumentsImportFromRequestSourceURL(t *testing.T) {
	t.Run("SetURL_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &DocumentsImportFromRequestSourceURL{}
		var fernTestValueURL string

		// Act
		obj.SetURL(fernTestValueURL)

		// 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 TestSettersUploadProxyDocumentsRequest(t *testing.T) {
	t.Run("SetTenantID", func(t *testing.T) {
		obj := &UploadProxyDocumentsRequest{}
		var fernTestValueTenantID string
		obj.SetTenantID(fernTestValueTenantID)
		assert.Equal(t, fernTestValueTenantID, obj.TenantID)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetID", func(t *testing.T) {
		obj := &UploadProxyDocumentsRequest{}
		var fernTestValueID string
		obj.SetID(fernTestValueID)
		assert.Equal(t, fernTestValueID, obj.ID)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestSettersMarkExplicitUploadProxyDocumentsRequest(t *testing.T) {
	t.Run("SetTenantID_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &UploadProxyDocumentsRequest{}
		var fernTestValueTenantID string

		// Act
		obj.SetTenantID(fernTestValueTenantID)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestEnumDocumentsCommit200ResponseDocumentState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsCommit200ResponseDocumentStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsCommit200ResponseDocumentState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsCommit200ResponseDocumentStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsCommit200ResponseDocumentState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsCommit200ResponseDocumentStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsCommit200ResponseDocumentState("failed"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_deleting", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsCommit200ResponseDocumentStateFromString("deleting")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsCommit200ResponseDocumentState("deleting"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsCommit200ResponseDocumentThumbnailState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsCommit200ResponseDocumentThumbnailStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsCommit200ResponseDocumentThumbnailState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsCommit200ResponseDocumentThumbnailStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsCommit200ResponseDocumentThumbnailState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_locked", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsCommit200ResponseDocumentThumbnailStateFromString("locked")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsCommit200ResponseDocumentThumbnailState("locked"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsCommit200ResponseDocumentThumbnailStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsCommit200ResponseDocumentThumbnailState("failed"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsGet200ResponseDocumentState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsGet200ResponseDocumentStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsGet200ResponseDocumentState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsGet200ResponseDocumentStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsGet200ResponseDocumentState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsGet200ResponseDocumentStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsGet200ResponseDocumentState("failed"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_deleting", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsGet200ResponseDocumentStateFromString("deleting")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsGet200ResponseDocumentState("deleting"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsGet200ResponseDocumentThumbnailState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsGet200ResponseDocumentThumbnailStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsGet200ResponseDocumentThumbnailState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsGet200ResponseDocumentThumbnailStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsGet200ResponseDocumentThumbnailState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_locked", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsGet200ResponseDocumentThumbnailStateFromString("locked")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsGet200ResponseDocumentThumbnailState("locked"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsGet200ResponseDocumentThumbnailStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsGet200ResponseDocumentThumbnailState("failed"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsImportFrom200ResponseDocumentState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFrom200ResponseDocumentStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFrom200ResponseDocumentState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFrom200ResponseDocumentStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFrom200ResponseDocumentState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFrom200ResponseDocumentStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFrom200ResponseDocumentState("failed"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_deleting", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFrom200ResponseDocumentStateFromString("deleting")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFrom200ResponseDocumentState("deleting"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsImportFrom200ResponseDocumentThumbnailState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFrom200ResponseDocumentThumbnailStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFrom200ResponseDocumentThumbnailState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFrom200ResponseDocumentThumbnailStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFrom200ResponseDocumentThumbnailState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_locked", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFrom200ResponseDocumentThumbnailStateFromString("locked")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFrom200ResponseDocumentThumbnailState("locked"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFrom200ResponseDocumentThumbnailStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFrom200ResponseDocumentThumbnailState("failed"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsImportFrom200ResponseTag(t *testing.T) {
	t.Run("NewFromString_imported", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFrom200ResponseTagFromString("imported")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFrom200ResponseTag("imported"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_deduped", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFrom200ResponseTagFromString("deduped")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFrom200ResponseTag("deduped"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_accepted", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFrom200ResponseTagFromString("accepted")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFrom200ResponseTag("accepted"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsImportFromRequestDedupMode(t *testing.T) {
	t.Run("NewFromString_always_create", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFromRequestDedupModeFromString("always-create")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFromRequestDedupMode("always-create"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_reuse_existing", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFromRequestDedupModeFromString("reuse-existing")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFromRequestDedupMode("reuse-existing"), val, "enum value should match expected wire value")
	})

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

	t.Run("Ptr", func(t *testing.T) {
		val, err := NewDocumentsImportFromRequestDedupModeFromString("always-create")
		assert.NoError(t, err)
		ptr := val.Ptr()
		assert.NotNil(t, ptr)
		assert.Equal(t, val, *ptr)
	})
}

func TestEnumDocumentsImportFromRequestMode(t *testing.T) {
	t.Run("NewFromString_sync", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFromRequestModeFromString("sync")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFromRequestMode("sync"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_async", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsImportFromRequestModeFromString("async")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsImportFromRequestMode("async"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsInit200ResponseCreatedDocumentState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseCreatedDocumentStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseCreatedDocumentState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseCreatedDocumentStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseCreatedDocumentState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseCreatedDocumentStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseCreatedDocumentState("failed"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_deleting", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseCreatedDocumentStateFromString("deleting")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseCreatedDocumentState("deleting"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsInit200ResponseCreatedDocumentThumbnailState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseCreatedDocumentThumbnailStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseCreatedDocumentThumbnailState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseCreatedDocumentThumbnailStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseCreatedDocumentThumbnailState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_locked", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseCreatedDocumentThumbnailStateFromString("locked")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseCreatedDocumentThumbnailState("locked"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseCreatedDocumentThumbnailStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseCreatedDocumentThumbnailState("failed"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsInit200ResponseCreatedUploadPresignedPresignedMethod(t *testing.T) {
	t.Run("NewFromString_PUT", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseCreatedUploadPresignedPresignedMethodFromString("PUT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseCreatedUploadPresignedPresignedMethod("PUT"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsInit200ResponseDedupedDocumentState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseDedupedDocumentStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseDedupedDocumentState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseDedupedDocumentStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseDedupedDocumentState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseDedupedDocumentStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseDedupedDocumentState("failed"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_deleting", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseDedupedDocumentStateFromString("deleting")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseDedupedDocumentState("deleting"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsInit200ResponseDedupedDocumentThumbnailState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseDedupedDocumentThumbnailStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseDedupedDocumentThumbnailState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseDedupedDocumentThumbnailStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseDedupedDocumentThumbnailState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_locked", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseDedupedDocumentThumbnailStateFromString("locked")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseDedupedDocumentThumbnailState("locked"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseDedupedDocumentThumbnailStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseDedupedDocumentThumbnailState("failed"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsInit200ResponseResumedDocumentState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseResumedDocumentStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseResumedDocumentState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseResumedDocumentStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseResumedDocumentState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseResumedDocumentStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseResumedDocumentState("failed"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_deleting", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseResumedDocumentStateFromString("deleting")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseResumedDocumentState("deleting"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsInit200ResponseResumedDocumentThumbnailState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseResumedDocumentThumbnailStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseResumedDocumentThumbnailState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseResumedDocumentThumbnailStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseResumedDocumentThumbnailState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_locked", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseResumedDocumentThumbnailStateFromString("locked")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseResumedDocumentThumbnailState("locked"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseResumedDocumentThumbnailStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseResumedDocumentThumbnailState("failed"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsInit200ResponseResumedUploadPresignedPresignedMethod(t *testing.T) {
	t.Run("NewFromString_PUT", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInit200ResponseResumedUploadPresignedPresignedMethodFromString("PUT")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInit200ResponseResumedUploadPresignedPresignedMethod("PUT"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsInitRequestDedupMode(t *testing.T) {
	t.Run("NewFromString_always_create", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInitRequestDedupModeFromString("always-create")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInitRequestDedupMode("always-create"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_reuse_existing", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInitRequestDedupModeFromString("reuse-existing")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInitRequestDedupMode("reuse-existing"), val, "enum value should match expected wire value")
	})

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

	t.Run("Ptr", func(t *testing.T) {
		val, err := NewDocumentsInitRequestDedupModeFromString("always-create")
		assert.NoError(t, err)
		ptr := val.Ptr()
		assert.NotNil(t, ptr)
		assert.Equal(t, val, *ptr)
	})
}

func TestEnumDocumentsInitRequestUploadPreference(t *testing.T) {
	t.Run("NewFromString_auto", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInitRequestUploadPreferenceFromString("auto")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInitRequestUploadPreference("auto"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_presigned", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInitRequestUploadPreferenceFromString("presigned")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInitRequestUploadPreference("presigned"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_proxy", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsInitRequestUploadPreferenceFromString("proxy")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsInitRequestUploadPreference("proxy"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsList200ResponseDocumentsItemState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsList200ResponseDocumentsItemStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsList200ResponseDocumentsItemState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsList200ResponseDocumentsItemStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsList200ResponseDocumentsItemState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsList200ResponseDocumentsItemStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsList200ResponseDocumentsItemState("failed"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_deleting", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsList200ResponseDocumentsItemStateFromString("deleting")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsList200ResponseDocumentsItemState("deleting"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumDocumentsList200ResponseDocumentsItemThumbnailState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsList200ResponseDocumentsItemThumbnailStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsList200ResponseDocumentsItemThumbnailState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsList200ResponseDocumentsItemThumbnailStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsList200ResponseDocumentsItemThumbnailState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_locked", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsList200ResponseDocumentsItemThumbnailStateFromString("locked")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsList200ResponseDocumentsItemThumbnailState("locked"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewDocumentsList200ResponseDocumentsItemThumbnailStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, DocumentsList200ResponseDocumentsItemThumbnailState("failed"), val, "enum value should match expected wire value")
	})

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

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

func TestEnumListDocumentsRequestState(t *testing.T) {
	t.Run("NewFromString_pending", func(t *testing.T) {
		t.Parallel()
		val, err := NewListDocumentsRequestStateFromString("pending")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ListDocumentsRequestState("pending"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_ready", func(t *testing.T) {
		t.Parallel()
		val, err := NewListDocumentsRequestStateFromString("ready")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ListDocumentsRequestState("ready"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_failed", func(t *testing.T) {
		t.Parallel()
		val, err := NewListDocumentsRequestStateFromString("failed")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ListDocumentsRequestState("failed"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_deleting", func(t *testing.T) {
		t.Parallel()
		val, err := NewListDocumentsRequestStateFromString("deleting")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ListDocumentsRequestState("deleting"), val, "enum value should match expected wire value")
	})

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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