models.go

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by the Google Gen AI SDK generator DO NOT EDIT.

package genai

import (
	"context"
	"fmt"
	"iter"
	"log"
	"net/http"
	"reflect"
	"sync"
)

func authConfigToMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromApiKey := InternalGetValueByPath(fromObject, []string{"apiKey"})
	if fromApiKey != nil {
		InternalSetValueByPath(toObject, []string{"apiKey"}, fromApiKey)
	}

	if InternalGetValueByPath(fromObject, []string{"apiKeyConfig"}) != nil {
		return nil, fmt.Errorf("apiKeyConfig parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"authType"}) != nil {
		return nil, fmt.Errorf("authType parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"googleServiceAccountConfig"}) != nil {
		return nil, fmt.Errorf("googleServiceAccountConfig parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"httpBasicAuthConfig"}) != nil {
		return nil, fmt.Errorf("httpBasicAuthConfig parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"oauthConfig"}) != nil {
		return nil, fmt.Errorf("oauthConfig parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"oidcConfig"}) != nil {
		return nil, fmt.Errorf("oidcConfig parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	return toObject, nil
}

func candidateFromMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromContent := InternalGetValueByPath(fromObject, []string{"content"})
	if fromContent != nil {
		InternalSetValueByPath(toObject, []string{"content"}, fromContent)
	}

	fromCitationMetadata := InternalGetValueByPath(fromObject, []string{"citationMetadata"})
	if fromCitationMetadata != nil {
		fromCitationMetadata, err = citationMetadataFromMldev(fromCitationMetadata.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"citationMetadata"}, fromCitationMetadata)
	}

	fromTokenCount := InternalGetValueByPath(fromObject, []string{"tokenCount"})
	if fromTokenCount != nil {
		InternalSetValueByPath(toObject, []string{"tokenCount"}, fromTokenCount)
	}

	fromFinishReason := InternalGetValueByPath(fromObject, []string{"finishReason"})
	if fromFinishReason != nil {
		InternalSetValueByPath(toObject, []string{"finishReason"}, fromFinishReason)
	}

	fromGroundingMetadata := InternalGetValueByPath(fromObject, []string{"groundingMetadata"})
	if fromGroundingMetadata != nil {
		InternalSetValueByPath(toObject, []string{"groundingMetadata"}, fromGroundingMetadata)
	}

	fromAvgLogprobs := InternalGetValueByPath(fromObject, []string{"avgLogprobs"})
	if fromAvgLogprobs != nil {
		InternalSetValueByPath(toObject, []string{"avgLogprobs"}, fromAvgLogprobs)
	}

	fromIndex := InternalGetValueByPath(fromObject, []string{"index"})
	if fromIndex != nil {
		InternalSetValueByPath(toObject, []string{"index"}, fromIndex)
	}

	fromLogprobsResult := InternalGetValueByPath(fromObject, []string{"logprobsResult"})
	if fromLogprobsResult != nil {
		InternalSetValueByPath(toObject, []string{"logprobsResult"}, fromLogprobsResult)
	}

	fromSafetyRatings := InternalGetValueByPath(fromObject, []string{"safetyRatings"})
	if fromSafetyRatings != nil {
		InternalSetValueByPath(toObject, []string{"safetyRatings"}, fromSafetyRatings)
	}

	fromUrlContextMetadata := InternalGetValueByPath(fromObject, []string{"urlContextMetadata"})
	if fromUrlContextMetadata != nil {
		InternalSetValueByPath(toObject, []string{"urlContextMetadata"}, fromUrlContextMetadata)
	}

	fromContinuationToken := InternalGetValueByPath(fromObject, []string{"continuationToken"})
	if fromContinuationToken != nil {
		InternalSetValueByPath(toObject, []string{"continuationToken"}, fromContinuationToken)
	}

	return toObject, nil
}

func citationMetadataFromMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromCitations := InternalGetValueByPath(fromObject, []string{"citationSources"})
	if fromCitations != nil {
		InternalSetValueByPath(toObject, []string{"citations"}, fromCitations)
	}

	return toObject, nil
}

func computeTokensParametersToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "model"}, fromModel)
	}

	fromContents := InternalGetValueByPath(fromObject, []string{"contents"})
	if fromContents != nil {
		fromContents, err = InternalTContents(fromContents)
		if err != nil {
			return nil, err
		}

		fromContents, err = InternalApplyConverterToSliceWithRoot(fromContents.([]any), contentToVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"contents"}, fromContents)
	}

	return toObject, nil
}

func computeTokensResponseFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSdkHttpResponse := InternalGetValueByPath(fromObject, []string{"sdkHttpResponse"})
	if fromSdkHttpResponse != nil {
		InternalSetValueByPath(toObject, []string{"sdkHttpResponse"}, fromSdkHttpResponse)
	}

	fromTokensInfo := InternalGetValueByPath(fromObject, []string{"tokensInfo"})
	if fromTokensInfo != nil {
		InternalSetValueByPath(toObject, []string{"tokensInfo"}, fromTokensInfo)
	}

	return toObject, nil
}

func contentEmbeddingFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromValues := InternalGetValueByPath(fromObject, []string{"values"})
	if fromValues != nil {
		InternalSetValueByPath(toObject, []string{"values"}, fromValues)
	}

	fromStatistics := InternalGetValueByPath(fromObject, []string{"statistics"})
	if fromStatistics != nil {
		fromStatistics, err = contentEmbeddingStatisticsFromVertex(fromStatistics.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"statistics"}, fromStatistics)
	}

	return toObject, nil
}

func contentEmbeddingStatisticsFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromTruncated := InternalGetValueByPath(fromObject, []string{"truncated"})
	if fromTruncated != nil {
		InternalSetValueByPath(toObject, []string{"truncated"}, fromTruncated)
	}

	fromTokenCount := InternalGetValueByPath(fromObject, []string{"token_count"})
	if fromTokenCount != nil {
		InternalSetValueByPath(toObject, []string{"tokenCount"}, fromTokenCount)
	}

	fromTokensDetails := InternalGetValueByPath(fromObject, []string{"tokensDetails"})
	if fromTokensDetails != nil {
		InternalSetValueByPath(toObject, []string{"tokensDetails"}, fromTokensDetails)
	}

	return toObject, nil
}

func contentToMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromParts := InternalGetValueByPath(fromObject, []string{"parts"})
	if fromParts != nil {
		fromParts, err = InternalApplyConverterToSliceWithRoot(fromParts.([]any), partToMldev, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"parts"}, fromParts)
	}

	fromRole := InternalGetValueByPath(fromObject, []string{"role"})
	if fromRole != nil {
		InternalSetValueByPath(toObject, []string{"role"}, fromRole)
	}

	return toObject, nil
}

func contentToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromParts := InternalGetValueByPath(fromObject, []string{"parts"})
	if fromParts != nil {
		fromParts, err = InternalApplyConverterToSliceWithRoot(fromParts.([]any), partToVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"parts"}, fromParts)
	}

	fromRole := InternalGetValueByPath(fromObject, []string{"role"})
	if fromRole != nil {
		InternalSetValueByPath(toObject, []string{"role"}, fromRole)
	}

	return toObject, nil
}

func controlReferenceConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromControlType := InternalGetValueByPath(fromObject, []string{"controlType"})
	if fromControlType != nil {
		InternalSetValueByPath(toObject, []string{"controlType"}, fromControlType)
	}

	fromEnableControlImageComputation := InternalGetValueByPath(fromObject, []string{"enableControlImageComputation"})
	if fromEnableControlImageComputation != nil {
		InternalSetValueByPath(toObject, []string{"computeControl"}, fromEnableControlImageComputation)
	}

	return toObject, nil
}

func countTokensConfigToMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	if InternalGetValueByPath(fromObject, []string{"systemInstruction"}) != nil {
		return nil, fmt.Errorf("systemInstruction parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"tools"}) != nil {
		return nil, fmt.Errorf("tools parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"generationConfig"}) != nil {
		return nil, fmt.Errorf("generationConfig parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	return toObject, nil
}

func countTokensConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSystemInstruction := InternalGetValueByPath(fromObject, []string{"systemInstruction"})
	if fromSystemInstruction != nil {
		fromSystemInstruction, err = InternalTContent(fromSystemInstruction)
		if err != nil {
			return nil, err
		}

		fromSystemInstruction, err = contentToVertex(fromSystemInstruction.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"systemInstruction"}, fromSystemInstruction)
	}

	fromTools := InternalGetValueByPath(fromObject, []string{"tools"})
	if fromTools != nil {
		fromTools, err = InternalApplyConverterToSliceWithRoot(fromTools.([]any), toolToVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"tools"}, fromTools)
	}

	fromGenerationConfig := InternalGetValueByPath(fromObject, []string{"generationConfig"})
	if fromGenerationConfig != nil {
		fromGenerationConfig, err = generationConfigToVertex(fromGenerationConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"generationConfig"}, fromGenerationConfig)
	}

	return toObject, nil
}

func countTokensParametersToMldev(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "model"}, fromModel)
	}

	fromContents := InternalGetValueByPath(fromObject, []string{"contents"})
	if fromContents != nil {
		fromContents, err = InternalTContents(fromContents)
		if err != nil {
			return nil, err
		}

		fromContents, err = InternalApplyConverterToSliceWithRoot(fromContents.([]any), contentToMldev, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"contents"}, fromContents)
	}

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		_, err = countTokensConfigToMldev(fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	return toObject, nil
}

func countTokensParametersToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "model"}, fromModel)
	}

	fromContents := InternalGetValueByPath(fromObject, []string{"contents"})
	if fromContents != nil {
		fromContents, err = InternalTContents(fromContents)
		if err != nil {
			return nil, err
		}

		fromContents, err = InternalApplyConverterToSliceWithRoot(fromContents.([]any), contentToVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"contents"}, fromContents)
	}

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		_, err = countTokensConfigToVertex(fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	return toObject, nil
}

func countTokensResponseFromMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSdkHttpResponse := InternalGetValueByPath(fromObject, []string{"sdkHttpResponse"})
	if fromSdkHttpResponse != nil {
		InternalSetValueByPath(toObject, []string{"sdkHttpResponse"}, fromSdkHttpResponse)
	}

	fromTotalTokens := InternalGetValueByPath(fromObject, []string{"totalTokens"})
	if fromTotalTokens != nil {
		InternalSetValueByPath(toObject, []string{"totalTokens"}, fromTotalTokens)
	}

	fromCachedContentTokenCount := InternalGetValueByPath(fromObject, []string{"cachedContentTokenCount"})
	if fromCachedContentTokenCount != nil {
		InternalSetValueByPath(toObject, []string{"cachedContentTokenCount"}, fromCachedContentTokenCount)
	}

	return toObject, nil
}

func countTokensResponseFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSdkHttpResponse := InternalGetValueByPath(fromObject, []string{"sdkHttpResponse"})
	if fromSdkHttpResponse != nil {
		InternalSetValueByPath(toObject, []string{"sdkHttpResponse"}, fromSdkHttpResponse)
	}

	fromTotalTokens := InternalGetValueByPath(fromObject, []string{"totalTokens"})
	if fromTotalTokens != nil {
		InternalSetValueByPath(toObject, []string{"totalTokens"}, fromTotalTokens)
	}

	return toObject, nil
}

func deleteModelParametersToMldev(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "name"}, fromModel)
	}

	return toObject, nil
}

func deleteModelParametersToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "name"}, fromModel)
	}

	return toObject, nil
}

func deleteModelResponseFromMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSdkHttpResponse := InternalGetValueByPath(fromObject, []string{"sdkHttpResponse"})
	if fromSdkHttpResponse != nil {
		InternalSetValueByPath(toObject, []string{"sdkHttpResponse"}, fromSdkHttpResponse)
	}

	return toObject, nil
}

func deleteModelResponseFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSdkHttpResponse := InternalGetValueByPath(fromObject, []string{"sdkHttpResponse"})
	if fromSdkHttpResponse != nil {
		InternalSetValueByPath(toObject, []string{"sdkHttpResponse"}, fromSdkHttpResponse)
	}

	return toObject, nil
}

func editImageConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromOutputGcsUri := InternalGetValueByPath(fromObject, []string{"outputGcsUri"})
	if fromOutputGcsUri != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "storageUri"}, fromOutputGcsUri)
	}

	fromNegativePrompt := InternalGetValueByPath(fromObject, []string{"negativePrompt"})
	if fromNegativePrompt != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "negativePrompt"}, fromNegativePrompt)
	}

	fromNumberOfImages := InternalGetValueByPath(fromObject, []string{"numberOfImages"})
	if fromNumberOfImages != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "sampleCount"}, fromNumberOfImages)
	}

	fromAspectRatio := InternalGetValueByPath(fromObject, []string{"aspectRatio"})
	if fromAspectRatio != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "aspectRatio"}, fromAspectRatio)
	}

	fromGuidanceScale := InternalGetValueByPath(fromObject, []string{"guidanceScale"})
	if fromGuidanceScale != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "guidanceScale"}, fromGuidanceScale)
	}

	fromSeed := InternalGetValueByPath(fromObject, []string{"seed"})
	if fromSeed != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "seed"}, fromSeed)
	}

	fromSafetyFilterLevel := InternalGetValueByPath(fromObject, []string{"safetyFilterLevel"})
	if fromSafetyFilterLevel != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "safetySetting"}, fromSafetyFilterLevel)
	}

	fromPersonGeneration := InternalGetValueByPath(fromObject, []string{"personGeneration"})
	if fromPersonGeneration != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "personGeneration"}, fromPersonGeneration)
	}

	fromIncludeSafetyAttributes := InternalGetValueByPath(fromObject, []string{"includeSafetyAttributes"})
	if fromIncludeSafetyAttributes != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "includeSafetyAttributes"}, fromIncludeSafetyAttributes)
	}

	fromIncludeRaiReason := InternalGetValueByPath(fromObject, []string{"includeRaiReason"})
	if fromIncludeRaiReason != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "includeRaiReason"}, fromIncludeRaiReason)
	}

	fromLanguage := InternalGetValueByPath(fromObject, []string{"language"})
	if fromLanguage != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "language"}, fromLanguage)
	}

	fromOutputMimeType := InternalGetValueByPath(fromObject, []string{"outputMimeType"})
	if fromOutputMimeType != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "outputOptions", "mimeType"}, fromOutputMimeType)
	}

	fromOutputCompressionQuality := InternalGetValueByPath(fromObject, []string{"outputCompressionQuality"})
	if fromOutputCompressionQuality != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "outputOptions", "compressionQuality"}, fromOutputCompressionQuality)
	}

	fromAddWatermark := InternalGetValueByPath(fromObject, []string{"addWatermark"})
	if fromAddWatermark != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "addWatermark"}, fromAddWatermark)
	}

	fromLabels := InternalGetValueByPath(fromObject, []string{"labels"})
	if fromLabels != nil {
		InternalSetValueByPath(parentObject, []string{"labels"}, fromLabels)
	}

	fromEditMode := InternalGetValueByPath(fromObject, []string{"editMode"})
	if fromEditMode != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "editMode"}, fromEditMode)
	}

	fromBaseSteps := InternalGetValueByPath(fromObject, []string{"baseSteps"})
	if fromBaseSteps != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "editConfig", "baseSteps"}, fromBaseSteps)
	}

	return toObject, nil
}

func editImageParametersToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "model"}, fromModel)
	}

	fromPrompt := InternalGetValueByPath(fromObject, []string{"prompt"})
	if fromPrompt != nil {
		InternalSetValueByPath(toObject, []string{"instances[0]", "prompt"}, fromPrompt)
	}

	fromReferenceImages := InternalGetValueByPath(fromObject, []string{"referenceImages"})
	if fromReferenceImages != nil {
		fromReferenceImages, err = InternalApplyConverterToSliceWithRoot(fromReferenceImages.([]any), referenceImageAPIToVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"instances[0]", "referenceImages"}, fromReferenceImages)
	}

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		_, err = editImageConfigToVertex(fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	return toObject, nil
}

func editImageResponseFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSdkHttpResponse := InternalGetValueByPath(fromObject, []string{"sdkHttpResponse"})
	if fromSdkHttpResponse != nil {
		InternalSetValueByPath(toObject, []string{"sdkHttpResponse"}, fromSdkHttpResponse)
	}

	fromGeneratedImages := InternalGetValueByPath(fromObject, []string{"predictions"})
	if fromGeneratedImages != nil {
		fromGeneratedImages, err = InternalApplyConverterToSliceWithRoot(fromGeneratedImages.([]any), generatedImageFromVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"generatedImages"}, fromGeneratedImages)
	}

	return toObject, nil
}

func embedContentConfigToMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromTaskType := InternalGetValueByPath(fromObject, []string{"taskType"})
	if fromTaskType != nil {
		InternalSetValueByPath(parentObject, []string{"requests[]", "taskType"}, fromTaskType)
	}

	fromTitle := InternalGetValueByPath(fromObject, []string{"title"})
	if fromTitle != nil {
		InternalSetValueByPath(parentObject, []string{"requests[]", "title"}, fromTitle)
	}

	fromOutputDimensionality := InternalGetValueByPath(fromObject, []string{"outputDimensionality"})
	if fromOutputDimensionality != nil {
		InternalSetValueByPath(parentObject, []string{"requests[]", "outputDimensionality"}, fromOutputDimensionality)
	}

	if InternalGetValueByPath(fromObject, []string{"mimeType"}) != nil {
		return nil, fmt.Errorf("mimeType parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"autoTruncate"}) != nil {
		return nil, fmt.Errorf("autoTruncate parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"documentOcr"}) != nil {
		return nil, fmt.Errorf("documentOcr parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"audioTrackExtraction"}) != nil {
		return nil, fmt.Errorf("audioTrackExtraction parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	return toObject, nil
}

func embedContentConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	var discriminatorTaskType any = InternalGetValueByPath(rootObject, []string{"embeddingApiType"})
	if discriminatorTaskType == nil {
		discriminatorTaskType = "PREDICT"
	}
	if discriminatorTaskType.(string) == "PREDICT" {
		fromTaskType := InternalGetValueByPath(fromObject, []string{"taskType"})
		if fromTaskType != nil {
			InternalSetValueByPath(parentObject, []string{"instances[]", "task_type"}, fromTaskType)
		}
	} else if discriminatorTaskType.(string) == "EMBED_CONTENT" {
		fromTaskType := InternalGetValueByPath(fromObject, []string{"taskType"})
		if fromTaskType != nil {
			InternalSetValueByPath(parentObject, []string{"embedContentConfig", "taskType"}, fromTaskType)
		}
	}

	var discriminatorTitle any = InternalGetValueByPath(rootObject, []string{"embeddingApiType"})
	if discriminatorTitle == nil {
		discriminatorTitle = "PREDICT"
	}
	if discriminatorTitle.(string) == "PREDICT" {
		fromTitle := InternalGetValueByPath(fromObject, []string{"title"})
		if fromTitle != nil {
			InternalSetValueByPath(parentObject, []string{"instances[]", "title"}, fromTitle)
		}
	} else if discriminatorTitle.(string) == "EMBED_CONTENT" {
		fromTitle := InternalGetValueByPath(fromObject, []string{"title"})
		if fromTitle != nil {
			InternalSetValueByPath(parentObject, []string{"embedContentConfig", "title"}, fromTitle)
		}
	}

	var discriminatorOutputDimensionality any = InternalGetValueByPath(rootObject, []string{"embeddingApiType"})
	if discriminatorOutputDimensionality == nil {
		discriminatorOutputDimensionality = "PREDICT"
	}
	if discriminatorOutputDimensionality.(string) == "PREDICT" {
		fromOutputDimensionality := InternalGetValueByPath(fromObject, []string{"outputDimensionality"})
		if fromOutputDimensionality != nil {
			InternalSetValueByPath(parentObject, []string{"parameters", "outputDimensionality"}, fromOutputDimensionality)
		}
	} else if discriminatorOutputDimensionality.(string) == "EMBED_CONTENT" {
		fromOutputDimensionality := InternalGetValueByPath(fromObject, []string{"outputDimensionality"})
		if fromOutputDimensionality != nil {
			InternalSetValueByPath(parentObject, []string{"embedContentConfig", "outputDimensionality"}, fromOutputDimensionality)
		}
	}

	var discriminatorMimeType any = InternalGetValueByPath(rootObject, []string{"embeddingApiType"})
	if discriminatorMimeType == nil {
		discriminatorMimeType = "PREDICT"
	}
	if discriminatorMimeType.(string) == "PREDICT" {
		fromMimeType := InternalGetValueByPath(fromObject, []string{"mimeType"})
		if fromMimeType != nil {
			InternalSetValueByPath(parentObject, []string{"instances[]", "mimeType"}, fromMimeType)
		}
	}

	var discriminatorAutoTruncate any = InternalGetValueByPath(rootObject, []string{"embeddingApiType"})
	if discriminatorAutoTruncate == nil {
		discriminatorAutoTruncate = "PREDICT"
	}
	if discriminatorAutoTruncate.(string) == "PREDICT" {
		fromAutoTruncate := InternalGetValueByPath(fromObject, []string{"autoTruncate"})
		if fromAutoTruncate != nil {
			InternalSetValueByPath(parentObject, []string{"parameters", "autoTruncate"}, fromAutoTruncate)
		}
	} else if discriminatorAutoTruncate.(string) == "EMBED_CONTENT" {
		fromAutoTruncate := InternalGetValueByPath(fromObject, []string{"autoTruncate"})
		if fromAutoTruncate != nil {
			InternalSetValueByPath(parentObject, []string{"embedContentConfig", "autoTruncate"}, fromAutoTruncate)
		}
	}

	var discriminatorDocumentOcr any = InternalGetValueByPath(rootObject, []string{"embeddingApiType"})
	if discriminatorDocumentOcr == nil {
		discriminatorDocumentOcr = "PREDICT"
	}
	if discriminatorDocumentOcr.(string) == "EMBED_CONTENT" {
		fromDocumentOcr := InternalGetValueByPath(fromObject, []string{"documentOcr"})
		if fromDocumentOcr != nil {
			InternalSetValueByPath(parentObject, []string{"embedContentConfig", "documentOcr"}, fromDocumentOcr)
		}
	}

	var discriminatorAudioTrackExtraction any = InternalGetValueByPath(rootObject, []string{"embeddingApiType"})
	if discriminatorAudioTrackExtraction == nil {
		discriminatorAudioTrackExtraction = "PREDICT"
	}
	if discriminatorAudioTrackExtraction.(string) == "EMBED_CONTENT" {
		fromAudioTrackExtraction := InternalGetValueByPath(fromObject, []string{"audioTrackExtraction"})
		if fromAudioTrackExtraction != nil {
			InternalSetValueByPath(parentObject, []string{"embedContentConfig", "audioTrackExtraction"}, fromAudioTrackExtraction)
		}
	}

	return toObject, nil
}

func embedContentParametersPrivateToMldev(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "model"}, fromModel)
	}

	fromContents := InternalGetValueByPath(fromObject, []string{"contents"})
	if fromContents != nil {
		fromContents, err = InternalTContentsForEmbed(ac, fromContents)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"requests[]", "content"}, fromContents)
	}

	fromContent := InternalGetValueByPath(fromObject, []string{"content"})
	if fromContent != nil {
		_, err = InternalTContent(fromContent)
		if err != nil {
			return nil, err
		}

		_, err = contentToMldev(fromContent.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		_, err = embedContentConfigToMldev(fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	setValueByPath(toObject, []string{"requests[]", "model"}, fromModel)

	return toObject, nil
}

func embedContentParametersPrivateToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "model"}, fromModel)
	}

	var discriminatorContents any = InternalGetValueByPath(rootObject, []string{"embeddingApiType"})
	if discriminatorContents == nil {
		discriminatorContents = "PREDICT"
	}
	if discriminatorContents.(string) == "PREDICT" {
		fromContents := InternalGetValueByPath(fromObject, []string{"contents"})
		if fromContents != nil {
			fromContents, err = InternalTContentsForEmbed(ac, fromContents)
			if err != nil {
				return nil, err
			}

			InternalSetValueByPath(toObject, []string{"instances[]", "content"}, fromContents)
		}
	}

	var discriminatorContent any = InternalGetValueByPath(rootObject, []string{"embeddingApiType"})
	if discriminatorContent == nil {
		discriminatorContent = "PREDICT"
	}
	if discriminatorContent.(string) == "EMBED_CONTENT" {
		fromContent := InternalGetValueByPath(fromObject, []string{"content"})
		if fromContent != nil {
			fromContent, err = InternalTContent(fromContent)
			if err != nil {
				return nil, err
			}

			fromContent, err = contentToVertex(fromContent.(map[string]any), toObject, rootObject)
			if err != nil {
				return nil, err
			}

			InternalSetValueByPath(toObject, []string{"content"}, fromContent)
		}
	}

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		_, err = embedContentConfigToVertex(fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	return toObject, nil
}

func embedContentResponseFromMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSdkHttpResponse := InternalGetValueByPath(fromObject, []string{"sdkHttpResponse"})
	if fromSdkHttpResponse != nil {
		InternalSetValueByPath(toObject, []string{"sdkHttpResponse"}, fromSdkHttpResponse)
	}

	fromEmbeddings := InternalGetValueByPath(fromObject, []string{"embeddings"})
	if fromEmbeddings != nil {
		InternalSetValueByPath(toObject, []string{"embeddings"}, fromEmbeddings)
	}

	fromMetadata := InternalGetValueByPath(fromObject, []string{"metadata"})
	if fromMetadata != nil {
		InternalSetValueByPath(toObject, []string{"metadata"}, fromMetadata)
	}

	fromUsageMetadata := InternalGetValueByPath(fromObject, []string{"usageMetadata"})
	if fromUsageMetadata != nil {
		InternalSetValueByPath(toObject, []string{"usageMetadata"}, fromUsageMetadata)
	}

	return toObject, nil
}

func embedContentResponseFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSdkHttpResponse := InternalGetValueByPath(fromObject, []string{"sdkHttpResponse"})
	if fromSdkHttpResponse != nil {
		InternalSetValueByPath(toObject, []string{"sdkHttpResponse"}, fromSdkHttpResponse)
	}

	fromEmbeddings := InternalGetValueByPath(fromObject, []string{"predictions[]", "embeddings"})
	if fromEmbeddings != nil {
		fromEmbeddings, err = InternalApplyConverterToSliceWithRoot(fromEmbeddings.([]any), contentEmbeddingFromVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"embeddings"}, fromEmbeddings)
	}

	fromMetadata := InternalGetValueByPath(fromObject, []string{"metadata"})
	if fromMetadata != nil {
		InternalSetValueByPath(toObject, []string{"metadata"}, fromMetadata)
	}

	fromTruncated := InternalGetValueByPath(fromObject, []string{"truncated"})
	if fromTruncated != nil {
		InternalSetValueByPath(toObject, []string{"truncated"}, fromTruncated)
	}

	fromUsageMetadata := InternalGetValueByPath(fromObject, []string{"usageMetadata"})
	if fromUsageMetadata != nil {
		fromUsageMetadata, err = usageMetadataFromVertex(fromUsageMetadata.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"usageMetadata"}, fromUsageMetadata)
	}

	if rootObject != nil && getValueByPath(rootObject, []string{"embeddingApiType"}) != nil && getValueByPath(rootObject, []string{"embeddingApiType"}).(string) == "EMBED_CONTENT" {
		embedding := getValueByPath(fromObject, []string{"embedding"})
		usageMetadata := getValueByPath(fromObject, []string{"usageMetadata"})
		truncated := getValueByPath(fromObject, []string{"truncated"})
		if embedding != nil {
			stats := make(map[string]any)
			if um, ok := usageMetadata.(map[string]any); ok {
				if ptc, ok := um["promptTokenCount"]; ok && ptc != nil {
					stats["tokenCount"] = ptc
					stats["token_count"] = ptc
				}
				if ptd, ok := um["promptTokensDetails"]; ok && ptd != nil {
					stats["tokensDetails"] = ptd
				}
			}
			if truncated != nil {
				stats["truncated"] = truncated
			}
			embedding.(map[string]any)["statistics"] = stats
			setValueByPath(toObject, []string{"embeddings"}, []any{embedding})
		}
	}

	return toObject, nil
}

func endpointFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromName := InternalGetValueByPath(fromObject, []string{"endpoint"})
	if fromName != nil {
		InternalSetValueByPath(toObject, []string{"name"}, fromName)
	}

	fromDeployedModelId := InternalGetValueByPath(fromObject, []string{"deployedModelId"})
	if fromDeployedModelId != nil {
		InternalSetValueByPath(toObject, []string{"deployedModelId"}, fromDeployedModelId)
	}

	return toObject, nil
}

func functionCallToMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromId := InternalGetValueByPath(fromObject, []string{"id"})
	if fromId != nil {
		InternalSetValueByPath(toObject, []string{"id"}, fromId)
	}

	fromArgs := InternalGetValueByPath(fromObject, []string{"args"})
	if fromArgs != nil {
		InternalSetValueByPath(toObject, []string{"args"}, fromArgs)
	}

	fromName := InternalGetValueByPath(fromObject, []string{"name"})
	if fromName != nil {
		InternalSetValueByPath(toObject, []string{"name"}, fromName)
	}

	if InternalGetValueByPath(fromObject, []string{"partialArgs"}) != nil {
		return nil, fmt.Errorf("partialArgs parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"willContinue"}) != nil {
		return nil, fmt.Errorf("willContinue parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	return toObject, nil
}

func functionCallingConfigToMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromAllowedFunctionNames := InternalGetValueByPath(fromObject, []string{"allowedFunctionNames"})
	if fromAllowedFunctionNames != nil {
		InternalSetValueByPath(toObject, []string{"allowedFunctionNames"}, fromAllowedFunctionNames)
	}

	fromMode := InternalGetValueByPath(fromObject, []string{"mode"})
	if fromMode != nil {
		InternalSetValueByPath(toObject, []string{"mode"}, fromMode)
	}

	if InternalGetValueByPath(fromObject, []string{"streamFunctionCallArguments"}) != nil {
		return nil, fmt.Errorf("streamFunctionCallArguments parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	return toObject, nil
}

func functionResponsePartToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromInlineData := InternalGetValueByPath(fromObject, []string{"inlineData"})
	if fromInlineData != nil {
		InternalSetValueByPath(toObject, []string{"inlineData"}, fromInlineData)
	}

	fromFileData := InternalGetValueByPath(fromObject, []string{"fileData"})
	if fromFileData != nil {
		InternalSetValueByPath(toObject, []string{"fileData"}, fromFileData)
	}

	if InternalGetValueByPath(fromObject, []string{"mediaProcessing"}) != nil {
		return nil, fmt.Errorf("mediaProcessing parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	return toObject, nil
}

func functionResponseToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)
	if InternalGetValueByPath(fromObject, []string{"willContinue"}) != nil {
		return nil, fmt.Errorf("willContinue parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	fromScheduling := InternalGetValueByPath(fromObject, []string{"scheduling"})
	if fromScheduling != nil {
		InternalSetValueByPath(toObject, []string{"scheduling"}, fromScheduling)
	}

	fromParts := InternalGetValueByPath(fromObject, []string{"parts"})
	if fromParts != nil {
		fromParts, err = InternalApplyConverterToSliceWithRoot(fromParts.([]any), functionResponsePartToVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"parts"}, fromParts)
	}

	fromId := InternalGetValueByPath(fromObject, []string{"id"})
	if fromId != nil {
		InternalSetValueByPath(toObject, []string{"id"}, fromId)
	}

	fromName := InternalGetValueByPath(fromObject, []string{"name"})
	if fromName != nil {
		InternalSetValueByPath(toObject, []string{"name"}, fromName)
	}

	fromResponse := InternalGetValueByPath(fromObject, []string{"response"})
	if fromResponse != nil {
		InternalSetValueByPath(toObject, []string{"response"}, fromResponse)
	}

	return toObject, nil
}

func generateContentConfigToMldev(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSystemInstruction := InternalGetValueByPath(fromObject, []string{"systemInstruction"})
	if fromSystemInstruction != nil {
		fromSystemInstruction, err = InternalTContent(fromSystemInstruction)
		if err != nil {
			return nil, err
		}

		fromSystemInstruction, err = contentToMldev(fromSystemInstruction.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"systemInstruction"}, fromSystemInstruction)
	}

	fromTemperature := InternalGetValueByPath(fromObject, []string{"temperature"})
	if fromTemperature != nil {
		InternalSetValueByPath(toObject, []string{"temperature"}, fromTemperature)
	}

	fromTopP := InternalGetValueByPath(fromObject, []string{"topP"})
	if fromTopP != nil {
		InternalSetValueByPath(toObject, []string{"topP"}, fromTopP)
	}

	fromTopK := InternalGetValueByPath(fromObject, []string{"topK"})
	if fromTopK != nil {
		InternalSetValueByPath(toObject, []string{"topK"}, fromTopK)
	}

	fromCandidateCount := InternalGetValueByPath(fromObject, []string{"candidateCount"})
	if fromCandidateCount != nil {
		InternalSetValueByPath(toObject, []string{"candidateCount"}, fromCandidateCount)
	}

	fromMaxOutputTokens := InternalGetValueByPath(fromObject, []string{"maxOutputTokens"})
	if fromMaxOutputTokens != nil {
		InternalSetValueByPath(toObject, []string{"maxOutputTokens"}, fromMaxOutputTokens)
	}

	fromStopSequences := InternalGetValueByPath(fromObject, []string{"stopSequences"})
	if fromStopSequences != nil {
		InternalSetValueByPath(toObject, []string{"stopSequences"}, fromStopSequences)
	}

	fromResponseLogprobs := InternalGetValueByPath(fromObject, []string{"responseLogprobs"})
	if fromResponseLogprobs != nil {
		InternalSetValueByPath(toObject, []string{"responseLogprobs"}, fromResponseLogprobs)
	}

	fromLogprobs := InternalGetValueByPath(fromObject, []string{"logprobs"})
	if fromLogprobs != nil {
		InternalSetValueByPath(toObject, []string{"logprobs"}, fromLogprobs)
	}

	fromPresencePenalty := InternalGetValueByPath(fromObject, []string{"presencePenalty"})
	if fromPresencePenalty != nil {
		InternalSetValueByPath(toObject, []string{"presencePenalty"}, fromPresencePenalty)
	}

	fromFrequencyPenalty := InternalGetValueByPath(fromObject, []string{"frequencyPenalty"})
	if fromFrequencyPenalty != nil {
		InternalSetValueByPath(toObject, []string{"frequencyPenalty"}, fromFrequencyPenalty)
	}

	fromSeed := InternalGetValueByPath(fromObject, []string{"seed"})
	if fromSeed != nil {
		InternalSetValueByPath(toObject, []string{"seed"}, fromSeed)
	}

	fromResponseMimeType := InternalGetValueByPath(fromObject, []string{"responseMimeType"})
	if fromResponseMimeType != nil {
		InternalSetValueByPath(toObject, []string{"responseMimeType"}, fromResponseMimeType)
	}

	fromResponseSchema := InternalGetValueByPath(fromObject, []string{"responseSchema"})
	if fromResponseSchema != nil {
		fromResponseSchema, err = InternalTSchema(fromResponseSchema)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"responseSchema"}, fromResponseSchema)
	}

	fromResponseJsonSchema := InternalGetValueByPath(fromObject, []string{"responseJsonSchema"})
	if fromResponseJsonSchema != nil {
		fromResponseJsonSchema, err = InternalTJsonSchema(fromResponseJsonSchema)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"responseJsonSchema"}, fromResponseJsonSchema)
	}

	if InternalGetValueByPath(fromObject, []string{"routingConfig"}) != nil {
		return nil, fmt.Errorf("routingConfig parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"modelSelectionConfig"}) != nil {
		return nil, fmt.Errorf("modelSelectionConfig parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	fromSafetySettings := InternalGetValueByPath(fromObject, []string{"safetySettings"})
	if fromSafetySettings != nil {
		fromSafetySettings, err = InternalApplyConverterToSliceWithRoot(fromSafetySettings.([]any), safetySettingToMldev, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"safetySettings"}, fromSafetySettings)
	}

	fromTools := InternalGetValueByPath(fromObject, []string{"tools"})
	if fromTools != nil {
		fromTools, err = applyItemTransformerToSlice(fromTools.([]any), tTool)
		if err != nil {
			return nil, err
		}

		fromTools, err = InternalTTools(fromTools)
		if err != nil {
			return nil, err
		}

		fromTools, err = InternalApplyConverterToSliceWithRoot(fromTools.([]any), toolToMldev, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"tools"}, fromTools)
	}

	fromToolConfig := InternalGetValueByPath(fromObject, []string{"toolConfig"})
	if fromToolConfig != nil {
		fromToolConfig, err = toolConfigToMldev(fromToolConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"toolConfig"}, fromToolConfig)
	}

	fromLabels := InternalGetValueByPath(fromObject, []string{"labels"})
	if fromLabels != nil {
		InternalSetValueByPath(parentObject, []string{"labels"}, fromLabels)
	}

	fromCachedContent := InternalGetValueByPath(fromObject, []string{"cachedContent"})
	if fromCachedContent != nil {
		fromCachedContent, err = InternalTCachedContentName(ac, fromCachedContent)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"cachedContent"}, fromCachedContent)
	}

	fromResponseModalities := InternalGetValueByPath(fromObject, []string{"responseModalities"})
	if fromResponseModalities != nil {
		InternalSetValueByPath(toObject, []string{"responseModalities"}, fromResponseModalities)
	}

	fromMediaResolution := InternalGetValueByPath(fromObject, []string{"mediaResolution"})
	if fromMediaResolution != nil {
		InternalSetValueByPath(toObject, []string{"mediaResolution"}, fromMediaResolution)
	}

	fromSpeechConfig := InternalGetValueByPath(fromObject, []string{"speechConfig"})
	if fromSpeechConfig != nil {
		fromSpeechConfig, err = InternalTSpeechConfig(fromSpeechConfig)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"speechConfig"}, fromSpeechConfig)
	}

	if InternalGetValueByPath(fromObject, []string{"audioTimestamp"}) != nil {
		return nil, fmt.Errorf("audioTimestamp parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	fromThinkingConfig := InternalGetValueByPath(fromObject, []string{"thinkingConfig"})
	if fromThinkingConfig != nil {
		InternalSetValueByPath(toObject, []string{"thinkingConfig"}, fromThinkingConfig)
	}

	fromImageConfig := InternalGetValueByPath(fromObject, []string{"imageConfig"})
	if fromImageConfig != nil {
		fromImageConfig, err = imageConfigToMldev(fromImageConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"imageConfig"}, fromImageConfig)
	}

	fromEnableEnhancedCivicAnswers := InternalGetValueByPath(fromObject, []string{"enableEnhancedCivicAnswers"})
	if fromEnableEnhancedCivicAnswers != nil {
		InternalSetValueByPath(toObject, []string{"enableEnhancedCivicAnswers"}, fromEnableEnhancedCivicAnswers)
	}

	if InternalGetValueByPath(fromObject, []string{"modelArmorConfig"}) != nil {
		return nil, fmt.Errorf("modelArmorConfig parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	fromServiceTier := InternalGetValueByPath(fromObject, []string{"serviceTier"})
	if fromServiceTier != nil {
		InternalSetValueByPath(parentObject, []string{"serviceTier"}, fromServiceTier)
	}

	fromAudioTranscriptionConfig := InternalGetValueByPath(fromObject, []string{"audioTranscriptionConfig"})
	if fromAudioTranscriptionConfig != nil {
		InternalSetValueByPath(toObject, []string{"audioTranscriptionConfig"}, fromAudioTranscriptionConfig)
	}

	fromContinuationToken := InternalGetValueByPath(fromObject, []string{"continuationToken"})
	if fromContinuationToken != nil {
		InternalSetValueByPath(parentObject, []string{"continuationToken"}, fromContinuationToken)
	}

	if InternalGetValueByPath(fromObject, []string{"generationOutputConfig"}) != nil {
		return nil, fmt.Errorf("generationOutputConfig parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	fromStore := InternalGetValueByPath(fromObject, []string{"store"})
	if fromStore != nil {
		InternalSetValueByPath(parentObject, []string{"store"}, fromStore)
	}

	return toObject, nil
}

func generateContentConfigToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSystemInstruction := InternalGetValueByPath(fromObject, []string{"systemInstruction"})
	if fromSystemInstruction != nil {
		fromSystemInstruction, err = InternalTContent(fromSystemInstruction)
		if err != nil {
			return nil, err
		}

		fromSystemInstruction, err = contentToVertex(fromSystemInstruction.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"systemInstruction"}, fromSystemInstruction)
	}

	fromTemperature := InternalGetValueByPath(fromObject, []string{"temperature"})
	if fromTemperature != nil {
		InternalSetValueByPath(toObject, []string{"temperature"}, fromTemperature)
	}

	fromTopP := InternalGetValueByPath(fromObject, []string{"topP"})
	if fromTopP != nil {
		InternalSetValueByPath(toObject, []string{"topP"}, fromTopP)
	}

	fromTopK := InternalGetValueByPath(fromObject, []string{"topK"})
	if fromTopK != nil {
		InternalSetValueByPath(toObject, []string{"topK"}, fromTopK)
	}

	fromCandidateCount := InternalGetValueByPath(fromObject, []string{"candidateCount"})
	if fromCandidateCount != nil {
		InternalSetValueByPath(toObject, []string{"candidateCount"}, fromCandidateCount)
	}

	fromMaxOutputTokens := InternalGetValueByPath(fromObject, []string{"maxOutputTokens"})
	if fromMaxOutputTokens != nil {
		InternalSetValueByPath(toObject, []string{"maxOutputTokens"}, fromMaxOutputTokens)
	}

	fromStopSequences := InternalGetValueByPath(fromObject, []string{"stopSequences"})
	if fromStopSequences != nil {
		InternalSetValueByPath(toObject, []string{"stopSequences"}, fromStopSequences)
	}

	fromResponseLogprobs := InternalGetValueByPath(fromObject, []string{"responseLogprobs"})
	if fromResponseLogprobs != nil {
		InternalSetValueByPath(toObject, []string{"responseLogprobs"}, fromResponseLogprobs)
	}

	fromLogprobs := InternalGetValueByPath(fromObject, []string{"logprobs"})
	if fromLogprobs != nil {
		InternalSetValueByPath(toObject, []string{"logprobs"}, fromLogprobs)
	}

	fromPresencePenalty := InternalGetValueByPath(fromObject, []string{"presencePenalty"})
	if fromPresencePenalty != nil {
		InternalSetValueByPath(toObject, []string{"presencePenalty"}, fromPresencePenalty)
	}

	fromFrequencyPenalty := InternalGetValueByPath(fromObject, []string{"frequencyPenalty"})
	if fromFrequencyPenalty != nil {
		InternalSetValueByPath(toObject, []string{"frequencyPenalty"}, fromFrequencyPenalty)
	}

	fromSeed := InternalGetValueByPath(fromObject, []string{"seed"})
	if fromSeed != nil {
		InternalSetValueByPath(toObject, []string{"seed"}, fromSeed)
	}

	fromResponseMimeType := InternalGetValueByPath(fromObject, []string{"responseMimeType"})
	if fromResponseMimeType != nil {
		InternalSetValueByPath(toObject, []string{"responseMimeType"}, fromResponseMimeType)
	}

	fromResponseSchema := InternalGetValueByPath(fromObject, []string{"responseSchema"})
	if fromResponseSchema != nil {
		fromResponseSchema, err = InternalTSchema(fromResponseSchema)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"responseSchema"}, fromResponseSchema)
	}

	fromResponseJsonSchema := InternalGetValueByPath(fromObject, []string{"responseJsonSchema"})
	if fromResponseJsonSchema != nil {
		fromResponseJsonSchema, err = InternalTJsonSchema(fromResponseJsonSchema)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"responseJsonSchema"}, fromResponseJsonSchema)
	}

	fromRoutingConfig := InternalGetValueByPath(fromObject, []string{"routingConfig"})
	if fromRoutingConfig != nil {
		InternalSetValueByPath(toObject, []string{"routingConfig"}, fromRoutingConfig)
	}

	fromModelSelectionConfig := InternalGetValueByPath(fromObject, []string{"modelSelectionConfig"})
	if fromModelSelectionConfig != nil {
		InternalSetValueByPath(toObject, []string{"modelConfig"}, fromModelSelectionConfig)
	}

	fromSafetySettings := InternalGetValueByPath(fromObject, []string{"safetySettings"})
	if fromSafetySettings != nil {
		InternalSetValueByPath(parentObject, []string{"safetySettings"}, fromSafetySettings)
	}

	fromTools := InternalGetValueByPath(fromObject, []string{"tools"})
	if fromTools != nil {
		fromTools, err = applyItemTransformerToSlice(fromTools.([]any), tTool)
		if err != nil {
			return nil, err
		}

		fromTools, err = InternalTTools(fromTools)
		if err != nil {
			return nil, err
		}

		fromTools, err = InternalApplyConverterToSliceWithRoot(fromTools.([]any), toolToVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"tools"}, fromTools)
	}

	fromToolConfig := InternalGetValueByPath(fromObject, []string{"toolConfig"})
	if fromToolConfig != nil {
		fromToolConfig, err = toolConfigToVertex(fromToolConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"toolConfig"}, fromToolConfig)
	}

	fromLabels := InternalGetValueByPath(fromObject, []string{"labels"})
	if fromLabels != nil {
		InternalSetValueByPath(parentObject, []string{"labels"}, fromLabels)
	}

	fromCachedContent := InternalGetValueByPath(fromObject, []string{"cachedContent"})
	if fromCachedContent != nil {
		fromCachedContent, err = InternalTCachedContentName(ac, fromCachedContent)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"cachedContent"}, fromCachedContent)
	}

	fromResponseModalities := InternalGetValueByPath(fromObject, []string{"responseModalities"})
	if fromResponseModalities != nil {
		InternalSetValueByPath(toObject, []string{"responseModalities"}, fromResponseModalities)
	}

	fromMediaResolution := InternalGetValueByPath(fromObject, []string{"mediaResolution"})
	if fromMediaResolution != nil {
		InternalSetValueByPath(toObject, []string{"mediaResolution"}, fromMediaResolution)
	}

	fromSpeechConfig := InternalGetValueByPath(fromObject, []string{"speechConfig"})
	if fromSpeechConfig != nil {
		fromSpeechConfig, err = InternalTSpeechConfig(fromSpeechConfig)
		if err != nil {
			return nil, err
		}

		fromSpeechConfig, err = speechConfigToVertex(fromSpeechConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"speechConfig"}, fromSpeechConfig)
	}

	fromAudioTimestamp := InternalGetValueByPath(fromObject, []string{"audioTimestamp"})
	if fromAudioTimestamp != nil {
		InternalSetValueByPath(toObject, []string{"audioTimestamp"}, fromAudioTimestamp)
	}

	fromThinkingConfig := InternalGetValueByPath(fromObject, []string{"thinkingConfig"})
	if fromThinkingConfig != nil {
		InternalSetValueByPath(toObject, []string{"thinkingConfig"}, fromThinkingConfig)
	}

	fromImageConfig := InternalGetValueByPath(fromObject, []string{"imageConfig"})
	if fromImageConfig != nil {
		fromImageConfig, err = imageConfigToVertex(fromImageConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"imageConfig"}, fromImageConfig)
	}

	if InternalGetValueByPath(fromObject, []string{"enableEnhancedCivicAnswers"}) != nil {
		return nil, fmt.Errorf("enableEnhancedCivicAnswers parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	fromModelArmorConfig := InternalGetValueByPath(fromObject, []string{"modelArmorConfig"})
	if fromModelArmorConfig != nil {
		InternalSetValueByPath(parentObject, []string{"modelArmorConfig"}, fromModelArmorConfig)
	}

	fromServiceTier := InternalGetValueByPath(fromObject, []string{"serviceTier"})
	if fromServiceTier != nil {
		InternalSetValueByPath(parentObject, []string{"serviceTier"}, fromServiceTier)
	}

	fromAudioTranscriptionConfig := InternalGetValueByPath(fromObject, []string{"audioTranscriptionConfig"})
	if fromAudioTranscriptionConfig != nil {
		InternalSetValueByPath(toObject, []string{"audioTranscriptionConfig"}, fromAudioTranscriptionConfig)
	}

	fromContinuationToken := InternalGetValueByPath(fromObject, []string{"continuationToken"})
	if fromContinuationToken != nil {
		InternalSetValueByPath(parentObject, []string{"continuationToken"}, fromContinuationToken)
	}

	fromGenerationOutputConfig := InternalGetValueByPath(fromObject, []string{"generationOutputConfig"})
	if fromGenerationOutputConfig != nil {
		InternalSetValueByPath(parentObject, []string{"outputConfig"}, fromGenerationOutputConfig)
	}

	if InternalGetValueByPath(fromObject, []string{"store"}) != nil {
		return nil, fmt.Errorf("store parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	return toObject, nil
}

func generateContentParametersToMldev(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "model"}, fromModel)
	}

	fromContents := InternalGetValueByPath(fromObject, []string{"contents"})
	if fromContents != nil {
		fromContents, err = InternalTContents(fromContents)
		if err != nil {
			return nil, err
		}

		fromContents, err = InternalApplyConverterToSliceWithRoot(fromContents.([]any), contentToMldev, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"contents"}, fromContents)
	}

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		fromConfig, err = generateContentConfigToMldev(ac, fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"generationConfig"}, fromConfig)
	}

	return toObject, nil
}

func generateContentParametersToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "model"}, fromModel)
	}

	fromContents := InternalGetValueByPath(fromObject, []string{"contents"})
	if fromContents != nil {
		fromContents, err = InternalTContents(fromContents)
		if err != nil {
			return nil, err
		}

		fromContents, err = InternalApplyConverterToSliceWithRoot(fromContents.([]any), contentToVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"contents"}, fromContents)
	}

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		fromConfig, err = generateContentConfigToVertex(ac, fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"generationConfig"}, fromConfig)
	}

	return toObject, nil
}

func generateContentResponseFromMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSdkHttpResponse := InternalGetValueByPath(fromObject, []string{"sdkHttpResponse"})
	if fromSdkHttpResponse != nil {
		InternalSetValueByPath(toObject, []string{"sdkHttpResponse"}, fromSdkHttpResponse)
	}

	fromCandidates := InternalGetValueByPath(fromObject, []string{"candidates"})
	if fromCandidates != nil {
		fromCandidates, err = InternalApplyConverterToSliceWithRoot(fromCandidates.([]any), candidateFromMldev, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"candidates"}, fromCandidates)
	}

	fromModelVersion := InternalGetValueByPath(fromObject, []string{"modelVersion"})
	if fromModelVersion != nil {
		InternalSetValueByPath(toObject, []string{"modelVersion"}, fromModelVersion)
	}

	fromPromptFeedback := InternalGetValueByPath(fromObject, []string{"promptFeedback"})
	if fromPromptFeedback != nil {
		InternalSetValueByPath(toObject, []string{"promptFeedback"}, fromPromptFeedback)
	}

	fromResponseId := InternalGetValueByPath(fromObject, []string{"responseId"})
	if fromResponseId != nil {
		InternalSetValueByPath(toObject, []string{"responseId"}, fromResponseId)
	}

	fromUsageMetadata := InternalGetValueByPath(fromObject, []string{"usageMetadata"})
	if fromUsageMetadata != nil {
		InternalSetValueByPath(toObject, []string{"usageMetadata"}, fromUsageMetadata)
	}

	fromModelStatus := InternalGetValueByPath(fromObject, []string{"modelStatus"})
	if fromModelStatus != nil {
		InternalSetValueByPath(toObject, []string{"modelStatus"}, fromModelStatus)
	}

	return toObject, nil
}

func generateContentResponseFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSdkHttpResponse := InternalGetValueByPath(fromObject, []string{"sdkHttpResponse"})
	if fromSdkHttpResponse != nil {
		InternalSetValueByPath(toObject, []string{"sdkHttpResponse"}, fromSdkHttpResponse)
	}

	fromCandidates := InternalGetValueByPath(fromObject, []string{"candidates"})
	if fromCandidates != nil {
		InternalSetValueByPath(toObject, []string{"candidates"}, fromCandidates)
	}

	fromCreateTime := InternalGetValueByPath(fromObject, []string{"createTime"})
	if fromCreateTime != nil {
		InternalSetValueByPath(toObject, []string{"createTime"}, fromCreateTime)
	}

	fromModelVersion := InternalGetValueByPath(fromObject, []string{"modelVersion"})
	if fromModelVersion != nil {
		InternalSetValueByPath(toObject, []string{"modelVersion"}, fromModelVersion)
	}

	fromPromptFeedback := InternalGetValueByPath(fromObject, []string{"promptFeedback"})
	if fromPromptFeedback != nil {
		InternalSetValueByPath(toObject, []string{"promptFeedback"}, fromPromptFeedback)
	}

	fromResponseId := InternalGetValueByPath(fromObject, []string{"responseId"})
	if fromResponseId != nil {
		InternalSetValueByPath(toObject, []string{"responseId"}, fromResponseId)
	}

	fromUsageMetadata := InternalGetValueByPath(fromObject, []string{"usageMetadata"})
	if fromUsageMetadata != nil {
		InternalSetValueByPath(toObject, []string{"usageMetadata"}, fromUsageMetadata)
	}

	return toObject, nil
}

func generateImagesConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromOutputGcsUri := InternalGetValueByPath(fromObject, []string{"outputGcsUri"})
	if fromOutputGcsUri != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "storageUri"}, fromOutputGcsUri)
	}

	fromNegativePrompt := InternalGetValueByPath(fromObject, []string{"negativePrompt"})
	if fromNegativePrompt != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "negativePrompt"}, fromNegativePrompt)
	}

	fromNumberOfImages := InternalGetValueByPath(fromObject, []string{"numberOfImages"})
	if fromNumberOfImages != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "sampleCount"}, fromNumberOfImages)
	}

	fromAspectRatio := InternalGetValueByPath(fromObject, []string{"aspectRatio"})
	if fromAspectRatio != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "aspectRatio"}, fromAspectRatio)
	}

	fromGuidanceScale := InternalGetValueByPath(fromObject, []string{"guidanceScale"})
	if fromGuidanceScale != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "guidanceScale"}, fromGuidanceScale)
	}

	fromSeed := InternalGetValueByPath(fromObject, []string{"seed"})
	if fromSeed != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "seed"}, fromSeed)
	}

	fromSafetyFilterLevel := InternalGetValueByPath(fromObject, []string{"safetyFilterLevel"})
	if fromSafetyFilterLevel != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "safetySetting"}, fromSafetyFilterLevel)
	}

	fromPersonGeneration := InternalGetValueByPath(fromObject, []string{"personGeneration"})
	if fromPersonGeneration != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "personGeneration"}, fromPersonGeneration)
	}

	fromIncludeSafetyAttributes := InternalGetValueByPath(fromObject, []string{"includeSafetyAttributes"})
	if fromIncludeSafetyAttributes != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "includeSafetyAttributes"}, fromIncludeSafetyAttributes)
	}

	fromIncludeRaiReason := InternalGetValueByPath(fromObject, []string{"includeRaiReason"})
	if fromIncludeRaiReason != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "includeRaiReason"}, fromIncludeRaiReason)
	}

	fromLanguage := InternalGetValueByPath(fromObject, []string{"language"})
	if fromLanguage != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "language"}, fromLanguage)
	}

	fromOutputMimeType := InternalGetValueByPath(fromObject, []string{"outputMimeType"})
	if fromOutputMimeType != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "outputOptions", "mimeType"}, fromOutputMimeType)
	}

	fromOutputCompressionQuality := InternalGetValueByPath(fromObject, []string{"outputCompressionQuality"})
	if fromOutputCompressionQuality != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "outputOptions", "compressionQuality"}, fromOutputCompressionQuality)
	}

	fromAddWatermark := InternalGetValueByPath(fromObject, []string{"addWatermark"})
	if fromAddWatermark != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "addWatermark"}, fromAddWatermark)
	}

	fromLabels := InternalGetValueByPath(fromObject, []string{"labels"})
	if fromLabels != nil {
		InternalSetValueByPath(parentObject, []string{"labels"}, fromLabels)
	}

	fromImageSize := InternalGetValueByPath(fromObject, []string{"imageSize"})
	if fromImageSize != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "sampleImageSize"}, fromImageSize)
	}

	fromEnhancePrompt := InternalGetValueByPath(fromObject, []string{"enhancePrompt"})
	if fromEnhancePrompt != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "enhancePrompt"}, fromEnhancePrompt)
	}

	return toObject, nil
}

func generateImagesParametersToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "model"}, fromModel)
	}

	fromPrompt := InternalGetValueByPath(fromObject, []string{"prompt"})
	if fromPrompt != nil {
		InternalSetValueByPath(toObject, []string{"instances[0]", "prompt"}, fromPrompt)
	}

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		_, err = generateImagesConfigToVertex(fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	return toObject, nil
}

func generateImagesResponseFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSdkHttpResponse := InternalGetValueByPath(fromObject, []string{"sdkHttpResponse"})
	if fromSdkHttpResponse != nil {
		InternalSetValueByPath(toObject, []string{"sdkHttpResponse"}, fromSdkHttpResponse)
	}

	fromGeneratedImages := InternalGetValueByPath(fromObject, []string{"predictions"})
	if fromGeneratedImages != nil {
		fromGeneratedImages, err = InternalApplyConverterToSliceWithRoot(fromGeneratedImages.([]any), generatedImageFromVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"generatedImages"}, fromGeneratedImages)
	}

	fromPositivePromptSafetyAttributes := InternalGetValueByPath(fromObject, []string{"positivePromptSafetyAttributes"})
	if fromPositivePromptSafetyAttributes != nil {
		fromPositivePromptSafetyAttributes, err = safetyAttributesFromVertex(fromPositivePromptSafetyAttributes.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"positivePromptSafetyAttributes"}, fromPositivePromptSafetyAttributes)
	}

	return toObject, nil
}

func generateVideosConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromNumberOfVideos := InternalGetValueByPath(fromObject, []string{"numberOfVideos"})
	if fromNumberOfVideos != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "sampleCount"}, fromNumberOfVideos)
	}

	fromOutputGcsUri := InternalGetValueByPath(fromObject, []string{"outputGcsUri"})
	if fromOutputGcsUri != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "storageUri"}, fromOutputGcsUri)
	}

	fromFps := InternalGetValueByPath(fromObject, []string{"fps"})
	if fromFps != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "fps"}, fromFps)
	}

	fromDurationSeconds := InternalGetValueByPath(fromObject, []string{"durationSeconds"})
	if fromDurationSeconds != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "durationSeconds"}, fromDurationSeconds)
	}

	fromSeed := InternalGetValueByPath(fromObject, []string{"seed"})
	if fromSeed != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "seed"}, fromSeed)
	}

	fromAspectRatio := InternalGetValueByPath(fromObject, []string{"aspectRatio"})
	if fromAspectRatio != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "aspectRatio"}, fromAspectRatio)
	}

	fromResolution := InternalGetValueByPath(fromObject, []string{"resolution"})
	if fromResolution != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "resolution"}, fromResolution)
	}

	fromPersonGeneration := InternalGetValueByPath(fromObject, []string{"personGeneration"})
	if fromPersonGeneration != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "personGeneration"}, fromPersonGeneration)
	}

	fromPubsubTopic := InternalGetValueByPath(fromObject, []string{"pubsubTopic"})
	if fromPubsubTopic != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "pubsubTopic"}, fromPubsubTopic)
	}

	fromNegativePrompt := InternalGetValueByPath(fromObject, []string{"negativePrompt"})
	if fromNegativePrompt != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "negativePrompt"}, fromNegativePrompt)
	}

	fromEnhancePrompt := InternalGetValueByPath(fromObject, []string{"enhancePrompt"})
	if fromEnhancePrompt != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "enhancePrompt"}, fromEnhancePrompt)
	}

	fromGenerateAudio := InternalGetValueByPath(fromObject, []string{"generateAudio"})
	if fromGenerateAudio != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "generateAudio"}, fromGenerateAudio)
	}

	fromLastFrame := InternalGetValueByPath(fromObject, []string{"lastFrame"})
	if fromLastFrame != nil {
		fromLastFrame, err = imageToVertex(fromLastFrame.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"instances[0]", "lastFrame"}, fromLastFrame)
	}

	fromReferenceImages := InternalGetValueByPath(fromObject, []string{"referenceImages"})
	if fromReferenceImages != nil {
		fromReferenceImages, err = InternalApplyConverterToSliceWithRoot(fromReferenceImages.([]any), videoGenerationReferenceImageToVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"instances[0]", "referenceImages"}, fromReferenceImages)
	}

	fromMask := InternalGetValueByPath(fromObject, []string{"mask"})
	if fromMask != nil {
		fromMask, err = videoGenerationMaskToVertex(fromMask.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"instances[0]", "mask"}, fromMask)
	}

	fromCompressionQuality := InternalGetValueByPath(fromObject, []string{"compressionQuality"})
	if fromCompressionQuality != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "compressionQuality"}, fromCompressionQuality)
	}

	fromLabels := InternalGetValueByPath(fromObject, []string{"labels"})
	if fromLabels != nil {
		InternalSetValueByPath(parentObject, []string{"labels"}, fromLabels)
	}

	if InternalGetValueByPath(fromObject, []string{"webhookConfig"}) != nil {
		return nil, fmt.Errorf("webhookConfig parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	fromResizeMode := InternalGetValueByPath(fromObject, []string{"resizeMode"})
	if fromResizeMode != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "resizeMode"}, fromResizeMode)
	}

	return toObject, nil
}

func generateVideosOperationFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromName := InternalGetValueByPath(fromObject, []string{"name"})
	if fromName != nil {
		InternalSetValueByPath(toObject, []string{"name"}, fromName)
	}

	fromMetadata := InternalGetValueByPath(fromObject, []string{"metadata"})
	if fromMetadata != nil {
		InternalSetValueByPath(toObject, []string{"metadata"}, fromMetadata)
	}

	fromDone := InternalGetValueByPath(fromObject, []string{"done"})
	if fromDone != nil {
		InternalSetValueByPath(toObject, []string{"done"}, fromDone)
	}

	fromError := InternalGetValueByPath(fromObject, []string{"error"})
	if fromError != nil {
		InternalSetValueByPath(toObject, []string{"error"}, fromError)
	}

	fromResponse := InternalGetValueByPath(fromObject, []string{"response"})
	if fromResponse != nil {
		fromResponse, err = generateVideosResponseFromVertex(fromResponse.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"response"}, fromResponse)
	}

	return toObject, nil
}

func generateVideosParametersToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "model"}, fromModel)
	}

	fromPrompt := InternalGetValueByPath(fromObject, []string{"prompt"})
	if fromPrompt != nil {
		InternalSetValueByPath(toObject, []string{"instances[0]", "prompt"}, fromPrompt)
	}

	fromImage := InternalGetValueByPath(fromObject, []string{"image"})
	if fromImage != nil {
		fromImage, err = imageToVertex(fromImage.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"instances[0]", "image"}, fromImage)
	}

	fromVideo := InternalGetValueByPath(fromObject, []string{"video"})
	if fromVideo != nil {
		fromVideo, err = videoToVertex(fromVideo.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"instances[0]", "video"}, fromVideo)
	}

	fromSource := InternalGetValueByPath(fromObject, []string{"source"})
	if fromSource != nil {
		_, err = generateVideosSourceToVertex(fromSource.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		_, err = generateVideosConfigToVertex(fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	return toObject, nil
}

func generateVideosResponseFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromGeneratedVideos := InternalGetValueByPath(fromObject, []string{"videos"})
	if fromGeneratedVideos != nil {
		fromGeneratedVideos, err = InternalApplyConverterToSliceWithRoot(fromGeneratedVideos.([]any), generatedVideoFromVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"generatedVideos"}, fromGeneratedVideos)
	}

	fromRaiMediaFilteredCount := InternalGetValueByPath(fromObject, []string{"raiMediaFilteredCount"})
	if fromRaiMediaFilteredCount != nil {
		InternalSetValueByPath(toObject, []string{"raiMediaFilteredCount"}, fromRaiMediaFilteredCount)
	}

	fromRaiMediaFilteredReasons := InternalGetValueByPath(fromObject, []string{"raiMediaFilteredReasons"})
	if fromRaiMediaFilteredReasons != nil {
		InternalSetValueByPath(toObject, []string{"raiMediaFilteredReasons"}, fromRaiMediaFilteredReasons)
	}

	return toObject, nil
}

func generateVideosSourceToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromPrompt := InternalGetValueByPath(fromObject, []string{"prompt"})
	if fromPrompt != nil {
		InternalSetValueByPath(parentObject, []string{"instances[0]", "prompt"}, fromPrompt)
	}

	fromImage := InternalGetValueByPath(fromObject, []string{"image"})
	if fromImage != nil {
		fromImage, err = imageToVertex(fromImage.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"instances[0]", "image"}, fromImage)
	}

	fromVideo := InternalGetValueByPath(fromObject, []string{"video"})
	if fromVideo != nil {
		fromVideo, err = videoToVertex(fromVideo.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"instances[0]", "video"}, fromVideo)
	}

	return toObject, nil
}

func generatedImageFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromImage := InternalGetValueByPath(fromObject, []string{"_self"})
	if fromImage != nil {
		fromImage, err = imageFromVertex(fromImage.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"image"}, fromImage)
	}

	fromRaiFilteredReason := InternalGetValueByPath(fromObject, []string{"raiFilteredReason"})
	if fromRaiFilteredReason != nil {
		InternalSetValueByPath(toObject, []string{"raiFilteredReason"}, fromRaiFilteredReason)
	}

	fromSafetyAttributes := InternalGetValueByPath(fromObject, []string{"_self"})
	if fromSafetyAttributes != nil {
		fromSafetyAttributes, err = safetyAttributesFromVertex(fromSafetyAttributes.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"safetyAttributes"}, fromSafetyAttributes)
	}

	fromEnhancedPrompt := InternalGetValueByPath(fromObject, []string{"prompt"})
	if fromEnhancedPrompt != nil {
		InternalSetValueByPath(toObject, []string{"enhancedPrompt"}, fromEnhancedPrompt)
	}

	return toObject, nil
}

func generatedImageMaskFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromMask := InternalGetValueByPath(fromObject, []string{"_self"})
	if fromMask != nil {
		fromMask, err = imageFromVertex(fromMask.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"mask"}, fromMask)
	}

	fromLabels := InternalGetValueByPath(fromObject, []string{"labels"})
	if fromLabels != nil {
		InternalSetValueByPath(toObject, []string{"labels"}, fromLabels)
	}

	return toObject, nil
}

func generatedVideoFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromVideo := InternalGetValueByPath(fromObject, []string{"_self"})
	if fromVideo != nil {
		fromVideo, err = videoFromVertex(fromVideo.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"video"}, fromVideo)
	}

	return toObject, nil
}

func generationConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModelSelectionConfig := InternalGetValueByPath(fromObject, []string{"modelSelectionConfig"})
	if fromModelSelectionConfig != nil {
		InternalSetValueByPath(toObject, []string{"modelConfig"}, fromModelSelectionConfig)
	}

	fromResponseJsonSchema := InternalGetValueByPath(fromObject, []string{"responseJsonSchema"})
	if fromResponseJsonSchema != nil {
		fromResponseJsonSchema, err = InternalTJsonSchema(fromResponseJsonSchema)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"responseJsonSchema"}, fromResponseJsonSchema)
	}

	fromAudioTimestamp := InternalGetValueByPath(fromObject, []string{"audioTimestamp"})
	if fromAudioTimestamp != nil {
		InternalSetValueByPath(toObject, []string{"audioTimestamp"}, fromAudioTimestamp)
	}

	fromCandidateCount := InternalGetValueByPath(fromObject, []string{"candidateCount"})
	if fromCandidateCount != nil {
		InternalSetValueByPath(toObject, []string{"candidateCount"}, fromCandidateCount)
	}

	fromEnableAffectiveDialog := InternalGetValueByPath(fromObject, []string{"enableAffectiveDialog"})
	if fromEnableAffectiveDialog != nil {
		InternalSetValueByPath(toObject, []string{"enableAffectiveDialog"}, fromEnableAffectiveDialog)
	}

	fromFrequencyPenalty := InternalGetValueByPath(fromObject, []string{"frequencyPenalty"})
	if fromFrequencyPenalty != nil {
		InternalSetValueByPath(toObject, []string{"frequencyPenalty"}, fromFrequencyPenalty)
	}

	fromLogprobs := InternalGetValueByPath(fromObject, []string{"logprobs"})
	if fromLogprobs != nil {
		InternalSetValueByPath(toObject, []string{"logprobs"}, fromLogprobs)
	}

	fromMaxOutputTokens := InternalGetValueByPath(fromObject, []string{"maxOutputTokens"})
	if fromMaxOutputTokens != nil {
		InternalSetValueByPath(toObject, []string{"maxOutputTokens"}, fromMaxOutputTokens)
	}

	fromMediaResolution := InternalGetValueByPath(fromObject, []string{"mediaResolution"})
	if fromMediaResolution != nil {
		InternalSetValueByPath(toObject, []string{"mediaResolution"}, fromMediaResolution)
	}

	fromPresencePenalty := InternalGetValueByPath(fromObject, []string{"presencePenalty"})
	if fromPresencePenalty != nil {
		InternalSetValueByPath(toObject, []string{"presencePenalty"}, fromPresencePenalty)
	}

	fromResponseLogprobs := InternalGetValueByPath(fromObject, []string{"responseLogprobs"})
	if fromResponseLogprobs != nil {
		InternalSetValueByPath(toObject, []string{"responseLogprobs"}, fromResponseLogprobs)
	}

	fromResponseMimeType := InternalGetValueByPath(fromObject, []string{"responseMimeType"})
	if fromResponseMimeType != nil {
		InternalSetValueByPath(toObject, []string{"responseMimeType"}, fromResponseMimeType)
	}

	fromResponseModalities := InternalGetValueByPath(fromObject, []string{"responseModalities"})
	if fromResponseModalities != nil {
		InternalSetValueByPath(toObject, []string{"responseModalities"}, fromResponseModalities)
	}

	fromResponseSchema := InternalGetValueByPath(fromObject, []string{"responseSchema"})
	if fromResponseSchema != nil {
		InternalSetValueByPath(toObject, []string{"responseSchema"}, fromResponseSchema)
	}

	fromRoutingConfig := InternalGetValueByPath(fromObject, []string{"routingConfig"})
	if fromRoutingConfig != nil {
		InternalSetValueByPath(toObject, []string{"routingConfig"}, fromRoutingConfig)
	}

	fromSeed := InternalGetValueByPath(fromObject, []string{"seed"})
	if fromSeed != nil {
		InternalSetValueByPath(toObject, []string{"seed"}, fromSeed)
	}

	fromSpeechConfig := InternalGetValueByPath(fromObject, []string{"speechConfig"})
	if fromSpeechConfig != nil {
		fromSpeechConfig, err = speechConfigToVertex(fromSpeechConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"speechConfig"}, fromSpeechConfig)
	}

	fromStopSequences := InternalGetValueByPath(fromObject, []string{"stopSequences"})
	if fromStopSequences != nil {
		InternalSetValueByPath(toObject, []string{"stopSequences"}, fromStopSequences)
	}

	fromTemperature := InternalGetValueByPath(fromObject, []string{"temperature"})
	if fromTemperature != nil {
		InternalSetValueByPath(toObject, []string{"temperature"}, fromTemperature)
	}

	fromThinkingConfig := InternalGetValueByPath(fromObject, []string{"thinkingConfig"})
	if fromThinkingConfig != nil {
		InternalSetValueByPath(toObject, []string{"thinkingConfig"}, fromThinkingConfig)
	}

	fromTopK := InternalGetValueByPath(fromObject, []string{"topK"})
	if fromTopK != nil {
		InternalSetValueByPath(toObject, []string{"topK"}, fromTopK)
	}

	fromTopP := InternalGetValueByPath(fromObject, []string{"topP"})
	if fromTopP != nil {
		InternalSetValueByPath(toObject, []string{"topP"}, fromTopP)
	}

	if InternalGetValueByPath(fromObject, []string{"enableEnhancedCivicAnswers"}) != nil {
		return nil, fmt.Errorf("enableEnhancedCivicAnswers parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	fromResponseFormat := InternalGetValueByPath(fromObject, []string{"responseFormat"})
	if fromResponseFormat != nil {
		InternalSetValueByPath(toObject, []string{"responseFormat"}, fromResponseFormat)
	}

	fromTranslationConfig := InternalGetValueByPath(fromObject, []string{"translationConfig"})
	if fromTranslationConfig != nil {
		InternalSetValueByPath(toObject, []string{"translationConfig"}, fromTranslationConfig)
	}

	fromAudioTranscriptionConfig := InternalGetValueByPath(fromObject, []string{"audioTranscriptionConfig"})
	if fromAudioTranscriptionConfig != nil {
		InternalSetValueByPath(toObject, []string{"audioTranscriptionConfig"}, fromAudioTranscriptionConfig)
	}

	return toObject, nil
}

func getModelParametersToMldev(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "name"}, fromModel)
	}

	return toObject, nil
}

func getModelParametersToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "name"}, fromModel)
	}

	return toObject, nil
}

func googleMapsToMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromAuthConfig := InternalGetValueByPath(fromObject, []string{"authConfig"})
	if fromAuthConfig != nil {
		fromAuthConfig, err = authConfigToMldev(fromAuthConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"authConfig"}, fromAuthConfig)
	}

	fromEnableWidget := InternalGetValueByPath(fromObject, []string{"enableWidget"})
	if fromEnableWidget != nil {
		InternalSetValueByPath(toObject, []string{"enableWidget"}, fromEnableWidget)
	}

	if InternalGetValueByPath(fromObject, []string{"groundingTypes"}) != nil {
		return nil, fmt.Errorf("groundingTypes parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	return toObject, nil
}

func googleSearchToMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSearchTypes := InternalGetValueByPath(fromObject, []string{"searchTypes"})
	if fromSearchTypes != nil {
		InternalSetValueByPath(toObject, []string{"searchTypes"}, fromSearchTypes)
	}

	if InternalGetValueByPath(fromObject, []string{"blockingConfidence"}) != nil {
		return nil, fmt.Errorf("blockingConfidence parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"excludeDomains"}) != nil {
		return nil, fmt.Errorf("excludeDomains parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	fromTimeRangeFilter := InternalGetValueByPath(fromObject, []string{"timeRangeFilter"})
	if fromTimeRangeFilter != nil {
		InternalSetValueByPath(toObject, []string{"timeRangeFilter"}, fromTimeRangeFilter)
	}

	return toObject, nil
}

func imageConfigToMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromAspectRatio := InternalGetValueByPath(fromObject, []string{"aspectRatio"})
	if fromAspectRatio != nil {
		InternalSetValueByPath(toObject, []string{"aspectRatio"}, fromAspectRatio)
	}

	fromImageSize := InternalGetValueByPath(fromObject, []string{"imageSize"})
	if fromImageSize != nil {
		InternalSetValueByPath(toObject, []string{"imageSize"}, fromImageSize)
	}

	if InternalGetValueByPath(fromObject, []string{"personGeneration"}) != nil {
		return nil, fmt.Errorf("personGeneration parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"prominentPeople"}) != nil {
		return nil, fmt.Errorf("prominentPeople parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"outputMimeType"}) != nil {
		return nil, fmt.Errorf("outputMimeType parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"outputCompressionQuality"}) != nil {
		return nil, fmt.Errorf("outputCompressionQuality parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"imageOutputOptions"}) != nil {
		return nil, fmt.Errorf("imageOutputOptions parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	return toObject, nil
}

func imageConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromAspectRatio := InternalGetValueByPath(fromObject, []string{"aspectRatio"})
	if fromAspectRatio != nil {
		InternalSetValueByPath(toObject, []string{"aspectRatio"}, fromAspectRatio)
	}

	fromImageSize := InternalGetValueByPath(fromObject, []string{"imageSize"})
	if fromImageSize != nil {
		InternalSetValueByPath(toObject, []string{"imageSize"}, fromImageSize)
	}

	fromPersonGeneration := InternalGetValueByPath(fromObject, []string{"personGeneration"})
	if fromPersonGeneration != nil {
		InternalSetValueByPath(toObject, []string{"personGeneration"}, fromPersonGeneration)
	}

	fromProminentPeople := InternalGetValueByPath(fromObject, []string{"prominentPeople"})
	if fromProminentPeople != nil {
		InternalSetValueByPath(toObject, []string{"prominentPeople"}, fromProminentPeople)
	}

	fromOutputMimeType := InternalGetValueByPath(fromObject, []string{"outputMimeType"})
	if fromOutputMimeType != nil {
		InternalSetValueByPath(toObject, []string{"imageOutputOptions", "mimeType"}, fromOutputMimeType)
	}

	fromOutputCompressionQuality := InternalGetValueByPath(fromObject, []string{"outputCompressionQuality"})
	if fromOutputCompressionQuality != nil {
		InternalSetValueByPath(toObject, []string{"imageOutputOptions", "compressionQuality"}, fromOutputCompressionQuality)
	}

	fromImageOutputOptions := InternalGetValueByPath(fromObject, []string{"imageOutputOptions"})
	if fromImageOutputOptions != nil {
		InternalSetValueByPath(toObject, []string{"imageOutputOptions"}, fromImageOutputOptions)
	}

	return toObject, nil
}

func imageFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromGcsUri := InternalGetValueByPath(fromObject, []string{"gcsUri"})
	if fromGcsUri != nil {
		InternalSetValueByPath(toObject, []string{"gcsUri"}, fromGcsUri)
	}

	fromImageBytes := InternalGetValueByPath(fromObject, []string{"bytesBase64Encoded"})
	if fromImageBytes != nil {
		fromImageBytes, err = InternalTBytes(fromImageBytes)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"imageBytes"}, fromImageBytes)
	}

	fromMimeType := InternalGetValueByPath(fromObject, []string{"mimeType"})
	if fromMimeType != nil {
		InternalSetValueByPath(toObject, []string{"mimeType"}, fromMimeType)
	}

	return toObject, nil
}

func imageToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromGcsUri := InternalGetValueByPath(fromObject, []string{"gcsUri"})
	if fromGcsUri != nil {
		InternalSetValueByPath(toObject, []string{"gcsUri"}, fromGcsUri)
	}

	fromImageBytes := InternalGetValueByPath(fromObject, []string{"imageBytes"})
	if fromImageBytes != nil {
		fromImageBytes, err = InternalTBytes(fromImageBytes)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"bytesBase64Encoded"}, fromImageBytes)
	}

	fromMimeType := InternalGetValueByPath(fromObject, []string{"mimeType"})
	if fromMimeType != nil {
		InternalSetValueByPath(toObject, []string{"mimeType"}, fromMimeType)
	}

	return toObject, nil
}

func listModelsConfigToMldev(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromPageSize := InternalGetValueByPath(fromObject, []string{"pageSize"})
	if fromPageSize != nil {
		InternalSetValueByPath(parentObject, []string{"_query", "pageSize"}, fromPageSize)
	}

	fromPageToken := InternalGetValueByPath(fromObject, []string{"pageToken"})
	if fromPageToken != nil {
		InternalSetValueByPath(parentObject, []string{"_query", "pageToken"}, fromPageToken)
	}

	fromFilter := InternalGetValueByPath(fromObject, []string{"filter"})
	if fromFilter != nil {
		InternalSetValueByPath(parentObject, []string{"_query", "filter"}, fromFilter)
	}

	fromQueryBase := InternalGetValueByPath(fromObject, []string{"queryBase"})
	if fromQueryBase != nil {
		fromQueryBase, err = InternalTModelsURL(ac, fromQueryBase)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"_url", "models_url"}, fromQueryBase)
	}

	return toObject, nil
}

func listModelsConfigToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromPageSize := InternalGetValueByPath(fromObject, []string{"pageSize"})
	if fromPageSize != nil {
		InternalSetValueByPath(parentObject, []string{"_query", "pageSize"}, fromPageSize)
	}

	fromPageToken := InternalGetValueByPath(fromObject, []string{"pageToken"})
	if fromPageToken != nil {
		InternalSetValueByPath(parentObject, []string{"_query", "pageToken"}, fromPageToken)
	}

	fromFilter := InternalGetValueByPath(fromObject, []string{"filter"})
	if fromFilter != nil {
		InternalSetValueByPath(parentObject, []string{"_query", "filter"}, fromFilter)
	}

	fromQueryBase := InternalGetValueByPath(fromObject, []string{"queryBase"})
	if fromQueryBase != nil {
		fromQueryBase, err = InternalTModelsURL(ac, fromQueryBase)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"_url", "models_url"}, fromQueryBase)
	}

	return toObject, nil
}

