readme_test.go

// Code generated by Fern. DO NOT EDIT.

package generatorcli

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

func TestSettersCargoPublishInfo(t *testing.T) {
	t.Run("SetPackageName", func(t *testing.T) {
		obj := &CargoPublishInfo{}
		var fernTestValuePackageName string
		obj.SetPackageName(fernTestValuePackageName)
		assert.Equal(t, fernTestValuePackageName, obj.PackageName)
		assert.NotNil(t, obj.explicitFields)
	})

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

}

func TestGettersCargoPublishInfo(t *testing.T) {
	t.Run("GetPackageName", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CargoPublishInfo{}
		var expected string
		obj.PackageName = expected

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

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

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

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

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

}

func TestSettersMarkExplicitCargoPublishInfo(t *testing.T) {
	t.Run("SetPackageName_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CargoPublishInfo{}
		var fernTestValuePackageName string

		// Act
		obj.SetPackageName(fernTestValuePackageName)

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

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

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

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

		// Act
		obj.SetVersion(fernTestValueVersion)

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

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

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

}

func TestSettersCodeSnippet(t *testing.T) {
	t.Run("SetContent", func(t *testing.T) {
		obj := &CodeSnippet{}
		var fernTestValueContent string
		obj.SetContent(fernTestValueContent)
		assert.Equal(t, fernTestValueContent, obj.Content)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetLanguage", func(t *testing.T) {
		obj := &CodeSnippet{}
		var fernTestValueLanguage *string
		obj.SetLanguage(fernTestValueLanguage)
		assert.Equal(t, fernTestValueLanguage, obj.Language)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersCodeSnippet(t *testing.T) {
	t.Run("GetContent", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CodeSnippet{}
		var expected string
		obj.Content = expected

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

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

	t.Run("GetLanguage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CodeSnippet{}
		var expected *string
		obj.Language = expected

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

	t.Run("GetLanguage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CodeSnippet{}
		obj.Language = nil

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

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

}

func TestSettersMarkExplicitCodeSnippet(t *testing.T) {
	t.Run("SetContent_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CodeSnippet{}
		var fernTestValueContent string

		// Act
		obj.SetContent(fernTestValueContent)

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

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

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

	t.Run("SetLanguage_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CodeSnippet{}
		var fernTestValueLanguage *string

		// Act
		obj.SetLanguage(fernTestValueLanguage)

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

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

		// Note: This 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 TestSettersComposerPublishInfo(t *testing.T) {
	t.Run("SetPackageName", func(t *testing.T) {
		obj := &ComposerPublishInfo{}
		var fernTestValuePackageName string
		obj.SetPackageName(fernTestValuePackageName)
		assert.Equal(t, fernTestValuePackageName, obj.PackageName)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersComposerPublishInfo(t *testing.T) {
	t.Run("GetPackageName", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ComposerPublishInfo{}
		var expected string
		obj.PackageName = expected

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

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

}

func TestSettersMarkExplicitComposerPublishInfo(t *testing.T) {
	t.Run("SetPackageName_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ComposerPublishInfo{}
		var fernTestValuePackageName string

		// Act
		obj.SetPackageName(fernTestValuePackageName)

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

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

		// Note: This 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 TestSettersCsharpInfo(t *testing.T) {
	t.Run("SetPublishInfo", func(t *testing.T) {
		obj := &CsharpInfo{}
		var fernTestValuePublishInfo *NugetPublishInfo
		obj.SetPublishInfo(fernTestValuePublishInfo)
		assert.Equal(t, fernTestValuePublishInfo, obj.PublishInfo)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersCsharpInfo(t *testing.T) {
	t.Run("GetPublishInfo", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CsharpInfo{}
		var expected *NugetPublishInfo
		obj.PublishInfo = expected

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

	t.Run("GetPublishInfo_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CsharpInfo{}
		obj.PublishInfo = nil

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

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

}

func TestSettersMarkExplicitCsharpInfo(t *testing.T) {
	t.Run("SetPublishInfo_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CsharpInfo{}
		var fernTestValuePublishInfo *NugetPublishInfo

		// Act
		obj.SetPublishInfo(fernTestValuePublishInfo)

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

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

		// Note: This 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 TestSettersCustomSection(t *testing.T) {
	t.Run("SetName", func(t *testing.T) {
		obj := &CustomSection{}
		var fernTestValueName string
		obj.SetName(fernTestValueName)
		assert.Equal(t, fernTestValueName, obj.Name)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetLanguage", func(t *testing.T) {
		obj := &CustomSection{}
		var fernTestValueLanguage Language
		obj.SetLanguage(fernTestValueLanguage)
		assert.Equal(t, fernTestValueLanguage, obj.Language)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetContent", func(t *testing.T) {
		obj := &CustomSection{}
		var fernTestValueContent string
		obj.SetContent(fernTestValueContent)
		assert.Equal(t, fernTestValueContent, obj.Content)
		assert.NotNil(t, obj.explicitFields)
	})

}

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

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

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

	t.Run("GetLanguage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CustomSection{}
		var expected Language
		obj.Language = expected

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

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

	t.Run("GetContent", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CustomSection{}
		var expected string
		obj.Content = expected

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

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

}

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

		// Act
		obj.SetName(fernTestValueName)

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

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

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

	t.Run("SetLanguage_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CustomSection{}
		var fernTestValueLanguage Language

		// Act
		obj.SetLanguage(fernTestValueLanguage)

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

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

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

	t.Run("SetContent_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &CustomSection{}
		var fernTestValueContent string

		// Act
		obj.SetContent(fernTestValueContent)

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

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

		// Note: This 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 TestSettersGithubRemote(t *testing.T) {
	t.Run("SetRepoUrl", func(t *testing.T) {
		obj := &GithubRemote{}
		var fernTestValueRepoUrl string
		obj.SetRepoUrl(fernTestValueRepoUrl)
		assert.Equal(t, fernTestValueRepoUrl, obj.RepoUrl)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetInstallationToken", func(t *testing.T) {
		obj := &GithubRemote{}
		var fernTestValueInstallationToken string
		obj.SetInstallationToken(fernTestValueInstallationToken)
		assert.Equal(t, fernTestValueInstallationToken, obj.InstallationToken)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetBranch", func(t *testing.T) {
		obj := &GithubRemote{}
		var fernTestValueBranch *string
		obj.SetBranch(fernTestValueBranch)
		assert.Equal(t, fernTestValueBranch, obj.Branch)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersGithubRemote(t *testing.T) {
	t.Run("GetRepoUrl", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GithubRemote{}
		var expected string
		obj.RepoUrl = expected

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

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

	t.Run("GetInstallationToken", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GithubRemote{}
		var expected string
		obj.InstallationToken = expected

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

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

	t.Run("GetBranch", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GithubRemote{}
		var expected *string
		obj.Branch = expected

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

	t.Run("GetBranch_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GithubRemote{}
		obj.Branch = nil

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

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

}

func TestSettersMarkExplicitGithubRemote(t *testing.T) {
	t.Run("SetRepoUrl_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GithubRemote{}
		var fernTestValueRepoUrl string

		// Act
		obj.SetRepoUrl(fernTestValueRepoUrl)

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

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

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

	t.Run("SetInstallationToken_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GithubRemote{}
		var fernTestValueInstallationToken string

		// Act
		obj.SetInstallationToken(fernTestValueInstallationToken)

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

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

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

	t.Run("SetBranch_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GithubRemote{}
		var fernTestValueBranch *string

		// Act
		obj.SetBranch(fernTestValueBranch)

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

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

		// Note: This 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 TestSettersGoInfo(t *testing.T) {
	t.Run("SetPublishInfo", func(t *testing.T) {
		obj := &GoInfo{}
		var fernTestValuePublishInfo *GoPublishInfo
		obj.SetPublishInfo(fernTestValuePublishInfo)
		assert.Equal(t, fernTestValuePublishInfo, obj.PublishInfo)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersGoInfo(t *testing.T) {
	t.Run("GetPublishInfo", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GoInfo{}
		var expected *GoPublishInfo
		obj.PublishInfo = expected

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

	t.Run("GetPublishInfo_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GoInfo{}
		obj.PublishInfo = nil

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

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

}

func TestSettersMarkExplicitGoInfo(t *testing.T) {
	t.Run("SetPublishInfo_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GoInfo{}
		var fernTestValuePublishInfo *GoPublishInfo

		// Act
		obj.SetPublishInfo(fernTestValuePublishInfo)

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

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

		// Note: This 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 TestSettersGoPublishInfo(t *testing.T) {
	t.Run("SetOwner", func(t *testing.T) {
		obj := &GoPublishInfo{}
		var fernTestValueOwner string
		obj.SetOwner(fernTestValueOwner)
		assert.Equal(t, fernTestValueOwner, obj.Owner)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetRepo", func(t *testing.T) {
		obj := &GoPublishInfo{}
		var fernTestValueRepo string
		obj.SetRepo(fernTestValueRepo)
		assert.Equal(t, fernTestValueRepo, obj.Repo)
		assert.NotNil(t, obj.explicitFields)
	})

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

}

func TestGettersGoPublishInfo(t *testing.T) {
	t.Run("GetOwner", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GoPublishInfo{}
		var expected string
		obj.Owner = expected

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

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

	t.Run("GetRepo", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GoPublishInfo{}
		var expected string
		obj.Repo = expected

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

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

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

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

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

}

func TestSettersMarkExplicitGoPublishInfo(t *testing.T) {
	t.Run("SetOwner_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GoPublishInfo{}
		var fernTestValueOwner string

		// Act
		obj.SetOwner(fernTestValueOwner)

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

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

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

	t.Run("SetRepo_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &GoPublishInfo{}
		var fernTestValueRepo string

		// Act
		obj.SetRepo(fernTestValueRepo)

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

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

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

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

		// Act
		obj.SetVersion(fernTestValueVersion)

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

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

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

}

func TestSettersJavaInfo(t *testing.T) {
	t.Run("SetPublishInfo", func(t *testing.T) {
		obj := &JavaInfo{}
		var fernTestValuePublishInfo *MavenPublishInfo
		obj.SetPublishInfo(fernTestValuePublishInfo)
		assert.Equal(t, fernTestValuePublishInfo, obj.PublishInfo)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersJavaInfo(t *testing.T) {
	t.Run("GetPublishInfo", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &JavaInfo{}
		var expected *MavenPublishInfo
		obj.PublishInfo = expected

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

	t.Run("GetPublishInfo_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &JavaInfo{}
		obj.PublishInfo = nil

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

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

}

func TestSettersMarkExplicitJavaInfo(t *testing.T) {
	t.Run("SetPublishInfo_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &JavaInfo{}
		var fernTestValuePublishInfo *MavenPublishInfo

		// Act
		obj.SetPublishInfo(fernTestValuePublishInfo)

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

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

		// Note: This 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 TestGettersLanguageInfo(t *testing.T) {
	t.Run("GetType", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		var expected string
		obj.Type = expected

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

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

	t.Run("GetTypescript", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		var expected *TypescriptInfo
		obj.Typescript = expected

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

	t.Run("GetTypescript_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		obj.Typescript = nil

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

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

	t.Run("GetPython", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		var expected *PythonInfo
		obj.Python = expected

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

	t.Run("GetPython_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		obj.Python = nil

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

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

	t.Run("GetGo", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		var expected *GoInfo
		obj.Go = expected

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

	t.Run("GetGo_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		obj.Go = nil

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

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

	t.Run("GetJava", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		var expected *JavaInfo
		obj.Java = expected

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

	t.Run("GetJava_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		obj.Java = nil

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

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

	t.Run("GetRuby", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		var expected *RubyInfo
		obj.Ruby = expected

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

	t.Run("GetRuby_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		obj.Ruby = nil

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

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

	t.Run("GetCsharp", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		var expected *CsharpInfo
		obj.Csharp = expected

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

	t.Run("GetCsharp_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		obj.Csharp = nil

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

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

	t.Run("GetPhp", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		var expected *PhpInfo
		obj.Php = expected

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

	t.Run("GetPhp_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		obj.Php = nil

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

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

	t.Run("GetRust", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		var expected *RustInfo
		obj.Rust = expected

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

	t.Run("GetRust_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		obj.Rust = nil

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

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

	t.Run("GetSwift", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		var expected *SwiftInfo
		obj.Swift = expected

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

	t.Run("GetSwift_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &LanguageInfo{}
		obj.Swift = nil

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

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

}

func TestSettersMarkdownSnippet(t *testing.T) {
	t.Run("SetContent", func(t *testing.T) {
		obj := &MarkdownSnippet{}
		var fernTestValueContent string
		obj.SetContent(fernTestValueContent)
		assert.Equal(t, fernTestValueContent, obj.Content)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersMarkdownSnippet(t *testing.T) {
	t.Run("GetContent", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &MarkdownSnippet{}
		var expected string
		obj.Content = expected

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

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

}

func TestSettersMarkExplicitMarkdownSnippet(t *testing.T) {
	t.Run("SetContent_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &MarkdownSnippet{}
		var fernTestValueContent string

		// Act
		obj.SetContent(fernTestValueContent)

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

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

		// Note: This 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 TestSettersMavenPublishInfo(t *testing.T) {
	t.Run("SetArtifact", func(t *testing.T) {
		obj := &MavenPublishInfo{}
		var fernTestValueArtifact string
		obj.SetArtifact(fernTestValueArtifact)
		assert.Equal(t, fernTestValueArtifact, obj.Artifact)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetGroup", func(t *testing.T) {
		obj := &MavenPublishInfo{}
		var fernTestValueGroup string
		obj.SetGroup(fernTestValueGroup)
		assert.Equal(t, fernTestValueGroup, obj.Group)
		assert.NotNil(t, obj.explicitFields)
	})

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

}

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

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

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

	t.Run("GetGroup", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &MavenPublishInfo{}
		var expected string
		obj.Group = expected

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

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

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

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

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

}

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

		// Act
		obj.SetArtifact(fernTestValueArtifact)

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

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

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

	t.Run("SetGroup_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &MavenPublishInfo{}
		var fernTestValueGroup string

		// Act
		obj.SetGroup(fernTestValueGroup)

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

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

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

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

		// Act
		obj.SetVersion(fernTestValueVersion)

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

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

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

}

func TestSettersNpmPublishInfo(t *testing.T) {
	t.Run("SetPackageName", func(t *testing.T) {
		obj := &NpmPublishInfo{}
		var fernTestValuePackageName string
		obj.SetPackageName(fernTestValuePackageName)
		assert.Equal(t, fernTestValuePackageName, obj.PackageName)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersNpmPublishInfo(t *testing.T) {
	t.Run("GetPackageName", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &NpmPublishInfo{}
		var expected string
		obj.PackageName = expected

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

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

}

func TestSettersMarkExplicitNpmPublishInfo(t *testing.T) {
	t.Run("SetPackageName_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &NpmPublishInfo{}
		var fernTestValuePackageName string

		// Act
		obj.SetPackageName(fernTestValuePackageName)

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

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

		// Note: This 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 TestSettersNugetPublishInfo(t *testing.T) {
	t.Run("SetPackageName", func(t *testing.T) {
		obj := &NugetPublishInfo{}
		var fernTestValuePackageName string
		obj.SetPackageName(fernTestValuePackageName)
		assert.Equal(t, fernTestValuePackageName, obj.PackageName)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersNugetPublishInfo(t *testing.T) {
	t.Run("GetPackageName", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &NugetPublishInfo{}
		var expected string
		obj.PackageName = expected

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

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

}

func TestSettersMarkExplicitNugetPublishInfo(t *testing.T) {
	t.Run("SetPackageName_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &NugetPublishInfo{}
		var fernTestValuePackageName string

		// Act
		obj.SetPackageName(fernTestValuePackageName)

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

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

		// Note: This 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 TestSettersPhpInfo(t *testing.T) {
	t.Run("SetPublishInfo", func(t *testing.T) {
		obj := &PhpInfo{}
		var fernTestValuePublishInfo *ComposerPublishInfo
		obj.SetPublishInfo(fernTestValuePublishInfo)
		assert.Equal(t, fernTestValuePublishInfo, obj.PublishInfo)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersPhpInfo(t *testing.T) {
	t.Run("GetPublishInfo", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PhpInfo{}
		var expected *ComposerPublishInfo
		obj.PublishInfo = expected

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

	t.Run("GetPublishInfo_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PhpInfo{}
		obj.PublishInfo = nil

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

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

}

func TestSettersMarkExplicitPhpInfo(t *testing.T) {
	t.Run("SetPublishInfo_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PhpInfo{}
		var fernTestValuePublishInfo *ComposerPublishInfo

		// Act
		obj.SetPublishInfo(fernTestValuePublishInfo)

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

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

		// Note: This 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 TestSettersPypiPublishInfo(t *testing.T) {
	t.Run("SetPackageName", func(t *testing.T) {
		obj := &PypiPublishInfo{}
		var fernTestValuePackageName string
		obj.SetPackageName(fernTestValuePackageName)
		assert.Equal(t, fernTestValuePackageName, obj.PackageName)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersPypiPublishInfo(t *testing.T) {
	t.Run("GetPackageName", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PypiPublishInfo{}
		var expected string
		obj.PackageName = expected

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

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

}

func TestSettersMarkExplicitPypiPublishInfo(t *testing.T) {
	t.Run("SetPackageName_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PypiPublishInfo{}
		var fernTestValuePackageName string

		// Act
		obj.SetPackageName(fernTestValuePackageName)

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

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

		// Note: This 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 TestSettersPythonInfo(t *testing.T) {
	t.Run("SetPublishInfo", func(t *testing.T) {
		obj := &PythonInfo{}
		var fernTestValuePublishInfo *PypiPublishInfo
		obj.SetPublishInfo(fernTestValuePublishInfo)
		assert.Equal(t, fernTestValuePublishInfo, obj.PublishInfo)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersPythonInfo(t *testing.T) {
	t.Run("GetPublishInfo", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PythonInfo{}
		var expected *PypiPublishInfo
		obj.PublishInfo = expected

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

	t.Run("GetPublishInfo_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PythonInfo{}
		obj.PublishInfo = nil

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

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

}

func TestSettersMarkExplicitPythonInfo(t *testing.T) {
	t.Run("SetPublishInfo_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &PythonInfo{}
		var fernTestValuePublishInfo *PypiPublishInfo

		// Act
		obj.SetPublishInfo(fernTestValuePublishInfo)

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

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

		// Note: This 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 TestSettersReadmeConfig(t *testing.T) {
	t.Run("SetRemote", func(t *testing.T) {
		obj := &ReadmeConfig{}
		var fernTestValueRemote *Remote
		obj.SetRemote(fernTestValueRemote)
		assert.Equal(t, fernTestValueRemote, obj.Remote)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetLanguage", func(t *testing.T) {
		obj := &ReadmeConfig{}
		var fernTestValueLanguage *LanguageInfo
		obj.SetLanguage(fernTestValueLanguage)
		assert.Equal(t, fernTestValueLanguage, obj.Language)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetOrganization", func(t *testing.T) {
		obj := &ReadmeConfig{}
		var fernTestValueOrganization string
		obj.SetOrganization(fernTestValueOrganization)
		assert.Equal(t, fernTestValueOrganization, obj.Organization)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetApiName", func(t *testing.T) {
		obj := &ReadmeConfig{}
		var fernTestValueApiName *string
		obj.SetApiName(fernTestValueApiName)
		assert.Equal(t, fernTestValueApiName, obj.ApiName)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetBannerLink", func(t *testing.T) {
		obj := &ReadmeConfig{}
		var fernTestValueBannerLink *string
		obj.SetBannerLink(fernTestValueBannerLink)
		assert.Equal(t, fernTestValueBannerLink, obj.BannerLink)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetIntroduction", func(t *testing.T) {
		obj := &ReadmeConfig{}
		var fernTestValueIntroduction *string
		obj.SetIntroduction(fernTestValueIntroduction)
		assert.Equal(t, fernTestValueIntroduction, obj.Introduction)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetApiReferenceLink", func(t *testing.T) {
		obj := &ReadmeConfig{}
		var fernTestValueApiReferenceLink *string
		obj.SetApiReferenceLink(fernTestValueApiReferenceLink)
		assert.Equal(t, fernTestValueApiReferenceLink, obj.ApiReferenceLink)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetReferenceMarkdownPath", func(t *testing.T) {
		obj := &ReadmeConfig{}
		var fernTestValueReferenceMarkdownPath *string
		obj.SetReferenceMarkdownPath(fernTestValueReferenceMarkdownPath)
		assert.Equal(t, fernTestValueReferenceMarkdownPath, obj.ReferenceMarkdownPath)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetRequirements", func(t *testing.T) {
		obj := &ReadmeConfig{}
		var fernTestValueRequirements []string
		obj.SetRequirements(fernTestValueRequirements)
		assert.Equal(t, fernTestValueRequirements, obj.Requirements)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetDisabledFeatures", func(t *testing.T) {
		obj := &ReadmeConfig{}
		var fernTestValueDisabledFeatures []*FeatureId
		obj.SetDisabledFeatures(fernTestValueDisabledFeatures)
		assert.Equal(t, fernTestValueDisabledFeatures, obj.DisabledFeatures)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetWhiteLabel", func(t *testing.T) {
		obj := &ReadmeConfig{}
		var fernTestValueWhiteLabel *bool
		obj.SetWhiteLabel(fernTestValueWhiteLabel)
		assert.Equal(t, fernTestValueWhiteLabel, obj.WhiteLabel)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetCustomSections", func(t *testing.T) {
		obj := &ReadmeConfig{}
		var fernTestValueCustomSections []*CustomSection
		obj.SetCustomSections(fernTestValueCustomSections)
		assert.Equal(t, fernTestValueCustomSections, obj.CustomSections)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetFeatures", func(t *testing.T) {
		obj := &ReadmeConfig{}
		var fernTestValueFeatures []*ReadmeFeature
		obj.SetFeatures(fernTestValueFeatures)
		assert.Equal(t, fernTestValueFeatures, obj.Features)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetExampleStyle", func(t *testing.T) {
		obj := &ReadmeConfig{}
		var fernTestValueExampleStyle *ExampleStyle
		obj.SetExampleStyle(fernTestValueExampleStyle)
		assert.Equal(t, fernTestValueExampleStyle, obj.ExampleStyle)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersReadmeConfig(t *testing.T) {
	t.Run("GetRemote", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var expected *Remote
		obj.Remote = expected

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

	t.Run("GetRemote_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		obj.Remote = nil

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

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

	t.Run("GetLanguage", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var expected *LanguageInfo
		obj.Language = expected

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

	t.Run("GetLanguage_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		obj.Language = nil

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

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

	t.Run("GetOrganization", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var expected string
		obj.Organization = expected

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

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

	t.Run("GetApiName", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var expected *string
		obj.ApiName = expected

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

	t.Run("GetApiName_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		obj.ApiName = nil

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

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

	t.Run("GetBannerLink", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var expected *string
		obj.BannerLink = expected

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

	t.Run("GetBannerLink_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		obj.BannerLink = nil

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

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

	t.Run("GetIntroduction", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var expected *string
		obj.Introduction = expected

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

	t.Run("GetIntroduction_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		obj.Introduction = nil

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

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

	t.Run("GetApiReferenceLink", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var expected *string
		obj.ApiReferenceLink = expected

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

	t.Run("GetApiReferenceLink_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		obj.ApiReferenceLink = nil

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

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

	t.Run("GetReferenceMarkdownPath", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var expected *string
		obj.ReferenceMarkdownPath = expected

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

	t.Run("GetReferenceMarkdownPath_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		obj.ReferenceMarkdownPath = nil

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

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

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

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

	t.Run("GetRequirements_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		obj.Requirements = nil

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

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

	t.Run("GetDisabledFeatures", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var expected []*FeatureId
		obj.DisabledFeatures = expected

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

	t.Run("GetDisabledFeatures_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		obj.DisabledFeatures = nil

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

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

	t.Run("GetWhiteLabel", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var expected *bool
		obj.WhiteLabel = expected

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

	t.Run("GetWhiteLabel_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		obj.WhiteLabel = nil

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

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

	t.Run("GetCustomSections", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var expected []*CustomSection
		obj.CustomSections = expected

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

	t.Run("GetCustomSections_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		obj.CustomSections = nil

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

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

	t.Run("GetFeatures", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var expected []*ReadmeFeature
		obj.Features = expected

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

	t.Run("GetFeatures_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		obj.Features = nil

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

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

	t.Run("GetExampleStyle", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var expected *ExampleStyle
		obj.ExampleStyle = expected

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

	t.Run("GetExampleStyle_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		obj.ExampleStyle = nil

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

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

}

func TestSettersMarkExplicitReadmeConfig(t *testing.T) {
	t.Run("SetRemote_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var fernTestValueRemote *Remote

		// Act
		obj.SetRemote(fernTestValueRemote)

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

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

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

	t.Run("SetLanguage_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var fernTestValueLanguage *LanguageInfo

		// Act
		obj.SetLanguage(fernTestValueLanguage)

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

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

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

	t.Run("SetOrganization_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var fernTestValueOrganization string

		// Act
		obj.SetOrganization(fernTestValueOrganization)

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

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

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

	t.Run("SetApiName_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var fernTestValueApiName *string

		// Act
		obj.SetApiName(fernTestValueApiName)

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

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

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

	t.Run("SetBannerLink_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var fernTestValueBannerLink *string

		// Act
		obj.SetBannerLink(fernTestValueBannerLink)

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

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

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

	t.Run("SetIntroduction_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var fernTestValueIntroduction *string

		// Act
		obj.SetIntroduction(fernTestValueIntroduction)

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

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

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

	t.Run("SetApiReferenceLink_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var fernTestValueApiReferenceLink *string

		// Act
		obj.SetApiReferenceLink(fernTestValueApiReferenceLink)

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

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

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

	t.Run("SetReferenceMarkdownPath_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var fernTestValueReferenceMarkdownPath *string

		// Act
		obj.SetReferenceMarkdownPath(fernTestValueReferenceMarkdownPath)

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

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

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

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

		// Act
		obj.SetRequirements(fernTestValueRequirements)

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

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

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

	t.Run("SetDisabledFeatures_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var fernTestValueDisabledFeatures []*FeatureId

		// Act
		obj.SetDisabledFeatures(fernTestValueDisabledFeatures)

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

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

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

	t.Run("SetWhiteLabel_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var fernTestValueWhiteLabel *bool

		// Act
		obj.SetWhiteLabel(fernTestValueWhiteLabel)

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

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

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

	t.Run("SetCustomSections_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var fernTestValueCustomSections []*CustomSection

		// Act
		obj.SetCustomSections(fernTestValueCustomSections)

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

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

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

	t.Run("SetFeatures_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var fernTestValueFeatures []*ReadmeFeature

		// Act
		obj.SetFeatures(fernTestValueFeatures)

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

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

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

	t.Run("SetExampleStyle_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeConfig{}
		var fernTestValueExampleStyle *ExampleStyle

		// Act
		obj.SetExampleStyle(fernTestValueExampleStyle)

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

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

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

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

	t.Run("SetAddendum", func(t *testing.T) {
		obj := &ReadmeFeature{}
		var fernTestValueAddendum *string
		obj.SetAddendum(fernTestValueAddendum)
		assert.Equal(t, fernTestValueAddendum, obj.Addendum)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetAdvanced", func(t *testing.T) {
		obj := &ReadmeFeature{}
		var fernTestValueAdvanced *bool
		obj.SetAdvanced(fernTestValueAdvanced)
		assert.Equal(t, fernTestValueAdvanced, obj.Advanced)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSnippets", func(t *testing.T) {
		obj := &ReadmeFeature{}
		var fernTestValueSnippets []*Snippet
		obj.SetSnippets(fernTestValueSnippets)
		assert.Equal(t, fernTestValueSnippets, obj.Snippets)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetSnippetsAreOptional", func(t *testing.T) {
		obj := &ReadmeFeature{}
		var fernTestValueSnippetsAreOptional bool
		obj.SetSnippetsAreOptional(fernTestValueSnippetsAreOptional)
		assert.Equal(t, fernTestValueSnippetsAreOptional, obj.SnippetsAreOptional)
		assert.NotNil(t, obj.explicitFields)
	})

}

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

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

	t.Run("GetId_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeFeature{}
		obj.Id = nil

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

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

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

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

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

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

	t.Run("GetAddendum", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeFeature{}
		var expected *string
		obj.Addendum = expected

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

	t.Run("GetAddendum_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeFeature{}
		obj.Addendum = nil

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

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

	t.Run("GetAdvanced", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeFeature{}
		var expected *bool
		obj.Advanced = expected

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

	t.Run("GetAdvanced_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeFeature{}
		obj.Advanced = nil

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

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

	t.Run("GetSnippets", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeFeature{}
		var expected []*Snippet
		obj.Snippets = expected

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

	t.Run("GetSnippets_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeFeature{}
		obj.Snippets = nil

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

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

	t.Run("GetSnippetsAreOptional", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeFeature{}
		var expected bool
		obj.SnippetsAreOptional = expected

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

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

}

func TestSettersMarkExplicitReadmeFeature(t *testing.T) {
	t.Run("SetId_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeFeature{}
		var fernTestValueId *FeatureId

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

		// Act
		obj.SetDescription(fernTestValueDescription)

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

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

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

	t.Run("SetAddendum_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeFeature{}
		var fernTestValueAddendum *string

		// Act
		obj.SetAddendum(fernTestValueAddendum)

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

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

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

	t.Run("SetAdvanced_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeFeature{}
		var fernTestValueAdvanced *bool

		// Act
		obj.SetAdvanced(fernTestValueAdvanced)

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

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

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

	t.Run("SetSnippets_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeFeature{}
		var fernTestValueSnippets []*Snippet

		// Act
		obj.SetSnippets(fernTestValueSnippets)

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

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

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

	t.Run("SetSnippetsAreOptional_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &ReadmeFeature{}
		var fernTestValueSnippetsAreOptional bool

		// Act
		obj.SetSnippetsAreOptional(fernTestValueSnippetsAreOptional)

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

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

		// Note: This 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 TestGettersRemote(t *testing.T) {
	t.Run("GetType", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Remote{}
		var expected string
		obj.Type = expected

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

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

	t.Run("GetGithub", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Remote{}
		var expected *GithubRemote
		obj.Github = expected

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

	t.Run("GetGithub_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Remote{}
		obj.Github = nil

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

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

}

func TestSettersRubyGemsPublishInfo(t *testing.T) {
	t.Run("SetPackageName", func(t *testing.T) {
		obj := &RubyGemsPublishInfo{}
		var fernTestValuePackageName string
		obj.SetPackageName(fernTestValuePackageName)
		assert.Equal(t, fernTestValuePackageName, obj.PackageName)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersRubyGemsPublishInfo(t *testing.T) {
	t.Run("GetPackageName", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RubyGemsPublishInfo{}
		var expected string
		obj.PackageName = expected

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

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

}

func TestSettersMarkExplicitRubyGemsPublishInfo(t *testing.T) {
	t.Run("SetPackageName_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RubyGemsPublishInfo{}
		var fernTestValuePackageName string

		// Act
		obj.SetPackageName(fernTestValuePackageName)

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

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

		// Note: This 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 TestSettersRubyInfo(t *testing.T) {
	t.Run("SetPublishInfo", func(t *testing.T) {
		obj := &RubyInfo{}
		var fernTestValuePublishInfo *RubyGemsPublishInfo
		obj.SetPublishInfo(fernTestValuePublishInfo)
		assert.Equal(t, fernTestValuePublishInfo, obj.PublishInfo)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersRubyInfo(t *testing.T) {
	t.Run("GetPublishInfo", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RubyInfo{}
		var expected *RubyGemsPublishInfo
		obj.PublishInfo = expected

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

	t.Run("GetPublishInfo_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RubyInfo{}
		obj.PublishInfo = nil

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

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

}

func TestSettersMarkExplicitRubyInfo(t *testing.T) {
	t.Run("SetPublishInfo_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RubyInfo{}
		var fernTestValuePublishInfo *RubyGemsPublishInfo

		// Act
		obj.SetPublishInfo(fernTestValuePublishInfo)

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

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

		// Note: This 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 TestSettersRustInfo(t *testing.T) {
	t.Run("SetPublishInfo", func(t *testing.T) {
		obj := &RustInfo{}
		var fernTestValuePublishInfo *CargoPublishInfo
		obj.SetPublishInfo(fernTestValuePublishInfo)
		assert.Equal(t, fernTestValuePublishInfo, obj.PublishInfo)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersRustInfo(t *testing.T) {
	t.Run("GetPublishInfo", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RustInfo{}
		var expected *CargoPublishInfo
		obj.PublishInfo = expected

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

	t.Run("GetPublishInfo_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RustInfo{}
		obj.PublishInfo = nil

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

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

}

func TestSettersMarkExplicitRustInfo(t *testing.T) {
	t.Run("SetPublishInfo_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &RustInfo{}
		var fernTestValuePublishInfo *CargoPublishInfo

		// Act
		obj.SetPublishInfo(fernTestValuePublishInfo)

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

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

		// Note: This 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 TestGettersSnippet(t *testing.T) {
	t.Run("GetString", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Snippet{}
		var expected string
		obj.String = expected

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

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

	t.Run("GetMarkdownSnippet", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Snippet{}
		var expected *MarkdownSnippet
		obj.MarkdownSnippet = expected

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

	t.Run("GetMarkdownSnippet_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Snippet{}
		obj.MarkdownSnippet = nil

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

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

	t.Run("GetCodeSnippet", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Snippet{}
		var expected *CodeSnippet
		obj.CodeSnippet = expected

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

	t.Run("GetCodeSnippet_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &Snippet{}
		obj.CodeSnippet = nil

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

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

}

func TestSettersSwiftInfo(t *testing.T) {
	t.Run("SetPublishInfo", func(t *testing.T) {
		obj := &SwiftInfo{}
		var fernTestValuePublishInfo *SwiftPackageManagerPublishInfo
		obj.SetPublishInfo(fernTestValuePublishInfo)
		assert.Equal(t, fernTestValuePublishInfo, obj.PublishInfo)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersSwiftInfo(t *testing.T) {
	t.Run("GetPublishInfo", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SwiftInfo{}
		var expected *SwiftPackageManagerPublishInfo
		obj.PublishInfo = expected

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

	t.Run("GetPublishInfo_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SwiftInfo{}
		obj.PublishInfo = nil

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

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

}

func TestSettersMarkExplicitSwiftInfo(t *testing.T) {
	t.Run("SetPublishInfo_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SwiftInfo{}
		var fernTestValuePublishInfo *SwiftPackageManagerPublishInfo

		// Act
		obj.SetPublishInfo(fernTestValuePublishInfo)

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

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

		// Note: This 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 TestSettersSwiftPackageManagerPublishInfo(t *testing.T) {
	t.Run("SetGitUrl", func(t *testing.T) {
		obj := &SwiftPackageManagerPublishInfo{}
		var fernTestValueGitUrl string
		obj.SetGitUrl(fernTestValueGitUrl)
		assert.Equal(t, fernTestValueGitUrl, obj.GitUrl)
		assert.NotNil(t, obj.explicitFields)
	})

	t.Run("SetMinVersion", func(t *testing.T) {
		obj := &SwiftPackageManagerPublishInfo{}
		var fernTestValueMinVersion string
		obj.SetMinVersion(fernTestValueMinVersion)
		assert.Equal(t, fernTestValueMinVersion, obj.MinVersion)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersSwiftPackageManagerPublishInfo(t *testing.T) {
	t.Run("GetGitUrl", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SwiftPackageManagerPublishInfo{}
		var expected string
		obj.GitUrl = expected

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

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

	t.Run("GetMinVersion", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SwiftPackageManagerPublishInfo{}
		var expected string
		obj.MinVersion = expected

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

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

}

func TestSettersMarkExplicitSwiftPackageManagerPublishInfo(t *testing.T) {
	t.Run("SetGitUrl_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SwiftPackageManagerPublishInfo{}
		var fernTestValueGitUrl string

		// Act
		obj.SetGitUrl(fernTestValueGitUrl)

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

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

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

	t.Run("SetMinVersion_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &SwiftPackageManagerPublishInfo{}
		var fernTestValueMinVersion string

		// Act
		obj.SetMinVersion(fernTestValueMinVersion)

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

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

		// Note: This 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 TestSettersTypescriptInfo(t *testing.T) {
	t.Run("SetPublishInfo", func(t *testing.T) {
		obj := &TypescriptInfo{}
		var fernTestValuePublishInfo *NpmPublishInfo
		obj.SetPublishInfo(fernTestValuePublishInfo)
		assert.Equal(t, fernTestValuePublishInfo, obj.PublishInfo)
		assert.NotNil(t, obj.explicitFields)
	})

}

func TestGettersTypescriptInfo(t *testing.T) {
	t.Run("GetPublishInfo", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TypescriptInfo{}
		var expected *NpmPublishInfo
		obj.PublishInfo = expected

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

	t.Run("GetPublishInfo_NilValue", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TypescriptInfo{}
		obj.PublishInfo = nil

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

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

}

func TestSettersMarkExplicitTypescriptInfo(t *testing.T) {
	t.Run("SetPublishInfo_MarksExplicit", func(t *testing.T) {
		t.Parallel()
		// Arrange
		obj := &TypescriptInfo{}
		var fernTestValuePublishInfo *NpmPublishInfo

		// Act
		obj.SetPublishInfo(fernTestValuePublishInfo)

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

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

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

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

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

		// 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 CodeSnippet
		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 CodeSnippet
		err := json.Unmarshal([]byte(`{invalid json}`), &obj)
		assert.Error(t, err, "unmarshaling invalid JSON should return an error")
	})

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		// 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 MarkdownSnippet
		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 MarkdownSnippet
		err := json.Unmarshal([]byte(`{invalid json}`), &obj)
		assert.Error(t, err, "unmarshaling invalid JSON should return an error")
	})

}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func TestEnumExampleStyle(t *testing.T) {
	t.Run("NewFromString_minimal", func(t *testing.T) {
		t.Parallel()
		val, err := NewExampleStyleFromString("minimal")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ExampleStyle("minimal"), val, "enum value should match expected wire value")
	})

	t.Run("NewFromString_comprehensive", func(t *testing.T) {
		t.Parallel()
		val, err := NewExampleStyleFromString("comprehensive")
		assert.NoError(t, err, "valid enum value should not return error")
		assert.Equal(t, ExampleStyle("comprehensive"), val, "enum value should match expected wire value")
	})

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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