func listModelsParametersToMldev(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		_, err = listModelsConfigToMldev(ac, fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	return toObject, nil
}

func listModelsParametersToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		_, err = listModelsConfigToVertex(ac, fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	return toObject, nil
}

func listModelsResponseFromMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSdkHttpResponse := InternalGetValueByPath(fromObject, []string{"sdkHttpResponse"})
	if fromSdkHttpResponse != nil {
		InternalSetValueByPath(toObject, []string{"sdkHttpResponse"}, fromSdkHttpResponse)
	}

	fromNextPageToken := InternalGetValueByPath(fromObject, []string{"nextPageToken"})
	if fromNextPageToken != nil {
		InternalSetValueByPath(toObject, []string{"nextPageToken"}, fromNextPageToken)
	}

	fromModels := InternalGetValueByPath(fromObject, []string{"_self"})
	if fromModels != nil {
		fromModels, err = InternalTExtractModels(fromModels)
		if err != nil {
			return nil, err
		}

		fromModels, err = InternalApplyConverterToSliceWithRoot(fromModels.([]any), modelFromMldev, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"models"}, fromModels)
	}

	return toObject, nil
}

func listModelsResponseFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSdkHttpResponse := InternalGetValueByPath(fromObject, []string{"sdkHttpResponse"})
	if fromSdkHttpResponse != nil {
		InternalSetValueByPath(toObject, []string{"sdkHttpResponse"}, fromSdkHttpResponse)
	}

	fromNextPageToken := InternalGetValueByPath(fromObject, []string{"nextPageToken"})
	if fromNextPageToken != nil {
		InternalSetValueByPath(toObject, []string{"nextPageToken"}, fromNextPageToken)
	}

	fromModels := InternalGetValueByPath(fromObject, []string{"_self"})
	if fromModels != nil {
		fromModels, err = InternalTExtractModels(fromModels)
		if err != nil {
			return nil, err
		}

		fromModels, err = InternalApplyConverterToSliceWithRoot(fromModels.([]any), modelFromVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"models"}, fromModels)
	}

	return toObject, nil
}

func maskReferenceConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromMaskMode := InternalGetValueByPath(fromObject, []string{"maskMode"})
	if fromMaskMode != nil {
		InternalSetValueByPath(toObject, []string{"maskMode"}, fromMaskMode)
	}

	fromSegmentationClasses := InternalGetValueByPath(fromObject, []string{"segmentationClasses"})
	if fromSegmentationClasses != nil {
		InternalSetValueByPath(toObject, []string{"maskClasses"}, fromSegmentationClasses)
	}

	fromMaskDilation := InternalGetValueByPath(fromObject, []string{"maskDilation"})
	if fromMaskDilation != nil {
		InternalSetValueByPath(toObject, []string{"dilation"}, fromMaskDilation)
	}

	return toObject, nil
}

func mcpServerToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)
	if InternalGetValueByPath(fromObject, []string{"name"}) != nil {
		return nil, fmt.Errorf("name parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"streamableHttpTransport"}) != nil {
		return nil, fmt.Errorf("streamableHttpTransport parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	return toObject, nil
}

func modelFromMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromName := InternalGetValueByPath(fromObject, []string{"name"})
	if fromName != nil {
		InternalSetValueByPath(toObject, []string{"name"}, fromName)
	}

	fromDisplayName := InternalGetValueByPath(fromObject, []string{"displayName"})
	if fromDisplayName != nil {
		InternalSetValueByPath(toObject, []string{"displayName"}, fromDisplayName)
	}

	fromDescription := InternalGetValueByPath(fromObject, []string{"description"})
	if fromDescription != nil {
		InternalSetValueByPath(toObject, []string{"description"}, fromDescription)
	}

	fromVersion := InternalGetValueByPath(fromObject, []string{"version"})
	if fromVersion != nil {
		InternalSetValueByPath(toObject, []string{"version"}, fromVersion)
	}

	fromTunedModelInfo := InternalGetValueByPath(fromObject, []string{"_self"})
	if fromTunedModelInfo != nil {
		InternalSetValueByPath(toObject, []string{"tunedModelInfo"}, fromTunedModelInfo)
	}

	fromInputTokenLimit := InternalGetValueByPath(fromObject, []string{"inputTokenLimit"})
	if fromInputTokenLimit != nil {
		InternalSetValueByPath(toObject, []string{"inputTokenLimit"}, fromInputTokenLimit)
	}

	fromOutputTokenLimit := InternalGetValueByPath(fromObject, []string{"outputTokenLimit"})
	if fromOutputTokenLimit != nil {
		InternalSetValueByPath(toObject, []string{"outputTokenLimit"}, fromOutputTokenLimit)
	}

	fromSupportedActions := InternalGetValueByPath(fromObject, []string{"supportedGenerationMethods"})
	if fromSupportedActions != nil {
		InternalSetValueByPath(toObject, []string{"supportedActions"}, fromSupportedActions)
	}

	fromTemperature := InternalGetValueByPath(fromObject, []string{"temperature"})
	if fromTemperature != nil {
		InternalSetValueByPath(toObject, []string{"temperature"}, fromTemperature)
	}

	fromMaxTemperature := InternalGetValueByPath(fromObject, []string{"maxTemperature"})
	if fromMaxTemperature != nil {
		InternalSetValueByPath(toObject, []string{"maxTemperature"}, fromMaxTemperature)
	}

	fromTopP := InternalGetValueByPath(fromObject, []string{"topP"})
	if fromTopP != nil {
		InternalSetValueByPath(toObject, []string{"topP"}, fromTopP)
	}

	fromTopK := InternalGetValueByPath(fromObject, []string{"topK"})
	if fromTopK != nil {
		InternalSetValueByPath(toObject, []string{"topK"}, fromTopK)
	}

	fromThinking := InternalGetValueByPath(fromObject, []string{"thinking"})
	if fromThinking != nil {
		InternalSetValueByPath(toObject, []string{"thinking"}, fromThinking)
	}

	return toObject, nil
}

func modelFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromName := InternalGetValueByPath(fromObject, []string{"name"})
	if fromName != nil {
		InternalSetValueByPath(toObject, []string{"name"}, fromName)
	}

	fromDisplayName := InternalGetValueByPath(fromObject, []string{"displayName"})
	if fromDisplayName != nil {
		InternalSetValueByPath(toObject, []string{"displayName"}, fromDisplayName)
	}

	fromDescription := InternalGetValueByPath(fromObject, []string{"description"})
	if fromDescription != nil {
		InternalSetValueByPath(toObject, []string{"description"}, fromDescription)
	}

	fromVersion := InternalGetValueByPath(fromObject, []string{"versionId"})
	if fromVersion != nil {
		InternalSetValueByPath(toObject, []string{"version"}, fromVersion)
	}

	fromEndpoints := InternalGetValueByPath(fromObject, []string{"deployedModels"})
	if fromEndpoints != nil {
		fromEndpoints, err = InternalApplyConverterToSliceWithRoot(fromEndpoints.([]any), endpointFromVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"endpoints"}, fromEndpoints)
	}

	fromLabels := InternalGetValueByPath(fromObject, []string{"labels"})
	if fromLabels != nil {
		InternalSetValueByPath(toObject, []string{"labels"}, fromLabels)
	}

	fromTunedModelInfo := InternalGetValueByPath(fromObject, []string{"_self"})
	if fromTunedModelInfo != nil {
		fromTunedModelInfo, err = tunedModelInfoFromVertex(fromTunedModelInfo.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"tunedModelInfo"}, fromTunedModelInfo)
	}

	fromDefaultCheckpointId := InternalGetValueByPath(fromObject, []string{"defaultCheckpointId"})
	if fromDefaultCheckpointId != nil {
		InternalSetValueByPath(toObject, []string{"defaultCheckpointId"}, fromDefaultCheckpointId)
	}

	fromCheckpoints := InternalGetValueByPath(fromObject, []string{"checkpoints"})
	if fromCheckpoints != nil {
		InternalSetValueByPath(toObject, []string{"checkpoints"}, fromCheckpoints)
	}

	return toObject, nil
}

func multiSpeakerVoiceConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSpeakerVoiceConfigs := InternalGetValueByPath(fromObject, []string{"speakerVoiceConfigs"})
	if fromSpeakerVoiceConfigs != nil {
		fromSpeakerVoiceConfigs, err = InternalApplyConverterToSliceWithRoot(fromSpeakerVoiceConfigs.([]any), speakerVoiceConfigToVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"speakerVoiceConfigs"}, fromSpeakerVoiceConfigs)
	}

	return toObject, nil
}

func partToMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromMediaResolution := InternalGetValueByPath(fromObject, []string{"mediaResolution"})
	if fromMediaResolution != nil {
		InternalSetValueByPath(toObject, []string{"mediaResolution"}, fromMediaResolution)
	}

	fromCodeExecutionResult := InternalGetValueByPath(fromObject, []string{"codeExecutionResult"})
	if fromCodeExecutionResult != nil {
		InternalSetValueByPath(toObject, []string{"codeExecutionResult"}, fromCodeExecutionResult)
	}

	fromExecutableCode := InternalGetValueByPath(fromObject, []string{"executableCode"})
	if fromExecutableCode != nil {
		InternalSetValueByPath(toObject, []string{"executableCode"}, fromExecutableCode)
	}

	fromFileData := InternalGetValueByPath(fromObject, []string{"fileData"})
	if fromFileData != nil {
		InternalSetValueByPath(toObject, []string{"fileData"}, fromFileData)
	}

	fromFunctionCall := InternalGetValueByPath(fromObject, []string{"functionCall"})
	if fromFunctionCall != nil {
		fromFunctionCall, err = functionCallToMldev(fromFunctionCall.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"functionCall"}, fromFunctionCall)
	}

	fromFunctionResponse := InternalGetValueByPath(fromObject, []string{"functionResponse"})
	if fromFunctionResponse != nil {
		InternalSetValueByPath(toObject, []string{"functionResponse"}, fromFunctionResponse)
	}

	fromInlineData := InternalGetValueByPath(fromObject, []string{"inlineData"})
	if fromInlineData != nil {
		InternalSetValueByPath(toObject, []string{"inlineData"}, fromInlineData)
	}

	fromText := InternalGetValueByPath(fromObject, []string{"text"})
	if fromText != nil {
		InternalSetValueByPath(toObject, []string{"text"}, fromText)
	}

	fromThought := InternalGetValueByPath(fromObject, []string{"thought"})
	if fromThought != nil {
		InternalSetValueByPath(toObject, []string{"thought"}, fromThought)
	}

	fromThoughtSignature := InternalGetValueByPath(fromObject, []string{"thoughtSignature"})
	if fromThoughtSignature != nil {
		InternalSetValueByPath(toObject, []string{"thoughtSignature"}, fromThoughtSignature)
	}

	fromVideoMetadata := InternalGetValueByPath(fromObject, []string{"videoMetadata"})
	if fromVideoMetadata != nil {
		InternalSetValueByPath(toObject, []string{"videoMetadata"}, fromVideoMetadata)
	}

	fromToolCall := InternalGetValueByPath(fromObject, []string{"toolCall"})
	if fromToolCall != nil {
		InternalSetValueByPath(toObject, []string{"toolCall"}, fromToolCall)
	}

	fromToolResponse := InternalGetValueByPath(fromObject, []string{"toolResponse"})
	if fromToolResponse != nil {
		InternalSetValueByPath(toObject, []string{"toolResponse"}, fromToolResponse)
	}

	fromPartMetadata := InternalGetValueByPath(fromObject, []string{"partMetadata"})
	if fromPartMetadata != nil {
		InternalSetValueByPath(toObject, []string{"partMetadata"}, fromPartMetadata)
	}

	fromAudioTranscription := InternalGetValueByPath(fromObject, []string{"audioTranscription"})
	if fromAudioTranscription != nil {
		InternalSetValueByPath(toObject, []string{"audioTranscription"}, fromAudioTranscription)
	}

	fromMediaProcessing := InternalGetValueByPath(fromObject, []string{"mediaProcessing"})
	if fromMediaProcessing != nil {
		InternalSetValueByPath(toObject, []string{"mediaProcessing"}, fromMediaProcessing)
	}

	fromSpeechMetadata := InternalGetValueByPath(fromObject, []string{"speechMetadata"})
	if fromSpeechMetadata != nil {
		InternalSetValueByPath(toObject, []string{"speechMetadata"}, fromSpeechMetadata)
	}

	return toObject, nil
}

func partToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromMediaResolution := InternalGetValueByPath(fromObject, []string{"mediaResolution"})
	if fromMediaResolution != nil {
		InternalSetValueByPath(toObject, []string{"mediaResolution"}, fromMediaResolution)
	}

	fromCodeExecutionResult := InternalGetValueByPath(fromObject, []string{"codeExecutionResult"})
	if fromCodeExecutionResult != nil {
		InternalSetValueByPath(toObject, []string{"codeExecutionResult"}, fromCodeExecutionResult)
	}

	fromExecutableCode := InternalGetValueByPath(fromObject, []string{"executableCode"})
	if fromExecutableCode != nil {
		InternalSetValueByPath(toObject, []string{"executableCode"}, fromExecutableCode)
	}

	fromFileData := InternalGetValueByPath(fromObject, []string{"fileData"})
	if fromFileData != nil {
		InternalSetValueByPath(toObject, []string{"fileData"}, fromFileData)
	}

	fromFunctionCall := InternalGetValueByPath(fromObject, []string{"functionCall"})
	if fromFunctionCall != nil {
		InternalSetValueByPath(toObject, []string{"functionCall"}, fromFunctionCall)
	}

	fromFunctionResponse := InternalGetValueByPath(fromObject, []string{"functionResponse"})
	if fromFunctionResponse != nil {
		fromFunctionResponse, err = functionResponseToVertex(fromFunctionResponse.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"functionResponse"}, fromFunctionResponse)
	}

	fromInlineData := InternalGetValueByPath(fromObject, []string{"inlineData"})
	if fromInlineData != nil {
		InternalSetValueByPath(toObject, []string{"inlineData"}, fromInlineData)
	}

	fromText := InternalGetValueByPath(fromObject, []string{"text"})
	if fromText != nil {
		InternalSetValueByPath(toObject, []string{"text"}, fromText)
	}

	fromThought := InternalGetValueByPath(fromObject, []string{"thought"})
	if fromThought != nil {
		InternalSetValueByPath(toObject, []string{"thought"}, fromThought)
	}

	fromThoughtSignature := InternalGetValueByPath(fromObject, []string{"thoughtSignature"})
	if fromThoughtSignature != nil {
		InternalSetValueByPath(toObject, []string{"thoughtSignature"}, fromThoughtSignature)
	}

	fromVideoMetadata := InternalGetValueByPath(fromObject, []string{"videoMetadata"})
	if fromVideoMetadata != nil {
		InternalSetValueByPath(toObject, []string{"videoMetadata"}, fromVideoMetadata)
	}

	if InternalGetValueByPath(fromObject, []string{"toolCall"}) != nil {
		return nil, fmt.Errorf("toolCall parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"toolResponse"}) != nil {
		return nil, fmt.Errorf("toolResponse parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"partMetadata"}) != nil {
		return nil, fmt.Errorf("partMetadata parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	fromAudioTranscription := InternalGetValueByPath(fromObject, []string{"audioTranscription"})
	if fromAudioTranscription != nil {
		InternalSetValueByPath(toObject, []string{"audioTranscription"}, fromAudioTranscription)
	}

	fromMediaProcessing := InternalGetValueByPath(fromObject, []string{"mediaProcessing"})
	if fromMediaProcessing != nil {
		InternalSetValueByPath(toObject, []string{"mediaProcessing"}, fromMediaProcessing)
	}

	fromSpeechMetadata := InternalGetValueByPath(fromObject, []string{"speechMetadata"})
	if fromSpeechMetadata != nil {
		InternalSetValueByPath(toObject, []string{"speechMetadata"}, fromSpeechMetadata)
	}

	return toObject, nil
}

func productImageToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromProductImage := InternalGetValueByPath(fromObject, []string{"productImage"})
	if fromProductImage != nil {
		fromProductImage, err = imageToVertex(fromProductImage.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"image"}, fromProductImage)
	}

	return toObject, nil
}

func recontextImageConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromNumberOfImages := InternalGetValueByPath(fromObject, []string{"numberOfImages"})
	if fromNumberOfImages != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "sampleCount"}, fromNumberOfImages)
	}

	fromBaseSteps := InternalGetValueByPath(fromObject, []string{"baseSteps"})
	if fromBaseSteps != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "baseSteps"}, fromBaseSteps)
	}

	fromOutputGcsUri := InternalGetValueByPath(fromObject, []string{"outputGcsUri"})
	if fromOutputGcsUri != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "storageUri"}, fromOutputGcsUri)
	}

	fromSeed := InternalGetValueByPath(fromObject, []string{"seed"})
	if fromSeed != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "seed"}, fromSeed)
	}

	fromSafetyFilterLevel := InternalGetValueByPath(fromObject, []string{"safetyFilterLevel"})
	if fromSafetyFilterLevel != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "safetySetting"}, fromSafetyFilterLevel)
	}

	fromPersonGeneration := InternalGetValueByPath(fromObject, []string{"personGeneration"})
	if fromPersonGeneration != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "personGeneration"}, fromPersonGeneration)
	}

	fromAddWatermark := InternalGetValueByPath(fromObject, []string{"addWatermark"})
	if fromAddWatermark != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "addWatermark"}, fromAddWatermark)
	}

	fromOutputMimeType := InternalGetValueByPath(fromObject, []string{"outputMimeType"})
	if fromOutputMimeType != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "outputOptions", "mimeType"}, fromOutputMimeType)
	}

	fromOutputCompressionQuality := InternalGetValueByPath(fromObject, []string{"outputCompressionQuality"})
	if fromOutputCompressionQuality != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "outputOptions", "compressionQuality"}, fromOutputCompressionQuality)
	}

	fromEnhancePrompt := InternalGetValueByPath(fromObject, []string{"enhancePrompt"})
	if fromEnhancePrompt != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "enhancePrompt"}, fromEnhancePrompt)
	}

	fromLabels := InternalGetValueByPath(fromObject, []string{"labels"})
	if fromLabels != nil {
		InternalSetValueByPath(parentObject, []string{"labels"}, fromLabels)
	}

	return toObject, nil
}

func recontextImageParametersToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "model"}, fromModel)
	}

	fromSource := InternalGetValueByPath(fromObject, []string{"source"})
	if fromSource != nil {
		_, err = recontextImageSourceToVertex(fromSource.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		_, err = recontextImageConfigToVertex(fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	return toObject, nil
}

func recontextImageResponseFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromGeneratedImages := InternalGetValueByPath(fromObject, []string{"predictions"})
	if fromGeneratedImages != nil {
		fromGeneratedImages, err = InternalApplyConverterToSliceWithRoot(fromGeneratedImages.([]any), generatedImageFromVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"generatedImages"}, fromGeneratedImages)
	}

	return toObject, nil
}

func recontextImageSourceToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromPrompt := InternalGetValueByPath(fromObject, []string{"prompt"})
	if fromPrompt != nil {
		InternalSetValueByPath(parentObject, []string{"instances[0]", "prompt"}, fromPrompt)
	}

	fromPersonImage := InternalGetValueByPath(fromObject, []string{"personImage"})
	if fromPersonImage != nil {
		fromPersonImage, err = imageToVertex(fromPersonImage.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"instances[0]", "personImage", "image"}, fromPersonImage)
	}

	fromProductImages := InternalGetValueByPath(fromObject, []string{"productImages"})
	if fromProductImages != nil {
		fromProductImages, err = InternalApplyConverterToSliceWithRoot(fromProductImages.([]any), productImageToVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"instances[0]", "productImages"}, fromProductImages)
	}

	return toObject, nil
}

func referenceImageAPIToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromReferenceImage := InternalGetValueByPath(fromObject, []string{"referenceImage"})
	if fromReferenceImage != nil {
		fromReferenceImage, err = imageToVertex(fromReferenceImage.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"referenceImage"}, fromReferenceImage)
	}

	fromReferenceId := InternalGetValueByPath(fromObject, []string{"referenceId"})
	if fromReferenceId != nil {
		InternalSetValueByPath(toObject, []string{"referenceId"}, fromReferenceId)
	}

	fromReferenceType := InternalGetValueByPath(fromObject, []string{"referenceType"})
	if fromReferenceType != nil {
		InternalSetValueByPath(toObject, []string{"referenceType"}, fromReferenceType)
	}

	fromMaskImageConfig := InternalGetValueByPath(fromObject, []string{"maskImageConfig"})
	if fromMaskImageConfig != nil {
		fromMaskImageConfig, err = maskReferenceConfigToVertex(fromMaskImageConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"maskImageConfig"}, fromMaskImageConfig)
	}

	fromControlImageConfig := InternalGetValueByPath(fromObject, []string{"controlImageConfig"})
	if fromControlImageConfig != nil {
		fromControlImageConfig, err = controlReferenceConfigToVertex(fromControlImageConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"controlImageConfig"}, fromControlImageConfig)
	}

	fromStyleImageConfig := InternalGetValueByPath(fromObject, []string{"styleImageConfig"})
	if fromStyleImageConfig != nil {
		InternalSetValueByPath(toObject, []string{"styleImageConfig"}, fromStyleImageConfig)
	}

	fromSubjectImageConfig := InternalGetValueByPath(fromObject, []string{"subjectImageConfig"})
	if fromSubjectImageConfig != nil {
		InternalSetValueByPath(toObject, []string{"subjectImageConfig"}, fromSubjectImageConfig)
	}

	return toObject, nil
}

func replicatedVoiceConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromMimeType := InternalGetValueByPath(fromObject, []string{"mimeType"})
	if fromMimeType != nil {
		InternalSetValueByPath(toObject, []string{"mimeType"}, fromMimeType)
	}

	fromVoiceSampleAudio := InternalGetValueByPath(fromObject, []string{"voiceSampleAudio"})
	if fromVoiceSampleAudio != nil {
		InternalSetValueByPath(toObject, []string{"voiceSampleAudio"}, fromVoiceSampleAudio)
	}

	if InternalGetValueByPath(fromObject, []string{"consentAudio"}) != nil {
		return nil, fmt.Errorf("consentAudio parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	if InternalGetValueByPath(fromObject, []string{"voiceConsentSignature"}) != nil {
		return nil, fmt.Errorf("voiceConsentSignature parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	return toObject, nil
}

func safetyAttributesFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromCategories := InternalGetValueByPath(fromObject, []string{"safetyAttributes", "categories"})
	if fromCategories != nil {
		InternalSetValueByPath(toObject, []string{"categories"}, fromCategories)
	}

	fromScores := InternalGetValueByPath(fromObject, []string{"safetyAttributes", "scores"})
	if fromScores != nil {
		InternalSetValueByPath(toObject, []string{"scores"}, fromScores)
	}

	fromContentType := InternalGetValueByPath(fromObject, []string{"contentType"})
	if fromContentType != nil {
		InternalSetValueByPath(toObject, []string{"contentType"}, fromContentType)
	}

	return toObject, nil
}

func safetySettingToMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromCategory := InternalGetValueByPath(fromObject, []string{"category"})
	if fromCategory != nil {
		InternalSetValueByPath(toObject, []string{"category"}, fromCategory)
	}

	if InternalGetValueByPath(fromObject, []string{"method"}) != nil {
		return nil, fmt.Errorf("method parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	fromThreshold := InternalGetValueByPath(fromObject, []string{"threshold"})
	if fromThreshold != nil {
		InternalSetValueByPath(toObject, []string{"threshold"}, fromThreshold)
	}

	return toObject, nil
}

func scribbleImageToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromImage := InternalGetValueByPath(fromObject, []string{"image"})
	if fromImage != nil {
		fromImage, err = imageToVertex(fromImage.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"image"}, fromImage)
	}

	return toObject, nil
}

func segmentImageConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromMode := InternalGetValueByPath(fromObject, []string{"mode"})
	if fromMode != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "mode"}, fromMode)
	}

	fromMaxPredictions := InternalGetValueByPath(fromObject, []string{"maxPredictions"})
	if fromMaxPredictions != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "maxPredictions"}, fromMaxPredictions)
	}

	fromConfidenceThreshold := InternalGetValueByPath(fromObject, []string{"confidenceThreshold"})
	if fromConfidenceThreshold != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "confidenceThreshold"}, fromConfidenceThreshold)
	}

	fromMaskDilation := InternalGetValueByPath(fromObject, []string{"maskDilation"})
	if fromMaskDilation != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "maskDilation"}, fromMaskDilation)
	}

	fromBinaryColorThreshold := InternalGetValueByPath(fromObject, []string{"binaryColorThreshold"})
	if fromBinaryColorThreshold != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "binaryColorThreshold"}, fromBinaryColorThreshold)
	}

	fromLabels := InternalGetValueByPath(fromObject, []string{"labels"})
	if fromLabels != nil {
		InternalSetValueByPath(parentObject, []string{"labels"}, fromLabels)
	}

	return toObject, nil
}

func segmentImageParametersToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "model"}, fromModel)
	}

	fromSource := InternalGetValueByPath(fromObject, []string{"source"})
	if fromSource != nil {
		_, err = segmentImageSourceToVertex(fromSource.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		_, err = segmentImageConfigToVertex(fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	return toObject, nil
}

func segmentImageResponseFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromGeneratedMasks := InternalGetValueByPath(fromObject, []string{"predictions"})
	if fromGeneratedMasks != nil {
		fromGeneratedMasks, err = InternalApplyConverterToSliceWithRoot(fromGeneratedMasks.([]any), generatedImageMaskFromVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"generatedMasks"}, fromGeneratedMasks)
	}

	return toObject, nil
}

func segmentImageSourceToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromPrompt := InternalGetValueByPath(fromObject, []string{"prompt"})
	if fromPrompt != nil {
		InternalSetValueByPath(parentObject, []string{"instances[0]", "prompt"}, fromPrompt)
	}

	fromImage := InternalGetValueByPath(fromObject, []string{"image"})
	if fromImage != nil {
		fromImage, err = imageToVertex(fromImage.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"instances[0]", "image"}, fromImage)
	}

	fromScribbleImage := InternalGetValueByPath(fromObject, []string{"scribbleImage"})
	if fromScribbleImage != nil {
		fromScribbleImage, err = scribbleImageToVertex(fromScribbleImage.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(parentObject, []string{"instances[0]", "scribble"}, fromScribbleImage)
	}

	return toObject, nil
}

func speakerVoiceConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSpeaker := InternalGetValueByPath(fromObject, []string{"speaker"})
	if fromSpeaker != nil {
		InternalSetValueByPath(toObject, []string{"speaker"}, fromSpeaker)
	}

	fromVoiceConfig := InternalGetValueByPath(fromObject, []string{"voiceConfig"})
	if fromVoiceConfig != nil {
		fromVoiceConfig, err = voiceConfigToVertex(fromVoiceConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"voiceConfig"}, fromVoiceConfig)
	}

	return toObject, nil
}

func speechConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromVoiceConfig := InternalGetValueByPath(fromObject, []string{"voiceConfig"})
	if fromVoiceConfig != nil {
		fromVoiceConfig, err = voiceConfigToVertex(fromVoiceConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"voiceConfig"}, fromVoiceConfig)
	}

	fromLanguageCode := InternalGetValueByPath(fromObject, []string{"languageCode"})
	if fromLanguageCode != nil {
		InternalSetValueByPath(toObject, []string{"languageCode"}, fromLanguageCode)
	}

	fromMultiSpeakerVoiceConfig := InternalGetValueByPath(fromObject, []string{"multiSpeakerVoiceConfig"})
	if fromMultiSpeakerVoiceConfig != nil {
		fromMultiSpeakerVoiceConfig, err = multiSpeakerVoiceConfigToVertex(fromMultiSpeakerVoiceConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"multiSpeakerVoiceConfig"}, fromMultiSpeakerVoiceConfig)
	}

	return toObject, nil
}

func toolConfigToMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromRetrievalConfig := InternalGetValueByPath(fromObject, []string{"retrievalConfig"})
	if fromRetrievalConfig != nil {
		InternalSetValueByPath(toObject, []string{"retrievalConfig"}, fromRetrievalConfig)
	}

	fromFunctionCallingConfig := InternalGetValueByPath(fromObject, []string{"functionCallingConfig"})
	if fromFunctionCallingConfig != nil {
		fromFunctionCallingConfig, err = functionCallingConfigToMldev(fromFunctionCallingConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"functionCallingConfig"}, fromFunctionCallingConfig)
	}

	fromIncludeServerSideToolInvocations := InternalGetValueByPath(fromObject, []string{"includeServerSideToolInvocations"})
	if fromIncludeServerSideToolInvocations != nil {
		InternalSetValueByPath(toObject, []string{"includeServerSideToolInvocations"}, fromIncludeServerSideToolInvocations)
	}

	return toObject, nil
}

func toolConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromRetrievalConfig := InternalGetValueByPath(fromObject, []string{"retrievalConfig"})
	if fromRetrievalConfig != nil {
		InternalSetValueByPath(toObject, []string{"retrievalConfig"}, fromRetrievalConfig)
	}

	fromFunctionCallingConfig := InternalGetValueByPath(fromObject, []string{"functionCallingConfig"})
	if fromFunctionCallingConfig != nil {
		InternalSetValueByPath(toObject, []string{"functionCallingConfig"}, fromFunctionCallingConfig)
	}

	if InternalGetValueByPath(fromObject, []string{"includeServerSideToolInvocations"}) != nil {
		return nil, fmt.Errorf("includeServerSideToolInvocations parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	return toObject, nil
}

func toolToMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)
	if InternalGetValueByPath(fromObject, []string{"retrieval"}) != nil {
		return nil, fmt.Errorf("retrieval parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	fromComputerUse := InternalGetValueByPath(fromObject, []string{"computerUse"})
	if fromComputerUse != nil {
		InternalSetValueByPath(toObject, []string{"computerUse"}, fromComputerUse)
	}

	fromFileSearch := InternalGetValueByPath(fromObject, []string{"fileSearch"})
	if fromFileSearch != nil {
		InternalSetValueByPath(toObject, []string{"fileSearch"}, fromFileSearch)
	}

	fromGoogleSearch := InternalGetValueByPath(fromObject, []string{"googleSearch"})
	if fromGoogleSearch != nil {
		fromGoogleSearch, err = googleSearchToMldev(fromGoogleSearch.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"googleSearch"}, fromGoogleSearch)
	}

	fromGoogleMaps := InternalGetValueByPath(fromObject, []string{"googleMaps"})
	if fromGoogleMaps != nil {
		fromGoogleMaps, err = googleMapsToMldev(fromGoogleMaps.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"googleMaps"}, fromGoogleMaps)
	}

	fromCodeExecution := InternalGetValueByPath(fromObject, []string{"codeExecution"})
	if fromCodeExecution != nil {
		InternalSetValueByPath(toObject, []string{"codeExecution"}, fromCodeExecution)
	}

	if InternalGetValueByPath(fromObject, []string{"enterpriseWebSearch"}) != nil {
		return nil, fmt.Errorf("enterpriseWebSearch parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	fromFunctionDeclarations := InternalGetValueByPath(fromObject, []string{"functionDeclarations"})
	if fromFunctionDeclarations != nil {
		InternalSetValueByPath(toObject, []string{"functionDeclarations"}, fromFunctionDeclarations)
	}

	fromGoogleSearchRetrieval := InternalGetValueByPath(fromObject, []string{"googleSearchRetrieval"})
	if fromGoogleSearchRetrieval != nil {
		InternalSetValueByPath(toObject, []string{"googleSearchRetrieval"}, fromGoogleSearchRetrieval)
	}

	if InternalGetValueByPath(fromObject, []string{"parallelAiSearch"}) != nil {
		return nil, fmt.Errorf("parallelAiSearch parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	fromUrlContext := InternalGetValueByPath(fromObject, []string{"urlContext"})
	if fromUrlContext != nil {
		InternalSetValueByPath(toObject, []string{"urlContext"}, fromUrlContext)
	}

	fromMcpServers := InternalGetValueByPath(fromObject, []string{"mcpServers"})
	if fromMcpServers != nil {
		InternalSetValueByPath(toObject, []string{"mcpServers"}, fromMcpServers)
	}

	if InternalGetValueByPath(fromObject, []string{"exaAiSearch"}) != nil {
		return nil, fmt.Errorf("exaAiSearch parameter is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode.")
	}

	return toObject, nil
}

func toolToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromRetrieval := InternalGetValueByPath(fromObject, []string{"retrieval"})
	if fromRetrieval != nil {
		InternalSetValueByPath(toObject, []string{"retrieval"}, fromRetrieval)
	}

	fromComputerUse := InternalGetValueByPath(fromObject, []string{"computerUse"})
	if fromComputerUse != nil {
		InternalSetValueByPath(toObject, []string{"computerUse"}, fromComputerUse)
	}

	if InternalGetValueByPath(fromObject, []string{"fileSearch"}) != nil {
		return nil, fmt.Errorf("fileSearch parameter is only supported in Gemini Developer API mode, not in Gemini Enterprise Agent Platform mode.")
	}

	fromGoogleSearch := InternalGetValueByPath(fromObject, []string{"googleSearch"})
	if fromGoogleSearch != nil {
		InternalSetValueByPath(toObject, []string{"googleSearch"}, fromGoogleSearch)
	}

	fromGoogleMaps := InternalGetValueByPath(fromObject, []string{"googleMaps"})
	if fromGoogleMaps != nil {
		InternalSetValueByPath(toObject, []string{"googleMaps"}, fromGoogleMaps)
	}

	fromCodeExecution := InternalGetValueByPath(fromObject, []string{"codeExecution"})
	if fromCodeExecution != nil {
		InternalSetValueByPath(toObject, []string{"codeExecution"}, fromCodeExecution)
	}

	fromEnterpriseWebSearch := InternalGetValueByPath(fromObject, []string{"enterpriseWebSearch"})
	if fromEnterpriseWebSearch != nil {
		InternalSetValueByPath(toObject, []string{"enterpriseWebSearch"}, fromEnterpriseWebSearch)
	}

	fromFunctionDeclarations := InternalGetValueByPath(fromObject, []string{"functionDeclarations"})
	if fromFunctionDeclarations != nil {
		InternalSetValueByPath(toObject, []string{"functionDeclarations"}, fromFunctionDeclarations)
	}

	fromGoogleSearchRetrieval := InternalGetValueByPath(fromObject, []string{"googleSearchRetrieval"})
	if fromGoogleSearchRetrieval != nil {
		InternalSetValueByPath(toObject, []string{"googleSearchRetrieval"}, fromGoogleSearchRetrieval)
	}

	fromParallelAiSearch := InternalGetValueByPath(fromObject, []string{"parallelAiSearch"})
	if fromParallelAiSearch != nil {
		InternalSetValueByPath(toObject, []string{"parallelAiSearch"}, fromParallelAiSearch)
	}

	fromUrlContext := InternalGetValueByPath(fromObject, []string{"urlContext"})
	if fromUrlContext != nil {
		InternalSetValueByPath(toObject, []string{"urlContext"}, fromUrlContext)
	}

	fromMcpServers := InternalGetValueByPath(fromObject, []string{"mcpServers"})
	if fromMcpServers != nil {
		fromMcpServers, err = InternalApplyConverterToSliceWithRoot(fromMcpServers.([]any), mcpServerToVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"mcpServers"}, fromMcpServers)
	}

	fromExaAiSearch := InternalGetValueByPath(fromObject, []string{"exaAiSearch"})
	if fromExaAiSearch != nil {
		InternalSetValueByPath(toObject, []string{"exaAiSearch"}, fromExaAiSearch)
	}

	return toObject, nil
}

func tunedModelInfoFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromBaseModel := InternalGetValueByPath(fromObject, []string{"labels", "google-vertex-llm-tuning-base-model-id"})
	if fromBaseModel != nil {
		InternalSetValueByPath(toObject, []string{"baseModel"}, fromBaseModel)
	}

	fromCreateTime := InternalGetValueByPath(fromObject, []string{"createTime"})
	if fromCreateTime != nil {
		InternalSetValueByPath(toObject, []string{"createTime"}, fromCreateTime)
	}

	fromUpdateTime := InternalGetValueByPath(fromObject, []string{"updateTime"})
	if fromUpdateTime != nil {
		InternalSetValueByPath(toObject, []string{"updateTime"}, fromUpdateTime)
	}

	return toObject, nil
}

func updateModelConfigToMldev(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromDisplayName := InternalGetValueByPath(fromObject, []string{"displayName"})
	if fromDisplayName != nil {
		InternalSetValueByPath(parentObject, []string{"displayName"}, fromDisplayName)
	}

	fromDescription := InternalGetValueByPath(fromObject, []string{"description"})
	if fromDescription != nil {
		InternalSetValueByPath(parentObject, []string{"description"}, fromDescription)
	}

	fromDefaultCheckpointId := InternalGetValueByPath(fromObject, []string{"defaultCheckpointId"})
	if fromDefaultCheckpointId != nil {
		InternalSetValueByPath(parentObject, []string{"defaultCheckpointId"}, fromDefaultCheckpointId)
	}

	return toObject, nil
}

func updateModelConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromDisplayName := InternalGetValueByPath(fromObject, []string{"displayName"})
	if fromDisplayName != nil {
		InternalSetValueByPath(parentObject, []string{"displayName"}, fromDisplayName)
	}

	fromDescription := InternalGetValueByPath(fromObject, []string{"description"})
	if fromDescription != nil {
		InternalSetValueByPath(parentObject, []string{"description"}, fromDescription)
	}

	fromDefaultCheckpointId := InternalGetValueByPath(fromObject, []string{"defaultCheckpointId"})
	if fromDefaultCheckpointId != nil {
		InternalSetValueByPath(parentObject, []string{"defaultCheckpointId"}, fromDefaultCheckpointId)
	}

	return toObject, nil
}

func updateModelParametersToMldev(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "name"}, fromModel)
	}

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		_, err = updateModelConfigToMldev(fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	return toObject, nil
}

func updateModelParametersToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "model"}, fromModel)
	}

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		_, err = updateModelConfigToVertex(fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	return toObject, nil
}

func upscaleImageAPIConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromOutputGcsUri := InternalGetValueByPath(fromObject, []string{"outputGcsUri"})
	if fromOutputGcsUri != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "storageUri"}, fromOutputGcsUri)
	}

	fromSafetyFilterLevel := InternalGetValueByPath(fromObject, []string{"safetyFilterLevel"})
	if fromSafetyFilterLevel != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "safetySetting"}, fromSafetyFilterLevel)
	}

	fromPersonGeneration := InternalGetValueByPath(fromObject, []string{"personGeneration"})
	if fromPersonGeneration != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "personGeneration"}, fromPersonGeneration)
	}

	fromIncludeRaiReason := InternalGetValueByPath(fromObject, []string{"includeRaiReason"})
	if fromIncludeRaiReason != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "includeRaiReason"}, fromIncludeRaiReason)
	}

	fromOutputMimeType := InternalGetValueByPath(fromObject, []string{"outputMimeType"})
	if fromOutputMimeType != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "outputOptions", "mimeType"}, fromOutputMimeType)
	}

	fromOutputCompressionQuality := InternalGetValueByPath(fromObject, []string{"outputCompressionQuality"})
	if fromOutputCompressionQuality != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "outputOptions", "compressionQuality"}, fromOutputCompressionQuality)
	}

	fromEnhanceInputImage := InternalGetValueByPath(fromObject, []string{"enhanceInputImage"})
	if fromEnhanceInputImage != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "upscaleConfig", "enhanceInputImage"}, fromEnhanceInputImage)
	}

	fromImagePreservationFactor := InternalGetValueByPath(fromObject, []string{"imagePreservationFactor"})
	if fromImagePreservationFactor != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "upscaleConfig", "imagePreservationFactor"}, fromImagePreservationFactor)
	}

	fromLabels := InternalGetValueByPath(fromObject, []string{"labels"})
	if fromLabels != nil {
		InternalSetValueByPath(parentObject, []string{"labels"}, fromLabels)
	}

	fromNumberOfImages := InternalGetValueByPath(fromObject, []string{"numberOfImages"})
	if fromNumberOfImages != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "sampleCount"}, fromNumberOfImages)
	}

	fromMode := InternalGetValueByPath(fromObject, []string{"mode"})
	if fromMode != nil {
		InternalSetValueByPath(parentObject, []string{"parameters", "mode"}, fromMode)
	}

	return toObject, nil
}

func upscaleImageAPIParametersToVertex(ac *InternalAPIClient, fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromModel := InternalGetValueByPath(fromObject, []string{"model"})
	if fromModel != nil {
		fromModel, err = InternalTModel(ac, fromModel)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_url", "model"}, fromModel)
	}

	fromImage := InternalGetValueByPath(fromObject, []string{"image"})
	if fromImage != nil {
		fromImage, err = imageToVertex(fromImage.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"instances[0]", "image"}, fromImage)
	}

	fromUpscaleFactor := InternalGetValueByPath(fromObject, []string{"upscaleFactor"})
	if fromUpscaleFactor != nil {
		InternalSetValueByPath(toObject, []string{"parameters", "upscaleConfig", "upscaleFactor"}, fromUpscaleFactor)
	}

	fromConfig := InternalGetValueByPath(fromObject, []string{"config"})
	if fromConfig != nil {
		_, err = upscaleImageAPIConfigToVertex(fromConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}
	}

	return toObject, nil
}

func upscaleImageResponseFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromSdkHttpResponse := InternalGetValueByPath(fromObject, []string{"sdkHttpResponse"})
	if fromSdkHttpResponse != nil {
		InternalSetValueByPath(toObject, []string{"sdkHttpResponse"}, fromSdkHttpResponse)
	}

	fromGeneratedImages := InternalGetValueByPath(fromObject, []string{"predictions"})
	if fromGeneratedImages != nil {
		fromGeneratedImages, err = InternalApplyConverterToSliceWithRoot(fromGeneratedImages.([]any), generatedImageFromVertex, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"generatedImages"}, fromGeneratedImages)
	}

	return toObject, nil
}

func usageMetadataFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromPromptTokenCount := InternalGetValueByPath(fromObject, []string{"promptTokenCount"})
	if fromPromptTokenCount != nil {
		InternalSetValueByPath(toObject, []string{"promptTokenCount"}, fromPromptTokenCount)
	}

	fromCachedContentTokenCount := InternalGetValueByPath(fromObject, []string{"cachedContentTokenCount"})
	if fromCachedContentTokenCount != nil {
		InternalSetValueByPath(toObject, []string{"cachedContentTokenCount"}, fromCachedContentTokenCount)
	}

	fromResponseTokenCount := InternalGetValueByPath(fromObject, []string{"candidatesTokenCount"})
	if fromResponseTokenCount != nil {
		InternalSetValueByPath(toObject, []string{"responseTokenCount"}, fromResponseTokenCount)
	}

	fromToolUsePromptTokenCount := InternalGetValueByPath(fromObject, []string{"toolUsePromptTokenCount"})
	if fromToolUsePromptTokenCount != nil {
		InternalSetValueByPath(toObject, []string{"toolUsePromptTokenCount"}, fromToolUsePromptTokenCount)
	}

	fromThoughtsTokenCount := InternalGetValueByPath(fromObject, []string{"thoughtsTokenCount"})
	if fromThoughtsTokenCount != nil {
		InternalSetValueByPath(toObject, []string{"thoughtsTokenCount"}, fromThoughtsTokenCount)
	}

	fromTotalTokenCount := InternalGetValueByPath(fromObject, []string{"totalTokenCount"})
	if fromTotalTokenCount != nil {
		InternalSetValueByPath(toObject, []string{"totalTokenCount"}, fromTotalTokenCount)
	}

	fromPromptTokensDetails := InternalGetValueByPath(fromObject, []string{"promptTokensDetails"})
	if fromPromptTokensDetails != nil {
		InternalSetValueByPath(toObject, []string{"promptTokensDetails"}, fromPromptTokensDetails)
	}

	fromCacheTokensDetails := InternalGetValueByPath(fromObject, []string{"cacheTokensDetails"})
	if fromCacheTokensDetails != nil {
		InternalSetValueByPath(toObject, []string{"cacheTokensDetails"}, fromCacheTokensDetails)
	}

	fromResponseTokensDetails := InternalGetValueByPath(fromObject, []string{"candidatesTokensDetails"})
	if fromResponseTokensDetails != nil {
		InternalSetValueByPath(toObject, []string{"responseTokensDetails"}, fromResponseTokensDetails)
	}

	fromToolUsePromptTokensDetails := InternalGetValueByPath(fromObject, []string{"toolUsePromptTokensDetails"})
	if fromToolUsePromptTokensDetails != nil {
		InternalSetValueByPath(toObject, []string{"toolUsePromptTokensDetails"}, fromToolUsePromptTokensDetails)
	}

	fromTrafficType := InternalGetValueByPath(fromObject, []string{"trafficType"})
	if fromTrafficType != nil {
		InternalSetValueByPath(toObject, []string{"trafficType"}, fromTrafficType)
	}

	return toObject, nil
}

func videoFromVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromUri := InternalGetValueByPath(fromObject, []string{"gcsUri"})
	if fromUri != nil {
		InternalSetValueByPath(toObject, []string{"uri"}, fromUri)
	}

	fromVideoBytes := InternalGetValueByPath(fromObject, []string{"bytesBase64Encoded"})
	if fromVideoBytes != nil {
		fromVideoBytes, err = InternalTBytes(fromVideoBytes)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"videoBytes"}, fromVideoBytes)
	}

	fromMimeType := InternalGetValueByPath(fromObject, []string{"mimeType"})
	if fromMimeType != nil {
		InternalSetValueByPath(toObject, []string{"mimeType"}, fromMimeType)
	}

	return toObject, nil
}

func videoGenerationMaskToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromImage := InternalGetValueByPath(fromObject, []string{"image"})
	if fromImage != nil {
		fromImage, err = imageToVertex(fromImage.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"_self"}, fromImage)
	}

	fromMaskMode := InternalGetValueByPath(fromObject, []string{"maskMode"})
	if fromMaskMode != nil {
		InternalSetValueByPath(toObject, []string{"maskMode"}, fromMaskMode)
	}

	return toObject, nil
}

func videoGenerationReferenceImageToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromImage := InternalGetValueByPath(fromObject, []string{"image"})
	if fromImage != nil {
		fromImage, err = imageToVertex(fromImage.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"image"}, fromImage)
	}

	fromReferenceType := InternalGetValueByPath(fromObject, []string{"referenceType"})
	if fromReferenceType != nil {
		InternalSetValueByPath(toObject, []string{"referenceType"}, fromReferenceType)
	}

	return toObject, nil
}

func videoToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromUri := InternalGetValueByPath(fromObject, []string{"uri"})
	if fromUri != nil {
		InternalSetValueByPath(toObject, []string{"gcsUri"}, fromUri)
	}

	fromVideoBytes := InternalGetValueByPath(fromObject, []string{"videoBytes"})
	if fromVideoBytes != nil {
		fromVideoBytes, err = InternalTBytes(fromVideoBytes)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"bytesBase64Encoded"}, fromVideoBytes)
	}

	fromMimeType := InternalGetValueByPath(fromObject, []string{"mimeType"})
	if fromMimeType != nil {
		InternalSetValueByPath(toObject, []string{"mimeType"}, fromMimeType)
	}

	return toObject, nil
}

func voiceConfigToVertex(fromObject map[string]any, parentObject map[string]any, rootObject map[string]any) (toObject map[string]any, err error) {
	toObject = make(map[string]any)

	fromReplicatedVoiceConfig := InternalGetValueByPath(fromObject, []string{"replicatedVoiceConfig"})
	if fromReplicatedVoiceConfig != nil {
		fromReplicatedVoiceConfig, err = replicatedVoiceConfigToVertex(fromReplicatedVoiceConfig.(map[string]any), toObject, rootObject)
		if err != nil {
			return nil, err
		}

		InternalSetValueByPath(toObject, []string{"replicatedVoiceConfig"}, fromReplicatedVoiceConfig)
	}

	fromPrebuiltVoiceConfig := InternalGetValueByPath(fromObject, []string{"prebuiltVoiceConfig"})
	if fromPrebuiltVoiceConfig != nil {
		InternalSetValueByPath(toObject, []string{"prebuiltVoiceConfig"}, fromPrebuiltVoiceConfig)
	}

	fromVoice := InternalGetValueByPath(fromObject, []string{"voice"})
	if fromVoice != nil {
		InternalSetValueByPath(toObject, []string{"voice"}, fromVoice)
	}

	return toObject, nil
}

// Models provides methods for interacting with the available language models.
// You don't need to initiate this struct. Create a client instance via NewClient, and
// then access Models through client.Models field.
type Models struct {
	apiClient *InternalAPIClient
}

func (m Models) generateContent(ctx context.Context, model string, contents []*Content, config *GenerateContentConfig) (*GenerateContentResponse, error) {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"model": model, "contents": contents, "config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var response = new(GenerateContentResponse)
	var responseMap map[string]any
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = generateContentParametersToVertex
		fromConverter = generateContentResponseFromVertex
	} else {
		toConverter = generateContentParametersToMldev
		fromConverter = generateContentResponseFromMldev
	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return nil, err
	}

	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	path, err = InternalFormatMap("{model}:generateContent", urlParams)
	if err != nil {
		return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
	}
	if _, ok := body["_query"]; ok {
		query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
		if err != nil {
			return nil, err
		}
		path += "?" + query
		delete(body, "_query")
	}
	responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodPost, body, httpOptions)
	if err != nil {
		return nil, err
	}
	if fromConverter != nil {
		responseMap, err = fromConverter(responseMap, nil, parameterMap)
	}
	if err != nil {
		return nil, err
	}
	err = InternalMapToStruct(responseMap, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}

func (m Models) generateContentStream(ctx context.Context, model string, contents []*Content, config *GenerateContentConfig) iter.Seq2[*GenerateContentResponse, error] {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"model": model, "contents": contents, "config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var rs responseStream[GenerateContentResponse]
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = generateContentParametersToVertex
		fromConverter = generateContentResponseFromVertex
	} else {
		toConverter = generateContentParametersToMldev
		fromConverter = generateContentResponseFromMldev
	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return yieldErrorAndEndIterator[GenerateContentResponse](err)
	}
	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	path, err = InternalFormatMap("{model}:streamGenerateContent?alt=sse", urlParams)
	if err != nil {
		return yieldErrorAndEndIterator[GenerateContentResponse](fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err))
	}
	delete(body, "_url")
	delete(body, "config")
	err = sendStreamRequest(ctx, m.apiClient, path, http.MethodPost, body, httpOptions, &rs)
	if err != nil {
		return yieldErrorAndEndIterator[GenerateContentResponse](err)
	}
	return iterateResponseStream(&rs, func(responseMap map[string]any) (*GenerateContentResponse, error) {
		responseMap, err := fromConverter(responseMap, nil, parameterMap)
		if err != nil {
			return nil, err
		}
		var response = new(GenerateContentResponse)
		err = InternalMapToStruct(responseMap, response)
		if err != nil {
			return nil, err
		}
		return response, nil
	})
}

// EmbedContent generates embeddings for the provided contents using the specified model.
func (m Models) embedContent(ctx context.Context, model string, contents []*Content, content *Content, embeddingApiType *EmbeddingAPIType, config *EmbedContentConfig) (*EmbedContentResponse, error) {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"model": model, "contents": contents, "content": content, "embeddingApiType": embeddingApiType, "config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var response = new(EmbedContentResponse)
	var responseMap map[string]any
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = embedContentParametersPrivateToVertex
		fromConverter = embedContentResponseFromVertex
	} else {
		toConverter = embedContentParametersPrivateToMldev
		fromConverter = embedContentResponseFromMldev
	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return nil, err
	}

	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		if tIsVertexEmbedContentModel(parameterMap["model"].(string)) {
			path, err = InternalFormatMap("{model}:embedContent", urlParams)
		} else {
			path, err = InternalFormatMap("{model}:predict", urlParams)
		}
	} else {
		path, err = InternalFormatMap("{model}:batchEmbedContents", urlParams)
	}
	if err != nil {
		return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
	}
	if _, ok := body["_query"]; ok {
		query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
		if err != nil {
			return nil, err
		}
		path += "?" + query
		delete(body, "_query")
	}
	responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodPost, body, httpOptions)
	if err != nil {
		return nil, err
	}
	if fromConverter != nil {
		responseMap, err = fromConverter(responseMap, nil, parameterMap)
	}
	if err != nil {
		return nil, err
	}
	err = InternalMapToStruct(responseMap, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}

// generateImages private method for generating images.
func (m Models) generateImages(ctx context.Context, model string, prompt string, config *GenerateImagesConfig) (*GenerateImagesResponse, error) {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"model": model, "prompt": prompt, "config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var response = new(GenerateImagesResponse)
	var responseMap map[string]any
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = generateImagesParametersToVertex
		fromConverter = generateImagesResponseFromVertex
	} else {

		return nil, fmt.Errorf("method GenerateImages is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode. You can choose to use Gemini Enterprise Agent Platform by setting ClientConfig.Backend to BackendEnterprise.")

	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return nil, err
	}

	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		path, err = InternalFormatMap("{model}:predict", urlParams)
	} else {
		path, err = InternalFormatMap("None", urlParams)
	}
	if err != nil {
		return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
	}
	if _, ok := body["_query"]; ok {
		query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
		if err != nil {
			return nil, err
		}
		path += "?" + query
		delete(body, "_query")
	}
	responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodPost, body, httpOptions)
	if err != nil {
		return nil, err
	}
	if fromConverter != nil {
		responseMap, err = fromConverter(responseMap, nil, parameterMap)
	}
	if err != nil {
		return nil, err
	}
	err = InternalMapToStruct(responseMap, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}

// editImage private method for editing an image.
func (m Models) editImage(ctx context.Context, model string, prompt string, referenceImages []*referenceImageAPI, config *EditImageConfig) (*EditImageResponse, error) {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"model": model, "prompt": prompt, "referenceImages": referenceImages, "config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var response = new(EditImageResponse)
	var responseMap map[string]any
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = editImageParametersToVertex
		fromConverter = editImageResponseFromVertex
	} else {

		return nil, fmt.Errorf("method EditImage is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode. You can choose to use Gemini Enterprise Agent Platform by setting ClientConfig.Backend to BackendEnterprise.")

	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return nil, err
	}

	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		path, err = InternalFormatMap("{model}:predict", urlParams)
	} else {
		path, err = InternalFormatMap("None", urlParams)
	}
	if err != nil {
		return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
	}
	if _, ok := body["_query"]; ok {
		query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
		if err != nil {
			return nil, err
		}
		path += "?" + query
		delete(body, "_query")
	}
	responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodPost, body, httpOptions)
	if err != nil {
		return nil, err
	}
	if fromConverter != nil {
		responseMap, err = fromConverter(responseMap, nil, parameterMap)
	}
	if err != nil {
		return nil, err
	}
	err = InternalMapToStruct(responseMap, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}

// upscaleImage private method for upscaling an image.
func (m Models) upscaleImage(ctx context.Context, model string, image *Image, upscaleFactor string, config *upscaleImageAPIConfig) (*UpscaleImageResponse, error) {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"model": model, "image": image, "upscaleFactor": upscaleFactor, "config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var response = new(UpscaleImageResponse)
	var responseMap map[string]any
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = upscaleImageAPIParametersToVertex
		fromConverter = upscaleImageResponseFromVertex
	} else {

		return nil, fmt.Errorf("method UpscaleImage is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode. You can choose to use Gemini Enterprise Agent Platform by setting ClientConfig.Backend to BackendEnterprise.")

	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return nil, err
	}

	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		path, err = InternalFormatMap("{model}:predict", urlParams)
	} else {
		path, err = InternalFormatMap("None", urlParams)
	}
	if err != nil {
		return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
	}
	if _, ok := body["_query"]; ok {
		query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
		if err != nil {
			return nil, err
		}
		path += "?" + query
		delete(body, "_query")
	}
	responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodPost, body, httpOptions)
	if err != nil {
		return nil, err
	}
	if fromConverter != nil {
		responseMap, err = fromConverter(responseMap, nil, parameterMap)
	}
	if err != nil {
		return nil, err
	}
	err = InternalMapToStruct(responseMap, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}

// RecontextImage recontextualizes an image.
// There is one type of recontextualization currently supported:
// 1) Virtual Try-On: Generate images of persons modeling fashion products.
func (m Models) RecontextImage(ctx context.Context, model string, source *RecontextImageSource, config *RecontextImageConfig) (*RecontextImageResponse, error) {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"model": model, "source": source, "config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var response = new(RecontextImageResponse)
	var responseMap map[string]any
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = recontextImageParametersToVertex
		fromConverter = recontextImageResponseFromVertex
	} else {

		return nil, fmt.Errorf("method RecontextImage is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode. You can choose to use Gemini Enterprise Agent Platform by setting ClientConfig.Backend to BackendEnterprise.")

	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return nil, err
	}

	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		path, err = InternalFormatMap("{model}:predict", urlParams)
	} else {
		path, err = InternalFormatMap("None", urlParams)
	}
	if err != nil {
		return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
	}
	if _, ok := body["_query"]; ok {
		query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
		if err != nil {
			return nil, err
		}
		path += "?" + query
		delete(body, "_query")
	}
	responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodPost, body, httpOptions)
	if err != nil {
		return nil, err
	}
	if fromConverter != nil {
		responseMap, err = fromConverter(responseMap, nil, parameterMap)
	}
	if err != nil {
		return nil, err
	}
	err = InternalMapToStruct(responseMap, response)
	if err != nil {
		return nil, err
	}

	if field, ok := reflect.TypeOf(response).Elem().FieldByName("SDKHTTPResponse"); ok {
		{
			if reflect.ValueOf(response).Elem().FieldByName("SDKHTTPResponse").IsValid() {
				{
					reflect.ValueOf(response).Elem().FieldByName("SDKHTTPResponse").Set(reflect.Zero(field.Type))
				}
			}
		}
	}

	return response, nil
}

// SegmentImage segments an image, creating a mask of a specified area.
func (m Models) SegmentImage(ctx context.Context, model string, source *SegmentImageSource, config *SegmentImageConfig) (*SegmentImageResponse, error) {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"model": model, "source": source, "config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var response = new(SegmentImageResponse)
	var responseMap map[string]any
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = segmentImageParametersToVertex
		fromConverter = segmentImageResponseFromVertex
	} else {

		return nil, fmt.Errorf("method SegmentImage is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode. You can choose to use Gemini Enterprise Agent Platform by setting ClientConfig.Backend to BackendEnterprise.")

	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return nil, err
	}

	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		path, err = InternalFormatMap("{model}:predict", urlParams)
	} else {
		path, err = InternalFormatMap("None", urlParams)
	}
	if err != nil {
		return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
	}
	if _, ok := body["_query"]; ok {
		query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
		if err != nil {
			return nil, err
		}
		path += "?" + query
		delete(body, "_query")
	}
	responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodPost, body, httpOptions)
	if err != nil {
		return nil, err
	}
	if fromConverter != nil {
		responseMap, err = fromConverter(responseMap, nil, parameterMap)
	}
	if err != nil {
		return nil, err
	}
	err = InternalMapToStruct(responseMap, response)
	if err != nil {
		return nil, err
	}

	if field, ok := reflect.TypeOf(response).Elem().FieldByName("SDKHTTPResponse"); ok {
		{
			if reflect.ValueOf(response).Elem().FieldByName("SDKHTTPResponse").IsValid() {
				{
					reflect.ValueOf(response).Elem().FieldByName("SDKHTTPResponse").Set(reflect.Zero(field.Type))
				}
			}
		}
	}

	return response, nil
}

// Get retrieves a specific model resource by its name.
func (m Models) Get(ctx context.Context, model string, config *GetModelConfig) (*Model, error) {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"model": model, "config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var response = new(Model)
	var responseMap map[string]any
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = getModelParametersToVertex
		fromConverter = modelFromVertex
	} else {
		toConverter = getModelParametersToMldev
		fromConverter = modelFromMldev
	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return nil, err
	}

	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	path, err = InternalFormatMap("{name}", urlParams)
	if err != nil {
		return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
	}
	if _, ok := body["_query"]; ok {
		query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
		if err != nil {
			return nil, err
		}
		path += "?" + query
		delete(body, "_query")
	}
	responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodGet, body, httpOptions)
	if err != nil {
		return nil, err
	}
	if fromConverter != nil {
		responseMap, err = fromConverter(responseMap, nil, parameterMap)
	}
	if err != nil {
		return nil, err
	}
	err = InternalMapToStruct(responseMap, response)
	if err != nil {
		return nil, err
	}

	if field, ok := reflect.TypeOf(response).Elem().FieldByName("SDKHTTPResponse"); ok {
		{
			if reflect.ValueOf(response).Elem().FieldByName("SDKHTTPResponse").IsValid() {
				{
					reflect.ValueOf(response).Elem().FieldByName("SDKHTTPResponse").Set(reflect.Zero(field.Type))
				}
			}
		}
	}

	return response, nil
}

func (m Models) list(ctx context.Context, config *ListModelsConfig) (*ListModelsResponse, error) {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var response = new(ListModelsResponse)
	var responseMap map[string]any
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = listModelsParametersToVertex
		fromConverter = listModelsResponseFromVertex
	} else {
		toConverter = listModelsParametersToMldev
		fromConverter = listModelsResponseFromMldev
	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return nil, err
	}

	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	path, err = InternalFormatMap("{models_url}", urlParams)
	if err != nil {
		return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
	}
	if _, ok := body["_query"]; ok {
		if body["_query"].(map[string]any)["filter"] != nil {
			filter := body["_query"].(map[string]any)["filter"].(string)
			delete(body["_query"].(map[string]any), "filter")
			query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
			if err != nil {
				return nil, err
			}
			if query != "" {
				filter += "&"
			}
			path += "?filter=" + filter + query
		} else {
			query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
			if err != nil {
				return nil, err
			}
			path += "?" + query
		}
		delete(body, "_query")
	}
	responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodGet, body, httpOptions)
	if err != nil {
		return nil, err
	}
	if fromConverter != nil {
		responseMap, err = fromConverter(responseMap, nil, parameterMap)
	}
	if err != nil {
		return nil, err
	}
	err = InternalMapToStruct(responseMap, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}

// Update updates a specific model resource.
func (m Models) Update(ctx context.Context, model string, config *UpdateModelConfig) (*Model, error) {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"model": model, "config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var response = new(Model)
	var responseMap map[string]any
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = updateModelParametersToVertex
		fromConverter = modelFromVertex
	} else {
		toConverter = updateModelParametersToMldev
		fromConverter = modelFromMldev
	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return nil, err
	}

	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		path, err = InternalFormatMap("{model}", urlParams)
	} else {
		path, err = InternalFormatMap("{name}", urlParams)
	}
	if err != nil {
		return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
	}
	if _, ok := body["_query"]; ok {
		query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
		if err != nil {
			return nil, err
		}
		path += "?" + query
		delete(body, "_query")
	}
	responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodPatch, body, httpOptions)
	if err != nil {
		return nil, err
	}
	if fromConverter != nil {
		responseMap, err = fromConverter(responseMap, nil, parameterMap)
	}
	if err != nil {
		return nil, err
	}
	err = InternalMapToStruct(responseMap, response)
	if err != nil {
		return nil, err
	}

	if field, ok := reflect.TypeOf(response).Elem().FieldByName("SDKHTTPResponse"); ok {
		{
			if reflect.ValueOf(response).Elem().FieldByName("SDKHTTPResponse").IsValid() {
				{
					reflect.ValueOf(response).Elem().FieldByName("SDKHTTPResponse").Set(reflect.Zero(field.Type))
				}
			}
		}
	}

	return response, nil
}

// Delete deletes a specific model resource by its name.
func (m Models) Delete(ctx context.Context, model string, config *DeleteModelConfig) (*DeleteModelResponse, error) {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"model": model, "config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var response = new(DeleteModelResponse)
	var responseMap map[string]any
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = deleteModelParametersToVertex
		fromConverter = deleteModelResponseFromVertex
	} else {
		toConverter = deleteModelParametersToMldev
		fromConverter = deleteModelResponseFromMldev
	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return nil, err
	}

	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	path, err = InternalFormatMap("{name}", urlParams)
	if err != nil {
		return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
	}
	if _, ok := body["_query"]; ok {
		query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
		if err != nil {
			return nil, err
		}
		path += "?" + query
		delete(body, "_query")
	}
	responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodDelete, body, httpOptions)
	if err != nil {
		return nil, err
	}
	if fromConverter != nil {
		responseMap, err = fromConverter(responseMap, nil, parameterMap)
	}
	if err != nil {
		return nil, err
	}
	err = InternalMapToStruct(responseMap, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}

// CountTokens counts the number of tokens in the provided contents.
func (m Models) CountTokens(ctx context.Context, model string, contents []*Content, config *CountTokensConfig) (*CountTokensResponse, error) {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"model": model, "contents": contents, "config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var response = new(CountTokensResponse)
	var responseMap map[string]any
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = countTokensParametersToVertex
		fromConverter = countTokensResponseFromVertex
	} else {
		toConverter = countTokensParametersToMldev
		fromConverter = countTokensResponseFromMldev
	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return nil, err
	}

	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	path, err = InternalFormatMap("{model}:countTokens", urlParams)
	if err != nil {
		return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
	}
	if _, ok := body["_query"]; ok {
		query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
		if err != nil {
			return nil, err
		}
		path += "?" + query
		delete(body, "_query")
	}
	responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodPost, body, httpOptions)
	if err != nil {
		return nil, err
	}
	if fromConverter != nil {
		responseMap, err = fromConverter(responseMap, nil, parameterMap)
	}
	if err != nil {
		return nil, err
	}
	err = InternalMapToStruct(responseMap, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}

// ComputeTokens computes the number of tokens for the provided contents.
func (m Models) ComputeTokens(ctx context.Context, model string, contents []*Content, config *ComputeTokensConfig) (*ComputeTokensResponse, error) {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"model": model, "contents": contents, "config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var response = new(ComputeTokensResponse)
	var responseMap map[string]any
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = computeTokensParametersToVertex
		fromConverter = computeTokensResponseFromVertex
	} else {

		return nil, fmt.Errorf("method ComputeTokens is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode. You can choose to use Gemini Enterprise Agent Platform by setting ClientConfig.Backend to BackendEnterprise.")

	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return nil, err
	}

	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		path, err = InternalFormatMap("{model}:computeTokens", urlParams)
	} else {
		path, err = InternalFormatMap("None", urlParams)
	}
	if err != nil {
		return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
	}
	if _, ok := body["_query"]; ok {
		query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
		if err != nil {
			return nil, err
		}
		path += "?" + query
		delete(body, "_query")
	}
	responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodPost, body, httpOptions)
	if err != nil {
		return nil, err
	}
	if fromConverter != nil {
		responseMap, err = fromConverter(responseMap, nil, parameterMap)
	}
	if err != nil {
		return nil, err
	}
	err = InternalMapToStruct(responseMap, response)
	if err != nil {
		return nil, err
	}

	return response, nil
}

// generateVideos private method for generating videos.
func (m Models) generateVideos(ctx context.Context, model string, prompt *string, image *Image, video *Video, source *GenerateVideosSource, config *GenerateVideosConfig) (*GenerateVideosOperation, error) {
	parameterMap := make(map[string]any)

	kwargs := map[string]any{"model": model, "prompt": prompt, "image": image, "video": video, "source": source, "config": config}
	InternalDeepMarshal(kwargs, &parameterMap)

	var httpOptions *HTTPOptions
	if config == nil || config.HTTPOptions == nil {
		httpOptions = &HTTPOptions{}
	} else {
		httpOptions = config.HTTPOptions
	}
	if httpOptions.Headers == nil {
		httpOptions.Headers = http.Header{}
	}
	var response = new(GenerateVideosOperation)
	var responseMap map[string]any
	var fromConverter func(map[string]any, map[string]any, map[string]any) (map[string]any, error)
	var toConverter func(*InternalAPIClient, map[string]any, map[string]any, map[string]any) (map[string]any, error)
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		toConverter = generateVideosParametersToVertex
		fromConverter = generateVideosOperationFromVertex
	} else {

		return nil, fmt.Errorf("method GenerateVideos is only supported in Gemini Enterprise Agent Platform mode, not in Gemini Developer API mode. You can choose to use Gemini Enterprise Agent Platform by setting ClientConfig.Backend to BackendEnterprise.")

	}

	body, err := toConverter(m.apiClient, parameterMap, nil, parameterMap)
	if err != nil {
		return nil, err
	}

	var path string
	var urlParams map[string]any
	if _, ok := body["_url"]; ok {
		urlParams = body["_url"].(map[string]any)
		delete(body, "_url")
	}
	if m.apiClient.ClientConfig().Backend == BackendVertexAI {
		path, err = InternalFormatMap("{model}:predictLongRunning", urlParams)
	} else {
		path, err = InternalFormatMap("None", urlParams)
	}
	if err != nil {
		return nil, fmt.Errorf("invalid url params: %#v.\n%w", urlParams, err)
	}
	if _, ok := body["_query"]; ok {
		query, err := InternalCreateURLQuery(body["_query"].(map[string]any))
		if err != nil {
			return nil, err
		}
		path += "?" + query
		delete(body, "_query")
	}
	responseMap, err = sendRequest(ctx, m.apiClient, path, http.MethodPost, body, httpOptions)
	if err != nil {
		return nil, err
	}
	if fromConverter != nil {
		responseMap, err = fromConverter(responseMap, nil, parameterMap)
	}
	if err != nil {
		return nil, err
	}
	err = InternalMapToStruct(responseMap, response)
	if err != nil {
		return nil, err
	}

	if field, ok := reflect.TypeOf(response).Elem().FieldByName("SDKHTTPResponse"); ok {
		{
			if reflect.ValueOf(response).Elem().FieldByName("SDKHTTPResponse").IsValid() {
				{
					reflect.ValueOf(response).Elem().FieldByName("SDKHTTPResponse").Set(reflect.Zero(field.Type))
				}
			}
		}
	}

	return response, nil
}

var deprecationWarningEditImage sync.Once
var deprecationWarningGenerateImages sync.Once
var breakingChangeWarningGenerateVideosNotSource sync.Once
var deprecationWarningGenerateVideosFromSource sync.Once

// GenerateContent generates content based on the provided model, contents, and configuration.
//
// A response that stops before the model finishes is continued automatically: the same request is
// sent again with the response's continuation token until the model finishes. The responses are
// returned merged into one, with their parts concatenated and their usage metadata summed. Each
// request is billed, including any that succeeded before a later one failed. Set
// [GenerateContentConfig.AutomaticContinuation] to false to turn this off.
func (m Models) GenerateContent(ctx context.Context, model string, contents []*Content, config *GenerateContentConfig) (*GenerateContentResponse, error) {
	if config != nil {
		config.setDefaults()
	}
	enableContinuation := shouldEnableAutomaticContinuation(config)
	response, err := m.generateContent(ctx, model, contents, config)
	if err != nil {
		return nil, err
	}
	if !enableContinuation {
		return response, nil
	}

	hopResponses := []*GenerateContentResponse{response}
	for {
		nextToken := shouldContinueGeneration(response)
		if len(nextToken) == 0 {
			break
		}

		callConfig := prepareContinuationConfig(config, nextToken)
		response, err = m.generateContent(ctx, model, contents, callConfig)
		if err != nil {
			return nil, err
		}
		hopResponses = append(hopResponses, response)
	}

	if len(hopResponses) > 1 {
		return mergeContinuationResponses(hopResponses)
	}

	return response, nil
}

// GenerateContentStream generates a stream of content based on the provided model, contents, and configuration.
//
// A response that stops before the model finishes is continued automatically: the same request is
// sent again with the response's continuation token until the model finishes, and the chunks of
// every request are emitted in order. The usage metadata in a chunk is accumulated across
// continuation requests. Each request is billed, including any that succeeded before a later one
// failed. Set [GenerateContentConfig.AutomaticContinuation] to false to turn this off.
func (m Models) GenerateContentStream(ctx context.Context, model string, contents []*Content, config *GenerateContentConfig) iter.Seq2[*GenerateContentResponse, error] {
	if config != nil {
		config.setDefaults()
	}
	enableContinuation := shouldEnableAutomaticContinuation(config)

	return func(yield func(*GenerateContentResponse, error) bool) {
		state := newStreamContinuation(config, enableContinuation)
		for {
			callConfig := state.startHop()
			var hopErr error
			for chunk, err := range m.generateContentStream(ctx, model, contents, callConfig) {
				if err != nil {
					hopErr = err
					break
				}
				if !yield(state.observe(chunk), nil) {
					return
				}
			}

			resume, err := state.endHop(ctx, hopErr)
			if resume {
				continue
			}
			if err != nil {
				yield(nil, err)
			}
			// Otherwise the API returned no error, so end the stream normally; the
			// caller keeps every chunk already yielded.
			return
		}
	}
}

// List retrieves a paginated list of models resources.
func (m Models) List(ctx context.Context, config *ListModelsConfig) (Page[Model], error) {
	listFunc := func(ctx context.Context, config map[string]any) ([]*Model, string, *HTTPResponse, error) {
		var c ListModelsConfig
		if err := mapToStruct(config, &c); err != nil {
			return nil, "", nil, err
		}
		if c.QueryBase == nil {
			c.QueryBase = Ptr(true)
		}
		if m.apiClient.clientConfig.Backend == BackendVertexAI && !*c.QueryBase {
			if c.Filter != "" {
				c.Filter += "&filter="
			}
			c.Filter += "labels.tune-type:*"
		}
		resp, err := m.list(ctx, &c)
		if err != nil {
			return nil, "", nil, err
		}
		return resp.Models, resp.NextPageToken, resp.SDKHTTPResponse, nil
	}
	c := make(map[string]any)
	deepMarshal(config, &c)
	return newPage(ctx, "models", c, listFunc)
}

// All retrieves all models resources.
//
// This method handles pagination internally, making multiple API calls as needed
// to fetch all entries. It returns an iterator that yields each cached
// content entry one by one. You do not need to manage pagination
// tokens or make multiple calls to retrieve all data.
func (m Models) All(ctx context.Context) iter.Seq2[*Model, error] {
	listFunc := func(ctx context.Context, config map[string]any) ([]*Model, string, *HTTPResponse, error) {
		var c ListModelsConfig
		if err := mapToStruct(config, &c); err != nil {
			return nil, "", nil, err
		}
		if c.QueryBase == nil {
			c.QueryBase = Ptr(true)
		}

		resp, err := m.list(ctx, &c)
		if err != nil {
			return nil, "", nil, err
		}
		return resp.Models, resp.NextPageToken, resp.SDKHTTPResponse, nil
	}
	p, err := newPage(ctx, "models", map[string]any{}, listFunc)
	if err != nil {
		return yieldErrorAndEndIterator[Model](err)
	}
	return p.all(ctx)
}

// GenerateImages generates images based on the provided model, prompt, and configuration.
func (m Models) GenerateImages(ctx context.Context, model string, prompt string, config *GenerateImagesConfig) (*GenerateImagesResponse, error) {
	deprecationWarningGenerateImages.Do(func() {
		log.Println("The GenerateImages method is deprecated and will be removed in the next major release (not before Jan. 1 2027). Please use the GenerateContent method with image models instead. See https://aistudio.google.com/docs/deprecations#imagen-models and https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/capabilities/image-generation#generate-images")
	})
	apiResponse, err := m.generateImages(ctx, model, prompt, config)
	if err != nil {
		return nil, err
	}
	var positivePromptSafetyAttributes *SafetyAttributes
	generatedImages := []*GeneratedImage{}

	for _, generatedImage := range apiResponse.GeneratedImages {
		if generatedImage.SafetyAttributes != nil && generatedImage.SafetyAttributes.ContentType == "Positive Prompt" {
			positivePromptSafetyAttributes = generatedImage.SafetyAttributes
		} else {
			generatedImages = append(generatedImages, generatedImage)
		}
	}

	var sdkHTTPResponse *HTTPResponse
	if apiResponse.SDKHTTPResponse != nil {
		sdkHTTPResponse = apiResponse.SDKHTTPResponse
	}

	return &GenerateImagesResponse{
		GeneratedImages:                generatedImages,
		PositivePromptSafetyAttributes: positivePromptSafetyAttributes,
		SDKHTTPResponse:                sdkHTTPResponse,
	}, nil
}

// UpscaleImage upscales an image using the specified model, image, upscale factor, and configuration.
func (m Models) UpscaleImage(ctx context.Context, model string, image *Image, upscaleFactor string, config *UpscaleImageConfig) (*UpscaleImageResponse, error) {
	// Convert to API config.
	apiConfig := &upscaleImageAPIConfig{Mode: "upscale", NumberOfImages: 1}

	if config != nil {
		apiConfig.OutputGCSURI = config.OutputGCSURI
		apiConfig.OutputMIMEType = config.OutputMIMEType
		apiConfig.OutputCompressionQuality = config.OutputCompressionQuality
		apiConfig.SafetyFilterLevel = config.SafetyFilterLevel
		apiConfig.PersonGeneration = config.PersonGeneration
		apiConfig.IncludeRAIReason = config.IncludeRAIReason
		apiConfig.EnhanceInputImage = config.EnhanceInputImage
		apiConfig.ImagePreservationFactor = config.ImagePreservationFactor
		apiConfig.Labels = config.Labels
	}

	return m.upscaleImage(ctx, model, image, upscaleFactor, apiConfig)
}

// EditImage edits an image based on the provided model, prompt, reference images, and configuration.
func (m Models) EditImage(ctx context.Context, model, prompt string, referenceImages []ReferenceImage, config *EditImageConfig) (*EditImageResponse, error) {
	deprecationWarningEditImage.Do(func() {
		log.Println("The EditImage method is deprecated and will be removed in the next major release (not before Jan. 1 2027). Please use the GenerateContent method with image models instead. See https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/capabilities/gemini-edit-images#edit-an-image")
	})
	refImages := make([]*referenceImageAPI, len(referenceImages))
	for i, img := range referenceImages {
		refImages[i] = img.referenceImageAPI()
	}
	return m.editImage(ctx, model, prompt, refImages, config)
}

// GenerateVideos creates a long-running video generation operation.
// This method is kept for backward compatibility. Use GenerateVideosFromSource instead.
func (m Models) GenerateVideos(ctx context.Context, model string, prompt string, image *Image, config *GenerateVideosConfig) (*GenerateVideosOperation, error) {
	// Does not support Video or GenerateVideosSource.
	breakingChangeWarningGenerateVideosNotSource.Do(func() {
		log.Println("The GenerateVideos method with prompt/image is deprecated and will be replaced with source parameter in the next major release (not before 2026-07-31).")
	})
	return m.generateVideos(ctx, model, &prompt, image, nil, nil, config)
}

// GenerateVideos creates a long-running video generation operation.
func (m Models) GenerateVideosFromSource(ctx context.Context, model string, source *GenerateVideosSource, config *GenerateVideosConfig) (*GenerateVideosOperation, error) {
	deprecationWarningGenerateVideosFromSource.Do(func() {
		log.Println("The GenerateVideosFromSource method will be renamed to GenerateVideos() in the next major release (not before 2026-07-31).")
	})
	if source == nil {
		return nil, fmt.Errorf("source is required")
	}
	// Gemini API does not support video bytes.
	if m.apiClient.clientConfig.Backend == BackendGeminiAPI {
		if source.Video != nil && source.Video.URI != "" && source.Video.VideoBytes != nil {
			source.Video = &Video{URI: source.Video.URI, MIMEType: source.Video.MIMEType}
		}
	}
	// Rely on backend validation for combinations of prompt, image, and video.
	return m.generateVideos(ctx, model, nil, nil, nil, source, config)
}

func (m Models) EmbedContent(ctx context.Context, model string, contents []*Content, config *EmbedContentConfig) (*EmbedContentResponse, error) {
	// if not Vertex, call embedContent normally
	if m.apiClient.clientConfig.Backend != BackendVertexAI {
		return m.embedContent(ctx, model, contents, nil, nil, config)
	}
	if tIsVertexEmbedContentModel(model) {
		if len(contents) > 1 {
			return nil, fmt.Errorf("the embedContent API for this model only supports one content at a time")
		}
		eac := EmbeddingAPITypeEmbedContent
		return m.embedContent(ctx, model, contents, contents[0], &eac, config)
	} else {
		eap := EmbeddingAPITypePredict
		return m.embedContent(ctx, model, contents, nil, &eap, config)
	}
}