@google/genai 1.6.0 → 1.7.0

package/dist/index.cjs

@@ -532,7 +532,7 @@ exports.MediaResolution = void 0;
      */
     MediaResolution["MEDIA_RESOLUTION_HIGH"] = "MEDIA_RESOLUTION_HIGH";
 })(exports.MediaResolution || (exports.MediaResolution = {}));
-/** Output only. The detailed state of the job. */
+/** Job state. */
 exports.JobState = void 0;
 (function (JobState) {
     /**
@@ -576,7 +576,7 @@ exports.JobState = void 0;
      */
     JobState["JOB_STATE_EXPIRED"] = "JOB_STATE_EXPIRED";
     /**
-     * The job is being updated. Only jobs in the `RUNNING` state can be updated. After updating, the job goes back to the `RUNNING` state.
+     * The job is being updated. Only jobs in the `JOB_STATE_RUNNING` state can be updated. After updating, the job goes back to the `JOB_STATE_RUNNING` state.
      */
     JobState["JOB_STATE_UPDATING"] = "JOB_STATE_UPDATING";
     /**
@@ -699,8 +699,17 @@ exports.SafetyFilterLevel = void 0;
 /** Enum that controls the generation of people. */
 exports.PersonGeneration = void 0;
 (function (PersonGeneration) {
+    /**
+     * Block generation of images of people.
+     */
     PersonGeneration["DONT_ALLOW"] = "DONT_ALLOW";
+    /**
+     * Generate images of adults, but not children.
+     */
     PersonGeneration["ALLOW_ADULT"] = "ALLOW_ADULT";
+    /**
+     * Generate images that include adults and children.
+     */
     PersonGeneration["ALLOW_ALL"] = "ALLOW_ALL";
 })(exports.PersonGeneration || (exports.PersonGeneration = {}));
 /** Enum that specifies the language of the text in the prompt. */
@@ -749,6 +758,20 @@ exports.EditMode = void 0;
     EditMode["EDIT_MODE_BGSWAP"] = "EDIT_MODE_BGSWAP";
     EditMode["EDIT_MODE_PRODUCT_IMAGE"] = "EDIT_MODE_PRODUCT_IMAGE";
 })(exports.EditMode || (exports.EditMode = {}));
+/** Enum that controls the compression quality of the generated videos. */
+exports.VideoCompressionQuality = void 0;
+(function (VideoCompressionQuality) {
+    /**
+     * Optimized video compression quality. This will produce videos
+        with a compressed, smaller file size.
+     */
+    VideoCompressionQuality["OPTIMIZED"] = "OPTIMIZED";
+    /**
+     * Lossless video compression quality. This will produce videos
+        with a larger file size.
+     */
+    VideoCompressionQuality["LOSSLESS"] = "LOSSLESS";
+})(exports.VideoCompressionQuality || (exports.VideoCompressionQuality = {}));
 /** State for the lifecycle of a File. */
 exports.FileState = void 0;
 (function (FileState) {
@@ -1385,6 +1408,12 @@ class CreateFileResponse {
 /** Response for the delete file method. */
 class DeleteFileResponse {
 }
+/** Config for `inlined_responses` parameter. */
+class InlinedResponse {
+}
+/** Config for batches.list return value. */
+class ListBatchJobsResponse {
+}
 /** Represents a single response in a replay. */
 class ReplayResponse {
 }
@@ -2375,17 +2404,1966 @@ function filterToJsonSchema(schema) {
         else if (dictSchemaFieldNames.has(fieldName)) {
             filteredSchema[fieldName] = filterDictSchemaField(fieldValue);
         }
-        else if (fieldName === 'type') {
-            const typeValue = fieldValue.toUpperCase();
-            filteredSchema[fieldName] = Object.values(exports.Type).includes(typeValue)
-                ? typeValue
-                : exports.Type.TYPE_UNSPECIFIED;
+        else if (fieldName === 'type') {
+            const typeValue = fieldValue.toUpperCase();
+            filteredSchema[fieldName] = Object.values(exports.Type).includes(typeValue)
+                ? typeValue
+                : exports.Type.TYPE_UNSPECIFIED;
+        }
+        else if (supportedJsonSchemaFields.has(fieldName)) {
+            filteredSchema[fieldName] = fieldValue;
+        }
+    }
+    return filteredSchema;
+}
+// Transforms a source input into a BatchJobSource object with validation.
+function tBatchJobSource(apiClient, src) {
+    if (typeof src !== 'string' && !Array.isArray(src)) {
+        if (apiClient && apiClient.isVertexAI()) {
+            if (src.gcsUri && src.bigqueryUri) {
+                throw new Error('Only one of `gcsUri` or `bigqueryUri` can be set.');
+            }
+            else if (!src.gcsUri && !src.bigqueryUri) {
+                throw new Error('One of `gcsUri` or `bigqueryUri` must be set.');
+            }
+        }
+        else {
+            // Logic for non-Vertex AI client (inlined_requests, file_name)
+            if (src.inlinedRequests && src.fileName) {
+                throw new Error('Only one of `inlinedRequests` or `fileName` can be set.');
+            }
+            else if (!src.inlinedRequests && !src.fileName) {
+                throw new Error('One of `inlinedRequests` or `fileName` must be set.');
+            }
+        }
+        return src;
+    }
+    // If src is an array (list in Python)
+    else if (Array.isArray(src)) {
+        return { inlinedRequests: src };
+    }
+    else if (typeof src === 'string') {
+        if (src.startsWith('gs://')) {
+            return {
+                format: 'jsonl',
+                gcsUri: [src], // GCS URI is expected as an array
+            };
+        }
+        else if (src.startsWith('bq://')) {
+            return {
+                format: 'bigquery',
+                bigqueryUri: src,
+            };
+        }
+        else if (src.startsWith('files/')) {
+            return {
+                fileName: src,
+            };
+        }
+    }
+    throw new Error(`Unsupported source: ${src}`);
+}
+function tBatchJobDestination(dest) {
+    const destString = dest;
+    if (destString.startsWith('gs://')) {
+        return {
+            format: 'jsonl',
+            gcsUri: destString,
+        };
+    }
+    else if (destString.startsWith('bq://')) {
+        return {
+            format: 'bigquery',
+            bigqueryUri: destString,
+        };
+    }
+    else {
+        throw new Error(`Unsupported destination: ${destString}`);
+    }
+}
+function tBatchJobName(apiClient, name) {
+    const nameString = name;
+    if (!apiClient.isVertexAI()) {
+        const mldevPattern = /batches\/[^/]+$/;
+        if (mldevPattern.test(nameString)) {
+            return nameString.split('/').pop();
+        }
+        else {
+            throw new Error(`Invalid batch job name: ${nameString}.`);
+        }
+    }
+    const vertexPattern = /^projects\/[^/]+\/locations\/[^/]+\/batchPredictionJobs\/[^/]+$/;
+    if (vertexPattern.test(nameString)) {
+        return nameString.split('/').pop();
+    }
+    else if (/^\d+$/.test(nameString)) {
+        return nameString;
+    }
+    else {
+        throw new Error(`Invalid batch job name: ${nameString}.`);
+    }
+}
+function tJobState(state) {
+    const stateString = state;
+    if (stateString === 'BATCH_STATE_UNSPECIFIED') {
+        return 'JOB_STATE_UNSPECIFIED';
+    }
+    else if (stateString === 'BATCH_STATE_PENDING') {
+        return 'JOB_STATE_PENDING';
+    }
+    else if (stateString === 'BATCH_STATE_SUCCEEDED') {
+        return 'JOB_STATE_SUCCEEDED';
+    }
+    else if (stateString === 'BATCH_STATE_FAILED') {
+        return 'JOB_STATE_FAILED';
+    }
+    else if (stateString === 'BATCH_STATE_CANCELLED') {
+        return 'JOB_STATE_CANCELLED';
+    }
+    else {
+        return stateString;
+    }
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function videoMetadataToMldev$4(fromObject) {
+    const toObject = {};
+    const fromFps = getValueByPath(fromObject, ['fps']);
+    if (fromFps != null) {
+        setValueByPath(toObject, ['fps'], fromFps);
+    }
+    const fromEndOffset = getValueByPath(fromObject, ['endOffset']);
+    if (fromEndOffset != null) {
+        setValueByPath(toObject, ['endOffset'], fromEndOffset);
+    }
+    const fromStartOffset = getValueByPath(fromObject, ['startOffset']);
+    if (fromStartOffset != null) {
+        setValueByPath(toObject, ['startOffset'], fromStartOffset);
+    }
+    return toObject;
+}
+function blobToMldev$4(fromObject) {
+    const toObject = {};
+    if (getValueByPath(fromObject, ['displayName']) !== undefined) {
+        throw new Error('displayName parameter is not supported in Gemini API.');
+    }
+    const fromData = getValueByPath(fromObject, ['data']);
+    if (fromData != null) {
+        setValueByPath(toObject, ['data'], fromData);
+    }
+    const fromMimeType = getValueByPath(fromObject, ['mimeType']);
+    if (fromMimeType != null) {
+        setValueByPath(toObject, ['mimeType'], fromMimeType);
+    }
+    return toObject;
+}
+function fileDataToMldev$4(fromObject) {
+    const toObject = {};
+    if (getValueByPath(fromObject, ['displayName']) !== undefined) {
+        throw new Error('displayName parameter is not supported in Gemini API.');
+    }
+    const fromFileUri = getValueByPath(fromObject, ['fileUri']);
+    if (fromFileUri != null) {
+        setValueByPath(toObject, ['fileUri'], fromFileUri);
+    }
+    const fromMimeType = getValueByPath(fromObject, ['mimeType']);
+    if (fromMimeType != null) {
+        setValueByPath(toObject, ['mimeType'], fromMimeType);
+    }
+    return toObject;
+}
+function partToMldev$4(fromObject) {
+    const toObject = {};
+    const fromVideoMetadata = getValueByPath(fromObject, [
+        'videoMetadata',
+    ]);
+    if (fromVideoMetadata != null) {
+        setValueByPath(toObject, ['videoMetadata'], videoMetadataToMldev$4(fromVideoMetadata));
+    }
+    const fromThought = getValueByPath(fromObject, ['thought']);
+    if (fromThought != null) {
+        setValueByPath(toObject, ['thought'], fromThought);
+    }
+    const fromInlineData = getValueByPath(fromObject, ['inlineData']);
+    if (fromInlineData != null) {
+        setValueByPath(toObject, ['inlineData'], blobToMldev$4(fromInlineData));
+    }
+    const fromFileData = getValueByPath(fromObject, ['fileData']);
+    if (fromFileData != null) {
+        setValueByPath(toObject, ['fileData'], fileDataToMldev$4(fromFileData));
+    }
+    const fromThoughtSignature = getValueByPath(fromObject, [
+        'thoughtSignature',
+    ]);
+    if (fromThoughtSignature != null) {
+        setValueByPath(toObject, ['thoughtSignature'], fromThoughtSignature);
+    }
+    const fromCodeExecutionResult = getValueByPath(fromObject, [
+        'codeExecutionResult',
+    ]);
+    if (fromCodeExecutionResult != null) {
+        setValueByPath(toObject, ['codeExecutionResult'], fromCodeExecutionResult);
+    }
+    const fromExecutableCode = getValueByPath(fromObject, [
+        'executableCode',
+    ]);
+    if (fromExecutableCode != null) {
+        setValueByPath(toObject, ['executableCode'], fromExecutableCode);
+    }
+    const fromFunctionCall = getValueByPath(fromObject, ['functionCall']);
+    if (fromFunctionCall != null) {
+        setValueByPath(toObject, ['functionCall'], fromFunctionCall);
+    }
+    const fromFunctionResponse = getValueByPath(fromObject, [
+        'functionResponse',
+    ]);
+    if (fromFunctionResponse != null) {
+        setValueByPath(toObject, ['functionResponse'], fromFunctionResponse);
+    }
+    const fromText = getValueByPath(fromObject, ['text']);
+    if (fromText != null) {
+        setValueByPath(toObject, ['text'], fromText);
+    }
+    return toObject;
+}
+function contentToMldev$4(fromObject) {
+    const toObject = {};
+    const fromParts = getValueByPath(fromObject, ['parts']);
+    if (fromParts != null) {
+        let transformedList = fromParts;
+        if (Array.isArray(transformedList)) {
+            transformedList = transformedList.map((item) => {
+                return partToMldev$4(item);
+            });
+        }
+        setValueByPath(toObject, ['parts'], transformedList);
+    }
+    const fromRole = getValueByPath(fromObject, ['role']);
+    if (fromRole != null) {
+        setValueByPath(toObject, ['role'], fromRole);
+    }
+    return toObject;
+}
+function schemaToMldev$1(fromObject) {
+    const toObject = {};
+    const fromAnyOf = getValueByPath(fromObject, ['anyOf']);
+    if (fromAnyOf != null) {
+        setValueByPath(toObject, ['anyOf'], fromAnyOf);
+    }
+    const fromDefault = getValueByPath(fromObject, ['default']);
+    if (fromDefault != null) {
+        setValueByPath(toObject, ['default'], fromDefault);
+    }
+    const fromDescription = getValueByPath(fromObject, ['description']);
+    if (fromDescription != null) {
+        setValueByPath(toObject, ['description'], fromDescription);
+    }
+    const fromEnum = getValueByPath(fromObject, ['enum']);
+    if (fromEnum != null) {
+        setValueByPath(toObject, ['enum'], fromEnum);
+    }
+    const fromExample = getValueByPath(fromObject, ['example']);
+    if (fromExample != null) {
+        setValueByPath(toObject, ['example'], fromExample);
+    }
+    const fromFormat = getValueByPath(fromObject, ['format']);
+    if (fromFormat != null) {
+        setValueByPath(toObject, ['format'], fromFormat);
+    }
+    const fromItems = getValueByPath(fromObject, ['items']);
+    if (fromItems != null) {
+        setValueByPath(toObject, ['items'], fromItems);
+    }
+    const fromMaxItems = getValueByPath(fromObject, ['maxItems']);
+    if (fromMaxItems != null) {
+        setValueByPath(toObject, ['maxItems'], fromMaxItems);
+    }
+    const fromMaxLength = getValueByPath(fromObject, ['maxLength']);
+    if (fromMaxLength != null) {
+        setValueByPath(toObject, ['maxLength'], fromMaxLength);
+    }
+    const fromMaxProperties = getValueByPath(fromObject, [
+        'maxProperties',
+    ]);
+    if (fromMaxProperties != null) {
+        setValueByPath(toObject, ['maxProperties'], fromMaxProperties);
+    }
+    const fromMaximum = getValueByPath(fromObject, ['maximum']);
+    if (fromMaximum != null) {
+        setValueByPath(toObject, ['maximum'], fromMaximum);
+    }
+    const fromMinItems = getValueByPath(fromObject, ['minItems']);
+    if (fromMinItems != null) {
+        setValueByPath(toObject, ['minItems'], fromMinItems);
+    }
+    const fromMinLength = getValueByPath(fromObject, ['minLength']);
+    if (fromMinLength != null) {
+        setValueByPath(toObject, ['minLength'], fromMinLength);
+    }
+    const fromMinProperties = getValueByPath(fromObject, [
+        'minProperties',
+    ]);
+    if (fromMinProperties != null) {
+        setValueByPath(toObject, ['minProperties'], fromMinProperties);
+    }
+    const fromMinimum = getValueByPath(fromObject, ['minimum']);
+    if (fromMinimum != null) {
+        setValueByPath(toObject, ['minimum'], fromMinimum);
+    }
+    const fromNullable = getValueByPath(fromObject, ['nullable']);
+    if (fromNullable != null) {
+        setValueByPath(toObject, ['nullable'], fromNullable);
+    }
+    const fromPattern = getValueByPath(fromObject, ['pattern']);
+    if (fromPattern != null) {
+        setValueByPath(toObject, ['pattern'], fromPattern);
+    }
+    const fromProperties = getValueByPath(fromObject, ['properties']);
+    if (fromProperties != null) {
+        setValueByPath(toObject, ['properties'], fromProperties);
+    }
+    const fromPropertyOrdering = getValueByPath(fromObject, [
+        'propertyOrdering',
+    ]);
+    if (fromPropertyOrdering != null) {
+        setValueByPath(toObject, ['propertyOrdering'], fromPropertyOrdering);
+    }
+    const fromRequired = getValueByPath(fromObject, ['required']);
+    if (fromRequired != null) {
+        setValueByPath(toObject, ['required'], fromRequired);
+    }
+    const fromTitle = getValueByPath(fromObject, ['title']);
+    if (fromTitle != null) {
+        setValueByPath(toObject, ['title'], fromTitle);
+    }
+    const fromType = getValueByPath(fromObject, ['type']);
+    if (fromType != null) {
+        setValueByPath(toObject, ['type'], fromType);
+    }
+    return toObject;
+}
+function safetySettingToMldev$1(fromObject) {
+    const toObject = {};
+    if (getValueByPath(fromObject, ['method']) !== undefined) {
+        throw new Error('method parameter is not supported in Gemini API.');
+    }
+    const fromCategory = getValueByPath(fromObject, ['category']);
+    if (fromCategory != null) {
+        setValueByPath(toObject, ['category'], fromCategory);
+    }
+    const fromThreshold = getValueByPath(fromObject, ['threshold']);
+    if (fromThreshold != null) {
+        setValueByPath(toObject, ['threshold'], fromThreshold);
+    }
+    return toObject;
+}
+function functionDeclarationToMldev$4(fromObject) {
+    const toObject = {};
+    const fromBehavior = getValueByPath(fromObject, ['behavior']);
+    if (fromBehavior != null) {
+        setValueByPath(toObject, ['behavior'], fromBehavior);
+    }
+    const fromDescription = getValueByPath(fromObject, ['description']);
+    if (fromDescription != null) {
+        setValueByPath(toObject, ['description'], fromDescription);
+    }
+    const fromName = getValueByPath(fromObject, ['name']);
+    if (fromName != null) {
+        setValueByPath(toObject, ['name'], fromName);
+    }
+    const fromParameters = getValueByPath(fromObject, ['parameters']);
+    if (fromParameters != null) {
+        setValueByPath(toObject, ['parameters'], fromParameters);
+    }
+    const fromParametersJsonSchema = getValueByPath(fromObject, [
+        'parametersJsonSchema',
+    ]);
+    if (fromParametersJsonSchema != null) {
+        setValueByPath(toObject, ['parametersJsonSchema'], fromParametersJsonSchema);
+    }
+    const fromResponse = getValueByPath(fromObject, ['response']);
+    if (fromResponse != null) {
+        setValueByPath(toObject, ['response'], fromResponse);
+    }
+    const fromResponseJsonSchema = getValueByPath(fromObject, [
+        'responseJsonSchema',
+    ]);
+    if (fromResponseJsonSchema != null) {
+        setValueByPath(toObject, ['responseJsonSchema'], fromResponseJsonSchema);
+    }
+    return toObject;
+}
+function intervalToMldev$4(fromObject) {
+    const toObject = {};
+    const fromStartTime = getValueByPath(fromObject, ['startTime']);
+    if (fromStartTime != null) {
+        setValueByPath(toObject, ['startTime'], fromStartTime);
+    }
+    const fromEndTime = getValueByPath(fromObject, ['endTime']);
+    if (fromEndTime != null) {
+        setValueByPath(toObject, ['endTime'], fromEndTime);
+    }
+    return toObject;
+}
+function googleSearchToMldev$4(fromObject) {
+    const toObject = {};
+    const fromTimeRangeFilter = getValueByPath(fromObject, [
+        'timeRangeFilter',
+    ]);
+    if (fromTimeRangeFilter != null) {
+        setValueByPath(toObject, ['timeRangeFilter'], intervalToMldev$4(fromTimeRangeFilter));
+    }
+    return toObject;
+}
+function dynamicRetrievalConfigToMldev$4(fromObject) {
+    const toObject = {};
+    const fromMode = getValueByPath(fromObject, ['mode']);
+    if (fromMode != null) {
+        setValueByPath(toObject, ['mode'], fromMode);
+    }
+    const fromDynamicThreshold = getValueByPath(fromObject, [
+        'dynamicThreshold',
+    ]);
+    if (fromDynamicThreshold != null) {
+        setValueByPath(toObject, ['dynamicThreshold'], fromDynamicThreshold);
+    }
+    return toObject;
+}
+function googleSearchRetrievalToMldev$4(fromObject) {
+    const toObject = {};
+    const fromDynamicRetrievalConfig = getValueByPath(fromObject, [
+        'dynamicRetrievalConfig',
+    ]);
+    if (fromDynamicRetrievalConfig != null) {
+        setValueByPath(toObject, ['dynamicRetrievalConfig'], dynamicRetrievalConfigToMldev$4(fromDynamicRetrievalConfig));
+    }
+    return toObject;
+}
+function urlContextToMldev$4() {
+    const toObject = {};
+    return toObject;
+}
+function toolToMldev$4(fromObject) {
+    const toObject = {};
+    const fromFunctionDeclarations = getValueByPath(fromObject, [
+        'functionDeclarations',
+    ]);
+    if (fromFunctionDeclarations != null) {
+        let transformedList = fromFunctionDeclarations;
+        if (Array.isArray(transformedList)) {
+            transformedList = transformedList.map((item) => {
+                return functionDeclarationToMldev$4(item);
+            });
+        }
+        setValueByPath(toObject, ['functionDeclarations'], transformedList);
+    }
+    if (getValueByPath(fromObject, ['retrieval']) !== undefined) {
+        throw new Error('retrieval parameter is not supported in Gemini API.');
+    }
+    const fromGoogleSearch = getValueByPath(fromObject, ['googleSearch']);
+    if (fromGoogleSearch != null) {
+        setValueByPath(toObject, ['googleSearch'], googleSearchToMldev$4(fromGoogleSearch));
+    }
+    const fromGoogleSearchRetrieval = getValueByPath(fromObject, [
+        'googleSearchRetrieval',
+    ]);
+    if (fromGoogleSearchRetrieval != null) {
+        setValueByPath(toObject, ['googleSearchRetrieval'], googleSearchRetrievalToMldev$4(fromGoogleSearchRetrieval));
+    }
+    if (getValueByPath(fromObject, ['enterpriseWebSearch']) !== undefined) {
+        throw new Error('enterpriseWebSearch parameter is not supported in Gemini API.');
+    }
+    if (getValueByPath(fromObject, ['googleMaps']) !== undefined) {
+        throw new Error('googleMaps parameter is not supported in Gemini API.');
+    }
+    const fromUrlContext = getValueByPath(fromObject, ['urlContext']);
+    if (fromUrlContext != null) {
+        setValueByPath(toObject, ['urlContext'], urlContextToMldev$4());
+    }
+    const fromCodeExecution = getValueByPath(fromObject, [
+        'codeExecution',
+    ]);
+    if (fromCodeExecution != null) {
+        setValueByPath(toObject, ['codeExecution'], fromCodeExecution);
+    }
+    return toObject;
+}
+function functionCallingConfigToMldev$2(fromObject) {
+    const toObject = {};
+    const fromMode = getValueByPath(fromObject, ['mode']);
+    if (fromMode != null) {
+        setValueByPath(toObject, ['mode'], fromMode);
+    }
+    const fromAllowedFunctionNames = getValueByPath(fromObject, [
+        'allowedFunctionNames',
+    ]);
+    if (fromAllowedFunctionNames != null) {
+        setValueByPath(toObject, ['allowedFunctionNames'], fromAllowedFunctionNames);
+    }
+    return toObject;
+}
+function latLngToMldev$2(fromObject) {
+    const toObject = {};
+    const fromLatitude = getValueByPath(fromObject, ['latitude']);
+    if (fromLatitude != null) {
+        setValueByPath(toObject, ['latitude'], fromLatitude);
+    }
+    const fromLongitude = getValueByPath(fromObject, ['longitude']);
+    if (fromLongitude != null) {
+        setValueByPath(toObject, ['longitude'], fromLongitude);
+    }
+    return toObject;
+}
+function retrievalConfigToMldev$2(fromObject) {
+    const toObject = {};
+    const fromLatLng = getValueByPath(fromObject, ['latLng']);
+    if (fromLatLng != null) {
+        setValueByPath(toObject, ['latLng'], latLngToMldev$2(fromLatLng));
+    }
+    const fromLanguageCode = getValueByPath(fromObject, ['languageCode']);
+    if (fromLanguageCode != null) {
+        setValueByPath(toObject, ['languageCode'], fromLanguageCode);
+    }
+    return toObject;
+}
+function toolConfigToMldev$2(fromObject) {
+    const toObject = {};
+    const fromFunctionCallingConfig = getValueByPath(fromObject, [
+        'functionCallingConfig',
+    ]);
+    if (fromFunctionCallingConfig != null) {
+        setValueByPath(toObject, ['functionCallingConfig'], functionCallingConfigToMldev$2(fromFunctionCallingConfig));
+    }
+    const fromRetrievalConfig = getValueByPath(fromObject, [
+        'retrievalConfig',
+    ]);
+    if (fromRetrievalConfig != null) {
+        setValueByPath(toObject, ['retrievalConfig'], retrievalConfigToMldev$2(fromRetrievalConfig));
+    }
+    return toObject;
+}
+function prebuiltVoiceConfigToMldev$3(fromObject) {
+    const toObject = {};
+    const fromVoiceName = getValueByPath(fromObject, ['voiceName']);
+    if (fromVoiceName != null) {
+        setValueByPath(toObject, ['voiceName'], fromVoiceName);
+    }
+    return toObject;
+}
+function voiceConfigToMldev$3(fromObject) {
+    const toObject = {};
+    const fromPrebuiltVoiceConfig = getValueByPath(fromObject, [
+        'prebuiltVoiceConfig',
+    ]);
+    if (fromPrebuiltVoiceConfig != null) {
+        setValueByPath(toObject, ['prebuiltVoiceConfig'], prebuiltVoiceConfigToMldev$3(fromPrebuiltVoiceConfig));
+    }
+    return toObject;
+}
+function speakerVoiceConfigToMldev$3(fromObject) {
+    const toObject = {};
+    const fromSpeaker = getValueByPath(fromObject, ['speaker']);
+    if (fromSpeaker != null) {
+        setValueByPath(toObject, ['speaker'], fromSpeaker);
+    }
+    const fromVoiceConfig = getValueByPath(fromObject, ['voiceConfig']);
+    if (fromVoiceConfig != null) {
+        setValueByPath(toObject, ['voiceConfig'], voiceConfigToMldev$3(fromVoiceConfig));
+    }
+    return toObject;
+}
+function multiSpeakerVoiceConfigToMldev$3(fromObject) {
+    const toObject = {};
+    const fromSpeakerVoiceConfigs = getValueByPath(fromObject, [
+        'speakerVoiceConfigs',
+    ]);
+    if (fromSpeakerVoiceConfigs != null) {
+        let transformedList = fromSpeakerVoiceConfigs;
+        if (Array.isArray(transformedList)) {
+            transformedList = transformedList.map((item) => {
+                return speakerVoiceConfigToMldev$3(item);
+            });
+        }
+        setValueByPath(toObject, ['speakerVoiceConfigs'], transformedList);
+    }
+    return toObject;
+}
+function speechConfigToMldev$3(fromObject) {
+    const toObject = {};
+    const fromVoiceConfig = getValueByPath(fromObject, ['voiceConfig']);
+    if (fromVoiceConfig != null) {
+        setValueByPath(toObject, ['voiceConfig'], voiceConfigToMldev$3(fromVoiceConfig));
+    }
+    const fromMultiSpeakerVoiceConfig = getValueByPath(fromObject, [
+        'multiSpeakerVoiceConfig',
+    ]);
+    if (fromMultiSpeakerVoiceConfig != null) {
+        setValueByPath(toObject, ['multiSpeakerVoiceConfig'], multiSpeakerVoiceConfigToMldev$3(fromMultiSpeakerVoiceConfig));
+    }
+    const fromLanguageCode = getValueByPath(fromObject, ['languageCode']);
+    if (fromLanguageCode != null) {
+        setValueByPath(toObject, ['languageCode'], fromLanguageCode);
+    }
+    return toObject;
+}
+function thinkingConfigToMldev$1(fromObject) {
+    const toObject = {};
+    const fromIncludeThoughts = getValueByPath(fromObject, [
+        'includeThoughts',
+    ]);
+    if (fromIncludeThoughts != null) {
+        setValueByPath(toObject, ['includeThoughts'], fromIncludeThoughts);
+    }
+    const fromThinkingBudget = getValueByPath(fromObject, [
+        'thinkingBudget',
+    ]);
+    if (fromThinkingBudget != null) {
+        setValueByPath(toObject, ['thinkingBudget'], fromThinkingBudget);
+    }
+    return toObject;
+}
+function generateContentConfigToMldev$1(apiClient, fromObject, parentObject) {
+    const toObject = {};
+    const fromSystemInstruction = getValueByPath(fromObject, [
+        'systemInstruction',
+    ]);
+    if (parentObject !== undefined && fromSystemInstruction != null) {
+        setValueByPath(parentObject, ['systemInstruction'], contentToMldev$4(tContent(fromSystemInstruction)));
+    }
+    const fromTemperature = getValueByPath(fromObject, ['temperature']);
+    if (fromTemperature != null) {
+        setValueByPath(toObject, ['temperature'], fromTemperature);
+    }
+    const fromTopP = getValueByPath(fromObject, ['topP']);
+    if (fromTopP != null) {
+        setValueByPath(toObject, ['topP'], fromTopP);
+    }
+    const fromTopK = getValueByPath(fromObject, ['topK']);
+    if (fromTopK != null) {
+        setValueByPath(toObject, ['topK'], fromTopK);
+    }
+    const fromCandidateCount = getValueByPath(fromObject, [
+        'candidateCount',
+    ]);
+    if (fromCandidateCount != null) {
+        setValueByPath(toObject, ['candidateCount'], fromCandidateCount);
+    }
+    const fromMaxOutputTokens = getValueByPath(fromObject, [
+        'maxOutputTokens',
+    ]);
+    if (fromMaxOutputTokens != null) {
+        setValueByPath(toObject, ['maxOutputTokens'], fromMaxOutputTokens);
+    }
+    const fromStopSequences = getValueByPath(fromObject, [
+        'stopSequences',
+    ]);
+    if (fromStopSequences != null) {
+        setValueByPath(toObject, ['stopSequences'], fromStopSequences);
+    }
+    const fromResponseLogprobs = getValueByPath(fromObject, [
+        'responseLogprobs',
+    ]);
+    if (fromResponseLogprobs != null) {
+        setValueByPath(toObject, ['responseLogprobs'], fromResponseLogprobs);
+    }
+    const fromLogprobs = getValueByPath(fromObject, ['logprobs']);
+    if (fromLogprobs != null) {
+        setValueByPath(toObject, ['logprobs'], fromLogprobs);
+    }
+    const fromPresencePenalty = getValueByPath(fromObject, [
+        'presencePenalty',
+    ]);
+    if (fromPresencePenalty != null) {
+        setValueByPath(toObject, ['presencePenalty'], fromPresencePenalty);
+    }
+    const fromFrequencyPenalty = getValueByPath(fromObject, [
+        'frequencyPenalty',
+    ]);
+    if (fromFrequencyPenalty != null) {
+        setValueByPath(toObject, ['frequencyPenalty'], fromFrequencyPenalty);
+    }
+    const fromSeed = getValueByPath(fromObject, ['seed']);
+    if (fromSeed != null) {
+        setValueByPath(toObject, ['seed'], fromSeed);
+    }
+    const fromResponseMimeType = getValueByPath(fromObject, [
+        'responseMimeType',
+    ]);
+    if (fromResponseMimeType != null) {
+        setValueByPath(toObject, ['responseMimeType'], fromResponseMimeType);
+    }
+    const fromResponseSchema = getValueByPath(fromObject, [
+        'responseSchema',
+    ]);
+    if (fromResponseSchema != null) {
+        setValueByPath(toObject, ['responseSchema'], schemaToMldev$1(tSchema(fromResponseSchema)));
+    }
+    const fromResponseJsonSchema = getValueByPath(fromObject, [
+        'responseJsonSchema',
+    ]);
+    if (fromResponseJsonSchema != null) {
+        setValueByPath(toObject, ['responseJsonSchema'], fromResponseJsonSchema);
+    }
+    if (getValueByPath(fromObject, ['routingConfig']) !== undefined) {
+        throw new Error('routingConfig parameter is not supported in Gemini API.');
+    }
+    if (getValueByPath(fromObject, ['modelSelectionConfig']) !== undefined) {
+        throw new Error('modelSelectionConfig parameter is not supported in Gemini API.');
+    }
+    const fromSafetySettings = getValueByPath(fromObject, [
+        'safetySettings',
+    ]);
+    if (parentObject !== undefined && fromSafetySettings != null) {
+        let transformedList = fromSafetySettings;
+        if (Array.isArray(transformedList)) {
+            transformedList = transformedList.map((item) => {
+                return safetySettingToMldev$1(item);
+            });
+        }
+        setValueByPath(parentObject, ['safetySettings'], transformedList);
+    }
+    const fromTools = getValueByPath(fromObject, ['tools']);
+    if (parentObject !== undefined && fromTools != null) {
+        let transformedList = tTools(fromTools);
+        if (Array.isArray(transformedList)) {
+            transformedList = transformedList.map((item) => {
+                return toolToMldev$4(tTool(item));
+            });
+        }
+        setValueByPath(parentObject, ['tools'], transformedList);
+    }
+    const fromToolConfig = getValueByPath(fromObject, ['toolConfig']);
+    if (parentObject !== undefined && fromToolConfig != null) {
+        setValueByPath(parentObject, ['toolConfig'], toolConfigToMldev$2(fromToolConfig));
+    }
+    if (getValueByPath(fromObject, ['labels']) !== undefined) {
+        throw new Error('labels parameter is not supported in Gemini API.');
+    }
+    const fromCachedContent = getValueByPath(fromObject, [
+        'cachedContent',
+    ]);
+    if (parentObject !== undefined && fromCachedContent != null) {
+        setValueByPath(parentObject, ['cachedContent'], tCachedContentName(apiClient, fromCachedContent));
+    }
+    const fromResponseModalities = getValueByPath(fromObject, [
+        'responseModalities',
+    ]);
+    if (fromResponseModalities != null) {
+        setValueByPath(toObject, ['responseModalities'], fromResponseModalities);
+    }
+    const fromMediaResolution = getValueByPath(fromObject, [
+        'mediaResolution',
+    ]);
+    if (fromMediaResolution != null) {
+        setValueByPath(toObject, ['mediaResolution'], fromMediaResolution);
+    }
+    const fromSpeechConfig = getValueByPath(fromObject, ['speechConfig']);
+    if (fromSpeechConfig != null) {
+        setValueByPath(toObject, ['speechConfig'], speechConfigToMldev$3(tSpeechConfig(fromSpeechConfig)));
+    }
+    if (getValueByPath(fromObject, ['audioTimestamp']) !== undefined) {
+        throw new Error('audioTimestamp parameter is not supported in Gemini API.');
+    }
+    const fromThinkingConfig = getValueByPath(fromObject, [
+        'thinkingConfig',
+    ]);
+    if (fromThinkingConfig != null) {
+        setValueByPath(toObject, ['thinkingConfig'], thinkingConfigToMldev$1(fromThinkingConfig));
+    }
+    return toObject;
+}
+function inlinedRequestToMldev(apiClient, fromObject) {
+    const toObject = {};
+    const fromModel = getValueByPath(fromObject, ['model']);
+    if (fromModel != null) {
+        setValueByPath(toObject, ['request', 'model'], tModel(apiClient, fromModel));
+    }
+    const fromContents = getValueByPath(fromObject, ['contents']);
+    if (fromContents != null) {
+        let transformedList = tContents(fromContents);
+        if (Array.isArray(transformedList)) {
+            transformedList = transformedList.map((item) => {
+                return contentToMldev$4(item);
+            });
+        }
+        setValueByPath(toObject, ['request', 'contents'], transformedList);
+    }
+    const fromConfig = getValueByPath(fromObject, ['config']);
+    if (fromConfig != null) {
+        setValueByPath(toObject, ['request', 'generationConfig'], generateContentConfigToMldev$1(apiClient, fromConfig, toObject));
+    }
+    return toObject;
+}
+function batchJobSourceToMldev(apiClient, fromObject) {
+    const toObject = {};
+    if (getValueByPath(fromObject, ['format']) !== undefined) {
+        throw new Error('format parameter is not supported in Gemini API.');
+    }
+    if (getValueByPath(fromObject, ['gcsUri']) !== undefined) {
+        throw new Error('gcsUri parameter is not supported in Gemini API.');
+    }
+    if (getValueByPath(fromObject, ['bigqueryUri']) !== undefined) {
+        throw new Error('bigqueryUri parameter is not supported in Gemini API.');
+    }
+    const fromFileName = getValueByPath(fromObject, ['fileName']);
+    if (fromFileName != null) {
+        setValueByPath(toObject, ['fileName'], fromFileName);
+    }
+    const fromInlinedRequests = getValueByPath(fromObject, [
+        'inlinedRequests',
+    ]);
+    if (fromInlinedRequests != null) {
+        let transformedList = fromInlinedRequests;
+        if (Array.isArray(transformedList)) {
+            transformedList = transformedList.map((item) => {
+                return inlinedRequestToMldev(apiClient, item);
+            });
+        }
+        setValueByPath(toObject, ['requests', 'requests'], transformedList);
+    }
+    return toObject;
+}
+function createBatchJobConfigToMldev(fromObject, parentObject) {
+    const toObject = {};
+    const fromDisplayName = getValueByPath(fromObject, ['displayName']);
+    if (parentObject !== undefined && fromDisplayName != null) {
+        setValueByPath(parentObject, ['batch', 'displayName'], fromDisplayName);
+    }
+    if (getValueByPath(fromObject, ['dest']) !== undefined) {
+        throw new Error('dest parameter is not supported in Gemini API.');
+    }
+    return toObject;
+}
+function createBatchJobParametersToMldev(apiClient, fromObject) {
+    const toObject = {};
+    const fromModel = getValueByPath(fromObject, ['model']);
+    if (fromModel != null) {
+        setValueByPath(toObject, ['_url', 'model'], tModel(apiClient, fromModel));
+    }
+    const fromSrc = getValueByPath(fromObject, ['src']);
+    if (fromSrc != null) {
+        setValueByPath(toObject, ['batch', 'inputConfig'], batchJobSourceToMldev(apiClient, tBatchJobSource(apiClient, fromSrc)));
+    }
+    const fromConfig = getValueByPath(fromObject, ['config']);
+    if (fromConfig != null) {
+        setValueByPath(toObject, ['config'], createBatchJobConfigToMldev(fromConfig, toObject));
+    }
+    return toObject;
+}
+function getBatchJobParametersToMldev(apiClient, fromObject) {
+    const toObject = {};
+    const fromName = getValueByPath(fromObject, ['name']);
+    if (fromName != null) {
+        setValueByPath(toObject, ['_url', 'name'], tBatchJobName(apiClient, fromName));
+    }
+    const fromConfig = getValueByPath(fromObject, ['config']);
+    if (fromConfig != null) {
+        setValueByPath(toObject, ['config'], fromConfig);
+    }
+    return toObject;
+}
+function cancelBatchJobParametersToMldev(apiClient, fromObject) {
+    const toObject = {};
+    const fromName = getValueByPath(fromObject, ['name']);
+    if (fromName != null) {
+        setValueByPath(toObject, ['_url', 'name'], tBatchJobName(apiClient, fromName));
+    }
+    const fromConfig = getValueByPath(fromObject, ['config']);
+    if (fromConfig != null) {
+        setValueByPath(toObject, ['config'], fromConfig);
+    }
+    return toObject;
+}
+function listBatchJobsConfigToMldev(fromObject, parentObject) {
+    const toObject = {};
+    const fromPageSize = getValueByPath(fromObject, ['pageSize']);
+    if (parentObject !== undefined && fromPageSize != null) {
+        setValueByPath(parentObject, ['_query', 'pageSize'], fromPageSize);
+    }
+    const fromPageToken = getValueByPath(fromObject, ['pageToken']);
+    if (parentObject !== undefined && fromPageToken != null) {
+        setValueByPath(parentObject, ['_query', 'pageToken'], fromPageToken);
+    }
+    if (getValueByPath(fromObject, ['filter']) !== undefined) {
+        throw new Error('filter parameter is not supported in Gemini API.');
+    }
+    return toObject;
+}
+function listBatchJobsParametersToMldev(fromObject) {
+    const toObject = {};
+    const fromConfig = getValueByPath(fromObject, ['config']);
+    if (fromConfig != null) {
+        setValueByPath(toObject, ['config'], listBatchJobsConfigToMldev(fromConfig, toObject));
+    }
+    return toObject;
+}
+function batchJobSourceToVertex(fromObject) {
+    const toObject = {};
+    const fromFormat = getValueByPath(fromObject, ['format']);
+    if (fromFormat != null) {
+        setValueByPath(toObject, ['instancesFormat'], fromFormat);
+    }
+    const fromGcsUri = getValueByPath(fromObject, ['gcsUri']);
+    if (fromGcsUri != null) {
+        setValueByPath(toObject, ['gcsSource', 'uris'], fromGcsUri);
+    }
+    const fromBigqueryUri = getValueByPath(fromObject, ['bigqueryUri']);
+    if (fromBigqueryUri != null) {
+        setValueByPath(toObject, ['bigquerySource', 'inputUri'], fromBigqueryUri);
+    }
+    if (getValueByPath(fromObject, ['fileName']) !== undefined) {
+        throw new Error('fileName parameter is not supported in Vertex AI.');
+    }
+    if (getValueByPath(fromObject, ['inlinedRequests']) !== undefined) {
+        throw new Error('inlinedRequests parameter is not supported in Vertex AI.');
+    }
+    return toObject;
+}
+function batchJobDestinationToVertex(fromObject) {
+    const toObject = {};
+    const fromFormat = getValueByPath(fromObject, ['format']);
+    if (fromFormat != null) {
+        setValueByPath(toObject, ['predictionsFormat'], fromFormat);
+    }
+    const fromGcsUri = getValueByPath(fromObject, ['gcsUri']);
+    if (fromGcsUri != null) {
+        setValueByPath(toObject, ['gcsDestination', 'outputUriPrefix'], fromGcsUri);
+    }
+    const fromBigqueryUri = getValueByPath(fromObject, ['bigqueryUri']);
+    if (fromBigqueryUri != null) {
+        setValueByPath(toObject, ['bigqueryDestination', 'outputUri'], fromBigqueryUri);
+    }
+    if (getValueByPath(fromObject, ['fileName']) !== undefined) {
+        throw new Error('fileName parameter is not supported in Vertex AI.');
+    }
+    if (getValueByPath(fromObject, ['inlinedResponses']) !== undefined) {
+        throw new Error('inlinedResponses parameter is not supported in Vertex AI.');
+    }
+    return toObject;
+}
+function createBatchJobConfigToVertex(fromObject, parentObject) {
+    const toObject = {};
+    const fromDisplayName = getValueByPath(fromObject, ['displayName']);
+    if (parentObject !== undefined && fromDisplayName != null) {
+        setValueByPath(parentObject, ['displayName'], fromDisplayName);
+    }
+    const fromDest = getValueByPath(fromObject, ['dest']);
+    if (parentObject !== undefined && fromDest != null) {
+        setValueByPath(parentObject, ['outputConfig'], batchJobDestinationToVertex(tBatchJobDestination(fromDest)));
+    }
+    return toObject;
+}
+function createBatchJobParametersToVertex(apiClient, fromObject) {
+    const toObject = {};
+    const fromModel = getValueByPath(fromObject, ['model']);
+    if (fromModel != null) {
+        setValueByPath(toObject, ['model'], tModel(apiClient, fromModel));
+    }
+    const fromSrc = getValueByPath(fromObject, ['src']);
+    if (fromSrc != null) {
+        setValueByPath(toObject, ['inputConfig'], batchJobSourceToVertex(tBatchJobSource(apiClient, fromSrc)));
+    }
+    const fromConfig = getValueByPath(fromObject, ['config']);
+    if (fromConfig != null) {
+        setValueByPath(toObject, ['config'], createBatchJobConfigToVertex(fromConfig, toObject));
+    }
+    return toObject;
+}
+function getBatchJobParametersToVertex(apiClient, fromObject) {
+    const toObject = {};
+    const fromName = getValueByPath(fromObject, ['name']);
+    if (fromName != null) {
+        setValueByPath(toObject, ['_url', 'name'], tBatchJobName(apiClient, fromName));
+    }
+    const fromConfig = getValueByPath(fromObject, ['config']);
+    if (fromConfig != null) {
+        setValueByPath(toObject, ['config'], fromConfig);
+    }
+    return toObject;
+}
+function cancelBatchJobParametersToVertex(apiClient, fromObject) {
+    const toObject = {};
+    const fromName = getValueByPath(fromObject, ['name']);
+    if (fromName != null) {
+        setValueByPath(toObject, ['_url', 'name'], tBatchJobName(apiClient, fromName));
+    }
+    const fromConfig = getValueByPath(fromObject, ['config']);
+    if (fromConfig != null) {
+        setValueByPath(toObject, ['config'], fromConfig);
+    }
+    return toObject;
+}
+function listBatchJobsConfigToVertex(fromObject, parentObject) {
+    const toObject = {};
+    const fromPageSize = getValueByPath(fromObject, ['pageSize']);
+    if (parentObject !== undefined && fromPageSize != null) {
+        setValueByPath(parentObject, ['_query', 'pageSize'], fromPageSize);
+    }
+    const fromPageToken = getValueByPath(fromObject, ['pageToken']);
+    if (parentObject !== undefined && fromPageToken != null) {
+        setValueByPath(parentObject, ['_query', 'pageToken'], fromPageToken);
+    }
+    const fromFilter = getValueByPath(fromObject, ['filter']);
+    if (parentObject !== undefined && fromFilter != null) {
+        setValueByPath(parentObject, ['_query', 'filter'], fromFilter);
+    }
+    return toObject;
+}
+function listBatchJobsParametersToVertex(fromObject) {
+    const toObject = {};
+    const fromConfig = getValueByPath(fromObject, ['config']);
+    if (fromConfig != null) {
+        setValueByPath(toObject, ['config'], listBatchJobsConfigToVertex(fromConfig, toObject));
+    }
+    return toObject;
+}
+function jobErrorFromMldev() {
+    const toObject = {};
+    return toObject;
+}
+function videoMetadataFromMldev$2(fromObject) {
+    const toObject = {};
+    const fromFps = getValueByPath(fromObject, ['fps']);
+    if (fromFps != null) {
+        setValueByPath(toObject, ['fps'], fromFps);
+    }
+    const fromEndOffset = getValueByPath(fromObject, ['endOffset']);
+    if (fromEndOffset != null) {
+        setValueByPath(toObject, ['endOffset'], fromEndOffset);
+    }
+    const fromStartOffset = getValueByPath(fromObject, ['startOffset']);
+    if (fromStartOffset != null) {
+        setValueByPath(toObject, ['startOffset'], fromStartOffset);
+    }
+    return toObject;
+}
+function blobFromMldev$2(fromObject) {
+    const toObject = {};
+    const fromData = getValueByPath(fromObject, ['data']);
+    if (fromData != null) {
+        setValueByPath(toObject, ['data'], fromData);
+    }
+    const fromMimeType = getValueByPath(fromObject, ['mimeType']);
+    if (fromMimeType != null) {
+        setValueByPath(toObject, ['mimeType'], fromMimeType);
+    }
+    return toObject;
+}
+function fileDataFromMldev$2(fromObject) {
+    const toObject = {};
+    const fromFileUri = getValueByPath(fromObject, ['fileUri']);
+    if (fromFileUri != null) {
+        setValueByPath(toObject, ['fileUri'], fromFileUri);
+    }
+    const fromMimeType = getValueByPath(fromObject, ['mimeType']);
+    if (fromMimeType != null) {
+        setValueByPath(toObject, ['mimeType'], fromMimeType);
+    }
+    return toObject;
+}
+function partFromMldev$2(fromObject) {
+    const toObject = {};
+    const fromVideoMetadata = getValueByPath(fromObject, [
+        'videoMetadata',
+    ]);
+    if (fromVideoMetadata != null) {
+        setValueByPath(toObject, ['videoMetadata'], videoMetadataFromMldev$2(fromVideoMetadata));
+    }
+    const fromThought = getValueByPath(fromObject, ['thought']);
+    if (fromThought != null) {
+        setValueByPath(toObject, ['thought'], fromThought);
+    }
+    const fromInlineData = getValueByPath(fromObject, ['inlineData']);
+    if (fromInlineData != null) {
+        setValueByPath(toObject, ['inlineData'], blobFromMldev$2(fromInlineData));
+    }
+    const fromFileData = getValueByPath(fromObject, ['fileData']);
+    if (fromFileData != null) {
+        setValueByPath(toObject, ['fileData'], fileDataFromMldev$2(fromFileData));
+    }
+    const fromThoughtSignature = getValueByPath(fromObject, [
+        'thoughtSignature',
+    ]);
+    if (fromThoughtSignature != null) {
+        setValueByPath(toObject, ['thoughtSignature'], fromThoughtSignature);
+    }
+    const fromCodeExecutionResult = getValueByPath(fromObject, [
+        'codeExecutionResult',
+    ]);
+    if (fromCodeExecutionResult != null) {
+        setValueByPath(toObject, ['codeExecutionResult'], fromCodeExecutionResult);
+    }
+    const fromExecutableCode = getValueByPath(fromObject, [
+        'executableCode',
+    ]);
+    if (fromExecutableCode != null) {
+        setValueByPath(toObject, ['executableCode'], fromExecutableCode);
+    }
+    const fromFunctionCall = getValueByPath(fromObject, ['functionCall']);
+    if (fromFunctionCall != null) {
+        setValueByPath(toObject, ['functionCall'], fromFunctionCall);
+    }
+    const fromFunctionResponse = getValueByPath(fromObject, [
+        'functionResponse',
+    ]);
+    if (fromFunctionResponse != null) {
+        setValueByPath(toObject, ['functionResponse'], fromFunctionResponse);
+    }
+    const fromText = getValueByPath(fromObject, ['text']);
+    if (fromText != null) {
+        setValueByPath(toObject, ['text'], fromText);
+    }
+    return toObject;
+}
+function contentFromMldev$2(fromObject) {
+    const toObject = {};
+    const fromParts = getValueByPath(fromObject, ['parts']);
+    if (fromParts != null) {
+        let transformedList = fromParts;
+        if (Array.isArray(transformedList)) {
+            transformedList = transformedList.map((item) => {
+                return partFromMldev$2(item);
+            });
+        }
+        setValueByPath(toObject, ['parts'], transformedList);
+    }
+    const fromRole = getValueByPath(fromObject, ['role']);
+    if (fromRole != null) {
+        setValueByPath(toObject, ['role'], fromRole);
+    }
+    return toObject;
+}
+function citationMetadataFromMldev$1(fromObject) {
+    const toObject = {};
+    const fromCitations = getValueByPath(fromObject, ['citationSources']);
+    if (fromCitations != null) {
+        setValueByPath(toObject, ['citations'], fromCitations);
+    }
+    return toObject;
+}
+function urlMetadataFromMldev$2(fromObject) {
+    const toObject = {};
+    const fromRetrievedUrl = getValueByPath(fromObject, ['retrievedUrl']);
+    if (fromRetrievedUrl != null) {
+        setValueByPath(toObject, ['retrievedUrl'], fromRetrievedUrl);
+    }
+    const fromUrlRetrievalStatus = getValueByPath(fromObject, [
+        'urlRetrievalStatus',
+    ]);
+    if (fromUrlRetrievalStatus != null) {
+        setValueByPath(toObject, ['urlRetrievalStatus'], fromUrlRetrievalStatus);
+    }
+    return toObject;
+}
+function urlContextMetadataFromMldev$2(fromObject) {
+    const toObject = {};
+    const fromUrlMetadata = getValueByPath(fromObject, ['urlMetadata']);
+    if (fromUrlMetadata != null) {
+        let transformedList = fromUrlMetadata;
+        if (Array.isArray(transformedList)) {
+            transformedList = transformedList.map((item) => {
+                return urlMetadataFromMldev$2(item);
+            });
+        }
+        setValueByPath(toObject, ['urlMetadata'], transformedList);
+    }
+    return toObject;
+}
+function candidateFromMldev$1(fromObject) {
+    const toObject = {};
+    const fromContent = getValueByPath(fromObject, ['content']);
+    if (fromContent != null) {
+        setValueByPath(toObject, ['content'], contentFromMldev$2(fromContent));
+    }
+    const fromCitationMetadata = getValueByPath(fromObject, [
+        'citationMetadata',
+    ]);
+    if (fromCitationMetadata != null) {
+        setValueByPath(toObject, ['citationMetadata'], citationMetadataFromMldev$1(fromCitationMetadata));
+    }
+    const fromTokenCount = getValueByPath(fromObject, ['tokenCount']);
+    if (fromTokenCount != null) {
+        setValueByPath(toObject, ['tokenCount'], fromTokenCount);
+    }
+    const fromFinishReason = getValueByPath(fromObject, ['finishReason']);
+    if (fromFinishReason != null) {
+        setValueByPath(toObject, ['finishReason'], fromFinishReason);
+    }
+    const fromUrlContextMetadata = getValueByPath(fromObject, [
+        'urlContextMetadata',
+    ]);
+    if (fromUrlContextMetadata != null) {
+        setValueByPath(toObject, ['urlContextMetadata'], urlContextMetadataFromMldev$2(fromUrlContextMetadata));
+    }
+    const fromAvgLogprobs = getValueByPath(fromObject, ['avgLogprobs']);
+    if (fromAvgLogprobs != null) {
+        setValueByPath(toObject, ['avgLogprobs'], fromAvgLogprobs);
+    }
+    const fromGroundingMetadata = getValueByPath(fromObject, [
+        'groundingMetadata',
+    ]);
+    if (fromGroundingMetadata != null) {
+        setValueByPath(toObject, ['groundingMetadata'], fromGroundingMetadata);
+    }
+    const fromIndex = getValueByPath(fromObject, ['index']);
+    if (fromIndex != null) {
+        setValueByPath(toObject, ['index'], fromIndex);
+    }
+    const fromLogprobsResult = getValueByPath(fromObject, [
+        'logprobsResult',
+    ]);
+    if (fromLogprobsResult != null) {
+        setValueByPath(toObject, ['logprobsResult'], fromLogprobsResult);
+    }
+    const fromSafetyRatings = getValueByPath(fromObject, [
+        'safetyRatings',
+    ]);
+    if (fromSafetyRatings != null) {
+        setValueByPath(toObject, ['safetyRatings'], fromSafetyRatings);
+    }
+    return toObject;
+}
+function generateContentResponseFromMldev$1(fromObject) {
+    const toObject = {};
+    const fromCandidates = getValueByPath(fromObject, ['candidates']);
+    if (fromCandidates != null) {
+        let transformedList = fromCandidates;
+        if (Array.isArray(transformedList)) {
+            transformedList = transformedList.map((item) => {
+                return candidateFromMldev$1(item);
+            });
+        }
+        setValueByPath(toObject, ['candidates'], transformedList);
+    }
+    const fromModelVersion = getValueByPath(fromObject, ['modelVersion']);
+    if (fromModelVersion != null) {
+        setValueByPath(toObject, ['modelVersion'], fromModelVersion);
+    }
+    const fromPromptFeedback = getValueByPath(fromObject, [
+        'promptFeedback',
+    ]);
+    if (fromPromptFeedback != null) {
+        setValueByPath(toObject, ['promptFeedback'], fromPromptFeedback);
+    }
+    const fromUsageMetadata = getValueByPath(fromObject, [
+        'usageMetadata',
+    ]);
+    if (fromUsageMetadata != null) {
+        setValueByPath(toObject, ['usageMetadata'], fromUsageMetadata);
+    }
+    return toObject;
+}
+function inlinedResponseFromMldev(fromObject) {
+    const toObject = {};
+    const fromResponse = getValueByPath(fromObject, ['response']);
+    if (fromResponse != null) {
+        setValueByPath(toObject, ['response'], generateContentResponseFromMldev$1(fromResponse));
+    }
+    const fromError = getValueByPath(fromObject, ['error']);
+    if (fromError != null) {
+        setValueByPath(toObject, ['error'], jobErrorFromMldev());
+    }
+    return toObject;
+}
+function batchJobDestinationFromMldev(fromObject) {
+    const toObject = {};
+    const fromFileName = getValueByPath(fromObject, ['responsesFile']);
+    if (fromFileName != null) {
+        setValueByPath(toObject, ['fileName'], fromFileName);
+    }
+    const fromInlinedResponses = getValueByPath(fromObject, [
+        'inlinedResponses',
+        'inlinedResponses',
+    ]);
+    if (fromInlinedResponses != null) {
+        let transformedList = fromInlinedResponses;
+        if (Array.isArray(transformedList)) {
+            transformedList = transformedList.map((item) => {
+                return inlinedResponseFromMldev(item);
+            });
+        }
+        setValueByPath(toObject, ['inlinedResponses'], transformedList);
+    }
+    return toObject;
+}
+function batchJobFromMldev(fromObject) {
+    const toObject = {};
+    const fromName = getValueByPath(fromObject, ['name']);
+    if (fromName != null) {
+        setValueByPath(toObject, ['name'], fromName);
+    }
+    const fromDisplayName = getValueByPath(fromObject, [
+        'metadata',
+        'displayName',
+    ]);
+    if (fromDisplayName != null) {
+        setValueByPath(toObject, ['displayName'], fromDisplayName);
+    }
+    const fromState = getValueByPath(fromObject, ['metadata', 'state']);
+    if (fromState != null) {
+        setValueByPath(toObject, ['state'], tJobState(fromState));
+    }
+    const fromCreateTime = getValueByPath(fromObject, [
+        'metadata',
+        'createTime',
+    ]);
+    if (fromCreateTime != null) {
+        setValueByPath(toObject, ['createTime'], fromCreateTime);
+    }
+    const fromEndTime = getValueByPath(fromObject, [
+        'metadata',
+        'endTime',
+    ]);
+    if (fromEndTime != null) {
+        setValueByPath(toObject, ['endTime'], fromEndTime);
+    }
+    const fromUpdateTime = getValueByPath(fromObject, [
+        'metadata',
+        'updateTime',
+    ]);
+    if (fromUpdateTime != null) {
+        setValueByPath(toObject, ['updateTime'], fromUpdateTime);
+    }
+    const fromModel = getValueByPath(fromObject, ['metadata', 'model']);
+    if (fromModel != null) {
+        setValueByPath(toObject, ['model'], fromModel);
+    }
+    const fromDest = getValueByPath(fromObject, ['metadata', 'output']);
+    if (fromDest != null) {
+        setValueByPath(toObject, ['dest'], batchJobDestinationFromMldev(fromDest));
+    }
+    return toObject;
+}
+function listBatchJobsResponseFromMldev(fromObject) {
+    const toObject = {};
+    const fromNextPageToken = getValueByPath(fromObject, [
+        'nextPageToken',
+    ]);
+    if (fromNextPageToken != null) {
+        setValueByPath(toObject, ['nextPageToken'], fromNextPageToken);
+    }
+    const fromBatchJobs = getValueByPath(fromObject, ['operations']);
+    if (fromBatchJobs != null) {
+        let transformedList = fromBatchJobs;
+        if (Array.isArray(transformedList)) {
+            transformedList = transformedList.map((item) => {
+                return batchJobFromMldev(item);
+            });
+        }
+        setValueByPath(toObject, ['batchJobs'], transformedList);
+    }
+    return toObject;
+}
+function jobErrorFromVertex(fromObject) {
+    const toObject = {};
+    const fromDetails = getValueByPath(fromObject, ['details']);
+    if (fromDetails != null) {
+        setValueByPath(toObject, ['details'], fromDetails);
+    }
+    const fromCode = getValueByPath(fromObject, ['code']);
+    if (fromCode != null) {
+        setValueByPath(toObject, ['code'], fromCode);
+    }
+    const fromMessage = getValueByPath(fromObject, ['message']);
+    if (fromMessage != null) {
+        setValueByPath(toObject, ['message'], fromMessage);
+    }
+    return toObject;
+}
+function batchJobSourceFromVertex(fromObject) {
+    const toObject = {};
+    const fromFormat = getValueByPath(fromObject, ['instancesFormat']);
+    if (fromFormat != null) {
+        setValueByPath(toObject, ['format'], fromFormat);
+    }
+    const fromGcsUri = getValueByPath(fromObject, ['gcsSource', 'uris']);
+    if (fromGcsUri != null) {
+        setValueByPath(toObject, ['gcsUri'], fromGcsUri);
+    }
+    const fromBigqueryUri = getValueByPath(fromObject, [
+        'bigquerySource',
+        'inputUri',
+    ]);
+    if (fromBigqueryUri != null) {
+        setValueByPath(toObject, ['bigqueryUri'], fromBigqueryUri);
+    }
+    return toObject;
+}
+function batchJobDestinationFromVertex(fromObject) {
+    const toObject = {};
+    const fromFormat = getValueByPath(fromObject, ['predictionsFormat']);
+    if (fromFormat != null) {
+        setValueByPath(toObject, ['format'], fromFormat);
+    }
+    const fromGcsUri = getValueByPath(fromObject, [
+        'gcsDestination',
+        'outputUriPrefix',
+    ]);
+    if (fromGcsUri != null) {
+        setValueByPath(toObject, ['gcsUri'], fromGcsUri);
+    }
+    const fromBigqueryUri = getValueByPath(fromObject, [
+        'bigqueryDestination',
+        'outputUri',
+    ]);
+    if (fromBigqueryUri != null) {
+        setValueByPath(toObject, ['bigqueryUri'], fromBigqueryUri);
+    }
+    return toObject;
+}
+function batchJobFromVertex(fromObject) {
+    const toObject = {};
+    const fromName = getValueByPath(fromObject, ['name']);
+    if (fromName != null) {
+        setValueByPath(toObject, ['name'], fromName);
+    }
+    const fromDisplayName = getValueByPath(fromObject, ['displayName']);
+    if (fromDisplayName != null) {
+        setValueByPath(toObject, ['displayName'], fromDisplayName);
+    }
+    const fromState = getValueByPath(fromObject, ['state']);
+    if (fromState != null) {
+        setValueByPath(toObject, ['state'], tJobState(fromState));
+    }
+    const fromError = getValueByPath(fromObject, ['error']);
+    if (fromError != null) {
+        setValueByPath(toObject, ['error'], jobErrorFromVertex(fromError));
+    }
+    const fromCreateTime = getValueByPath(fromObject, ['createTime']);
+    if (fromCreateTime != null) {
+        setValueByPath(toObject, ['createTime'], fromCreateTime);
+    }
+    const fromStartTime = getValueByPath(fromObject, ['startTime']);
+    if (fromStartTime != null) {
+        setValueByPath(toObject, ['startTime'], fromStartTime);
+    }
+    const fromEndTime = getValueByPath(fromObject, ['endTime']);
+    if (fromEndTime != null) {
+        setValueByPath(toObject, ['endTime'], fromEndTime);
+    }
+    const fromUpdateTime = getValueByPath(fromObject, ['updateTime']);
+    if (fromUpdateTime != null) {
+        setValueByPath(toObject, ['updateTime'], fromUpdateTime);
+    }
+    const fromModel = getValueByPath(fromObject, ['model']);
+    if (fromModel != null) {
+        setValueByPath(toObject, ['model'], fromModel);
+    }
+    const fromSrc = getValueByPath(fromObject, ['inputConfig']);
+    if (fromSrc != null) {
+        setValueByPath(toObject, ['src'], batchJobSourceFromVertex(fromSrc));
+    }
+    const fromDest = getValueByPath(fromObject, ['outputConfig']);
+    if (fromDest != null) {
+        setValueByPath(toObject, ['dest'], batchJobDestinationFromVertex(fromDest));
+    }
+    return toObject;
+}
+function listBatchJobsResponseFromVertex(fromObject) {
+    const toObject = {};
+    const fromNextPageToken = getValueByPath(fromObject, [
+        'nextPageToken',
+    ]);
+    if (fromNextPageToken != null) {
+        setValueByPath(toObject, ['nextPageToken'], fromNextPageToken);
+    }
+    const fromBatchJobs = getValueByPath(fromObject, [
+        'batchPredictionJobs',
+    ]);
+    if (fromBatchJobs != null) {
+        let transformedList = fromBatchJobs;
+        if (Array.isArray(transformedList)) {
+            transformedList = transformedList.map((item) => {
+                return batchJobFromVertex(item);
+            });
+        }
+        setValueByPath(toObject, ['batchJobs'], transformedList);
+    }
+    return toObject;
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Pagers for the GenAI List APIs.
+ */
+exports.PagedItem = void 0;
+(function (PagedItem) {
+    PagedItem["PAGED_ITEM_BATCH_JOBS"] = "batchJobs";
+    PagedItem["PAGED_ITEM_MODELS"] = "models";
+    PagedItem["PAGED_ITEM_TUNING_JOBS"] = "tuningJobs";
+    PagedItem["PAGED_ITEM_FILES"] = "files";
+    PagedItem["PAGED_ITEM_CACHED_CONTENTS"] = "cachedContents";
+})(exports.PagedItem || (exports.PagedItem = {}));
+/**
+ * Pager class for iterating through paginated results.
+ */
+class Pager {
+    constructor(name, request, response, params) {
+        this.pageInternal = [];
+        this.paramsInternal = {};
+        this.requestInternal = request;
+        this.init(name, response, params);
+    }
+    init(name, response, params) {
+        var _a, _b;
+        this.nameInternal = name;
+        this.pageInternal = response[this.nameInternal] || [];
+        this.idxInternal = 0;
+        let requestParams = { config: {} };
+        if (!params) {
+            requestParams = { config: {} };
+        }
+        else if (typeof params === 'object') {
+            requestParams = Object.assign({}, params);
+        }
+        else {
+            requestParams = params;
+        }
+        if (requestParams['config']) {
+            requestParams['config']['pageToken'] = response['nextPageToken'];
+        }
+        this.paramsInternal = requestParams;
+        this.pageInternalSize =
+            (_b = (_a = requestParams['config']) === null || _a === void 0 ? void 0 : _a['pageSize']) !== null && _b !== void 0 ? _b : this.pageInternal.length;
+    }
+    initNextPage(response) {
+        this.init(this.nameInternal, response, this.paramsInternal);
+    }
+    /**
+     * Returns the current page, which is a list of items.
+     *
+     * @remarks
+     * The first page is retrieved when the pager is created. The returned list of
+     * items could be a subset of the entire list.
+     */
+    get page() {
+        return this.pageInternal;
+    }
+    /**
+     * Returns the type of paged item (for example, ``batch_jobs``).
+     */
+    get name() {
+        return this.nameInternal;
+    }
+    /**
+     * Returns the length of the page fetched each time by this pager.
+     *
+     * @remarks
+     * The number of items in the page is less than or equal to the page length.
+     */
+    get pageSize() {
+        return this.pageInternalSize;
+    }
+    /**
+     * Returns the parameters when making the API request for the next page.
+     *
+     * @remarks
+     * Parameters contain a set of optional configs that can be
+     * used to customize the API request. For example, the `pageToken` parameter
+     * contains the token to request the next page.
+     */
+    get params() {
+        return this.paramsInternal;
+    }
+    /**
+     * Returns the total number of items in the current page.
+     */
+    get pageLength() {
+        return this.pageInternal.length;
+    }
+    /**
+     * Returns the item at the given index.
+     */
+    getItem(index) {
+        return this.pageInternal[index];
+    }
+    /**
+     * Returns an async iterator that support iterating through all items
+     * retrieved from the API.
+     *
+     * @remarks
+     * The iterator will automatically fetch the next page if there are more items
+     * to fetch from the API.
+     *
+     * @example
+     *
+     * ```ts
+     * const pager = await ai.files.list({config: {pageSize: 10}});
+     * for await (const file of pager) {
+     *   console.log(file.name);
+     * }
+     * ```
+     */
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                if (this.idxInternal >= this.pageLength) {
+                    if (this.hasNextPage()) {
+                        await this.nextPage();
+                    }
+                    else {
+                        return { value: undefined, done: true };
+                    }
+                }
+                const item = this.getItem(this.idxInternal);
+                this.idxInternal += 1;
+                return { value: item, done: false };
+            },
+            return: async () => {
+                return { value: undefined, done: true };
+            },
+        };
+    }
+    /**
+     * Fetches the next page of items. This makes a new API request.
+     *
+     * @throws {Error} If there are no more pages to fetch.
+     *
+     * @example
+     *
+     * ```ts
+     * const pager = await ai.files.list({config: {pageSize: 10}});
+     * let page = pager.page;
+     * while (true) {
+     *   for (const file of page) {
+     *     console.log(file.name);
+     *   }
+     *   if (!pager.hasNextPage()) {
+     *     break;
+     *   }
+     *   page = await pager.nextPage();
+     * }
+     * ```
+     */
+    async nextPage() {
+        if (!this.hasNextPage()) {
+            throw new Error('No more pages to fetch.');
+        }
+        const response = await this.requestInternal(this.params);
+        this.initNextPage(response);
+        return this.page;
+    }
+    /**
+     * Returns true if there are more pages to fetch from the API.
+     */
+    hasNextPage() {
+        var _a;
+        if (((_a = this.params['config']) === null || _a === void 0 ? void 0 : _a['pageToken']) !== undefined) {
+            return true;
+        }
+        return false;
+    }
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class Batches extends BaseModule {
+    constructor(apiClient) {
+        super();
+        this.apiClient = apiClient;
+        /**
+         * Create batch job.
+         *
+         * @param params - The parameters for create batch job request.
+         * @return The created batch job.
+         *
+         * @example
+         * ```ts
+         * const response = await ai.batches.create({
+         *   model: 'gemini-2.0-flash',
+         *   src: {gcsUri: 'gs://bucket/path/to/file.jsonl', format: 'jsonl'},
+         *   config: {
+         *     dest: {gcsUri: 'gs://bucket/path/output/directory', format: 'jsonl'},
+         *   }
+         * });
+         * console.log(response);
+         * ```
+         */
+        this.create = async (params) => {
+            if (this.apiClient.isVertexAI()) {
+                if (Array.isArray(params.src)) {
+                    throw new Error('InlinedRequest[] is not supported in Vertex AI. Please use ' +
+                        'Google Cloud Storage URI or BigQuery URI instead.');
+                }
+                params.config = params.config || {};
+                if (params.config.displayName === undefined) {
+                    params.config.displayName = 'genaiBatchJob_';
+                }
+                if (params.config.dest === undefined && typeof params.src === 'string') {
+                    if (params.src.startsWith('gs://') && params.src.endsWith('.jsonl')) {
+                        params.config.dest = `${params.src.slice(0, -6)}/dest`;
+                    }
+                    else if (params.src.startsWith('bq://')) {
+                        params.config.dest = `${params.src}_dest_`;
+                    }
+                    else {
+                        throw new Error('Unsupported source:' + params.src);
+                    }
+                }
+            }
+            return await this.createInternal(params);
+        };
+        /**
+         * Lists batch job configurations.
+         *
+         * @param params - The parameters for the list request.
+         * @return The paginated results of the list of batch jobs.
+         *
+         * @example
+         * ```ts
+         * const batchJobs = await ai.batches.list({config: {'pageSize': 2}});
+         * for await (const batchJob of batchJobs) {
+         *   console.log(batchJob);
+         * }
+         * ```
+         */
+        this.list = async (params = {}) => {
+            return new Pager(exports.PagedItem.PAGED_ITEM_BATCH_JOBS, (x) => this.listInternal(x), await this.listInternal(params), params);
+        };
+    }
+    /**
+     * Internal method to create batch job.
+     *
+     * @param params - The parameters for create batch job request.
+     * @return The created batch job.
+     *
+     */
+    async createInternal(params) {
+        var _a, _b, _c, _d;
+        let response;
+        let path = '';
+        let queryParams = {};
+        if (this.apiClient.isVertexAI()) {
+            const body = createBatchJobParametersToVertex(this.apiClient, params);
+            path = formatMap('batchPredictionJobs', body['_url']);
+            queryParams = body['_query'];
+            delete body['config'];
+            delete body['_url'];
+            delete body['_query'];
+            response = this.apiClient
+                .request({
+                path: path,
+                queryParams: queryParams,
+                body: JSON.stringify(body),
+                httpMethod: 'POST',
+                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
+                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
+            })
+                .then((httpResponse) => {
+                return httpResponse.json();
+            });
+            return response.then((apiResponse) => {
+                const resp = batchJobFromVertex(apiResponse);
+                return resp;
+            });
+        }
+        else {
+            const body = createBatchJobParametersToMldev(this.apiClient, params);
+            path = formatMap('{model}:batchGenerateContent', body['_url']);
+            queryParams = body['_query'];
+            delete body['config'];
+            delete body['_url'];
+            delete body['_query'];
+            response = this.apiClient
+                .request({
+                path: path,
+                queryParams: queryParams,
+                body: JSON.stringify(body),
+                httpMethod: 'POST',
+                httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
+                abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal,
+            })
+                .then((httpResponse) => {
+                return httpResponse.json();
+            });
+            return response.then((apiResponse) => {
+                const resp = batchJobFromMldev(apiResponse);
+                return resp;
+            });
+        }
+    }
+    /**
+     * Gets batch job configurations.
+     *
+     * @param params - The parameters for the get request.
+     * @return The batch job.
+     *
+     * @example
+     * ```ts
+     * await ai.batches.get({name: '...'}); // The server-generated resource name.
+     * ```
+     */
+    async get(params) {
+        var _a, _b, _c, _d;
+        let response;
+        let path = '';
+        let queryParams = {};
+        if (this.apiClient.isVertexAI()) {
+            const body = getBatchJobParametersToVertex(this.apiClient, params);
+            path = formatMap('batchPredictionJobs/{name}', body['_url']);
+            queryParams = body['_query'];
+            delete body['config'];
+            delete body['_url'];
+            delete body['_query'];
+            response = this.apiClient
+                .request({
+                path: path,
+                queryParams: queryParams,
+                body: JSON.stringify(body),
+                httpMethod: 'GET',
+                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
+                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
+            })
+                .then((httpResponse) => {
+                return httpResponse.json();
+            });
+            return response.then((apiResponse) => {
+                const resp = batchJobFromVertex(apiResponse);
+                return resp;
+            });
+        }
+        else {
+            const body = getBatchJobParametersToMldev(this.apiClient, params);
+            path = formatMap('batches/{name}', body['_url']);
+            queryParams = body['_query'];
+            delete body['config'];
+            delete body['_url'];
+            delete body['_query'];
+            response = this.apiClient
+                .request({
+                path: path,
+                queryParams: queryParams,
+                body: JSON.stringify(body),
+                httpMethod: 'GET',
+                httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
+                abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal,
+            })
+                .then((httpResponse) => {
+                return httpResponse.json();
+            });
+            return response.then((apiResponse) => {
+                const resp = batchJobFromMldev(apiResponse);
+                return resp;
+            });
+        }
+    }
+    /**
+     * Cancels a batch job.
+     *
+     * @param params - The parameters for the cancel request.
+     * @return The empty response returned by the API.
+     *
+     * @example
+     * ```ts
+     * await ai.batches.cancel({name: '...'}); // The server-generated resource name.
+     * ```
+     */
+    async cancel(params) {
+        var _a, _b, _c, _d;
+        let path = '';
+        let queryParams = {};
+        if (this.apiClient.isVertexAI()) {
+            const body = cancelBatchJobParametersToVertex(this.apiClient, params);
+            path = formatMap('batchPredictionJobs/{name}:cancel', body['_url']);
+            queryParams = body['_query'];
+            delete body['config'];
+            delete body['_url'];
+            delete body['_query'];
+            await this.apiClient.request({
+                path: path,
+                queryParams: queryParams,
+                body: JSON.stringify(body),
+                httpMethod: 'POST',
+                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
+                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
+            });
+        }
+        else {
+            const body = cancelBatchJobParametersToMldev(this.apiClient, params);
+            path = formatMap('batches/{name}:cancel', body['_url']);
+            queryParams = body['_query'];
+            delete body['config'];
+            delete body['_url'];
+            delete body['_query'];
+            await this.apiClient.request({
+                path: path,
+                queryParams: queryParams,
+                body: JSON.stringify(body),
+                httpMethod: 'POST',
+                httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
+                abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal,
+            });
+        }
+    }
+    async listInternal(params) {
+        var _a, _b, _c, _d;
+        let response;
+        let path = '';
+        let queryParams = {};
+        if (this.apiClient.isVertexAI()) {
+            const body = listBatchJobsParametersToVertex(params);
+            path = formatMap('batchPredictionJobs', body['_url']);
+            queryParams = body['_query'];
+            delete body['config'];
+            delete body['_url'];
+            delete body['_query'];
+            response = this.apiClient
+                .request({
+                path: path,
+                queryParams: queryParams,
+                body: JSON.stringify(body),
+                httpMethod: 'GET',
+                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
+                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
+            })
+                .then((httpResponse) => {
+                return httpResponse.json();
+            });
+            return response.then((apiResponse) => {
+                const resp = listBatchJobsResponseFromVertex(apiResponse);
+                const typedResp = new ListBatchJobsResponse();
+                Object.assign(typedResp, resp);
+                return typedResp;
+            });
         }
-        else if (supportedJsonSchemaFields.has(fieldName)) {
-            filteredSchema[fieldName] = fieldValue;
+        else {
+            const body = listBatchJobsParametersToMldev(params);
+            path = formatMap('batches', body['_url']);
+            queryParams = body['_query'];
+            delete body['config'];
+            delete body['_url'];
+            delete body['_query'];
+            response = this.apiClient
+                .request({
+                path: path,
+                queryParams: queryParams,
+                body: JSON.stringify(body),
+                httpMethod: 'GET',
+                httpOptions: (_c = params.config) === null || _c === void 0 ? void 0 : _c.httpOptions,
+                abortSignal: (_d = params.config) === null || _d === void 0 ? void 0 : _d.abortSignal,
+            })
+                .then((httpResponse) => {
+                return httpResponse.json();
+            });
+            return response.then((apiResponse) => {
+                const resp = listBatchJobsResponseFromMldev(apiResponse);
+                const typedResp = new ListBatchJobsResponse();
+                Object.assign(typedResp, resp);
+                return typedResp;
+            });
         }
     }
-    return filteredSchema;
 }
 
 /**
@@ -3437,183 +5415,6 @@ function listCachedContentsResponseFromVertex(fromObject) {
     return toObject;
 }
 
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * Pagers for the GenAI List APIs.
- */
-exports.PagedItem = void 0;
-(function (PagedItem) {
-    PagedItem["PAGED_ITEM_BATCH_JOBS"] = "batchJobs";
-    PagedItem["PAGED_ITEM_MODELS"] = "models";
-    PagedItem["PAGED_ITEM_TUNING_JOBS"] = "tuningJobs";
-    PagedItem["PAGED_ITEM_FILES"] = "files";
-    PagedItem["PAGED_ITEM_CACHED_CONTENTS"] = "cachedContents";
-})(exports.PagedItem || (exports.PagedItem = {}));
-/**
- * Pager class for iterating through paginated results.
- */
-class Pager {
-    constructor(name, request, response, params) {
-        this.pageInternal = [];
-        this.paramsInternal = {};
-        this.requestInternal = request;
-        this.init(name, response, params);
-    }
-    init(name, response, params) {
-        var _a, _b;
-        this.nameInternal = name;
-        this.pageInternal = response[this.nameInternal] || [];
-        this.idxInternal = 0;
-        let requestParams = { config: {} };
-        if (!params) {
-            requestParams = { config: {} };
-        }
-        else if (typeof params === 'object') {
-            requestParams = Object.assign({}, params);
-        }
-        else {
-            requestParams = params;
-        }
-        if (requestParams['config']) {
-            requestParams['config']['pageToken'] = response['nextPageToken'];
-        }
-        this.paramsInternal = requestParams;
-        this.pageInternalSize =
-            (_b = (_a = requestParams['config']) === null || _a === void 0 ? void 0 : _a['pageSize']) !== null && _b !== void 0 ? _b : this.pageInternal.length;
-    }
-    initNextPage(response) {
-        this.init(this.nameInternal, response, this.paramsInternal);
-    }
-    /**
-     * Returns the current page, which is a list of items.
-     *
-     * @remarks
-     * The first page is retrieved when the pager is created. The returned list of
-     * items could be a subset of the entire list.
-     */
-    get page() {
-        return this.pageInternal;
-    }
-    /**
-     * Returns the type of paged item (for example, ``batch_jobs``).
-     */
-    get name() {
-        return this.nameInternal;
-    }
-    /**
-     * Returns the length of the page fetched each time by this pager.
-     *
-     * @remarks
-     * The number of items in the page is less than or equal to the page length.
-     */
-    get pageSize() {
-        return this.pageInternalSize;
-    }
-    /**
-     * Returns the parameters when making the API request for the next page.
-     *
-     * @remarks
-     * Parameters contain a set of optional configs that can be
-     * used to customize the API request. For example, the `pageToken` parameter
-     * contains the token to request the next page.
-     */
-    get params() {
-        return this.paramsInternal;
-    }
-    /**
-     * Returns the total number of items in the current page.
-     */
-    get pageLength() {
-        return this.pageInternal.length;
-    }
-    /**
-     * Returns the item at the given index.
-     */
-    getItem(index) {
-        return this.pageInternal[index];
-    }
-    /**
-     * Returns an async iterator that support iterating through all items
-     * retrieved from the API.
-     *
-     * @remarks
-     * The iterator will automatically fetch the next page if there are more items
-     * to fetch from the API.
-     *
-     * @example
-     *
-     * ```ts
-     * const pager = await ai.files.list({config: {pageSize: 10}});
-     * for await (const file of pager) {
-     *   console.log(file.name);
-     * }
-     * ```
-     */
-    [Symbol.asyncIterator]() {
-        return {
-            next: async () => {
-                if (this.idxInternal >= this.pageLength) {
-                    if (this.hasNextPage()) {
-                        await this.nextPage();
-                    }
-                    else {
-                        return { value: undefined, done: true };
-                    }
-                }
-                const item = this.getItem(this.idxInternal);
-                this.idxInternal += 1;
-                return { value: item, done: false };
-            },
-            return: async () => {
-                return { value: undefined, done: true };
-            },
-        };
-    }
-    /**
-     * Fetches the next page of items. This makes a new API request.
-     *
-     * @throws {Error} If there are no more pages to fetch.
-     *
-     * @example
-     *
-     * ```ts
-     * const pager = await ai.files.list({config: {pageSize: 10}});
-     * let page = pager.page;
-     * while (true) {
-     *   for (const file of page) {
-     *     console.log(file.name);
-     *   }
-     *   if (!pager.hasNextPage()) {
-     *     break;
-     *   }
-     *   page = await pager.nextPage();
-     * }
-     * ```
-     */
-    async nextPage() {
-        if (!this.hasNextPage()) {
-            throw new Error('No more pages to fetch.');
-        }
-        const response = await this.requestInternal(this.params);
-        this.initNextPage(response);
-        return this.page;
-    }
-    /**
-     * Returns true if there are more pages to fetch from the API.
-     */
-    hasNextPage() {
-        var _a;
-        if (((_a = this.params['config']) === null || _a === void 0 ? void 0 : _a['pageToken']) !== undefined) {
-            return true;
-        }
-        return false;
-    }
-}
-
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -4394,7 +6195,7 @@ const CONTENT_TYPE_HEADER = 'Content-Type';
 const SERVER_TIMEOUT_HEADER = 'X-Server-Timeout';
 const USER_AGENT_HEADER = 'User-Agent';
 const GOOGLE_API_CLIENT_HEADER = 'x-goog-api-client';
-const SDK_VERSION = '1.6.0'; // x-release-please-version
+const SDK_VERSION = '1.7.0'; // x-release-please-version
 const LIBRARY_LABEL = `google-genai-sdk/${SDK_VERSION}`;
 const VERTEX_AI_API_DEFAULT_VERSION = 'v1beta1';
 const GOOGLE_AI_API_DEFAULT_VERSION = 'v1beta';
@@ -8451,6 +10252,12 @@ function generateContentConfigToMldev(apiClient, fromObject, parentObject) {
     if (fromResponseSchema != null) {
         setValueByPath(toObject, ['responseSchema'], schemaToMldev(tSchema(fromResponseSchema)));
     }
+    const fromResponseJsonSchema = getValueByPath(fromObject, [
+        'responseJsonSchema',
+    ]);
+    if (fromResponseJsonSchema != null) {
+        setValueByPath(toObject, ['responseJsonSchema'], fromResponseJsonSchema);
+    }
     if (getValueByPath(fromObject, ['routingConfig']) !== undefined) {
         throw new Error('routingConfig parameter is not supported in Gemini API.');
     }
@@ -8865,6 +10672,9 @@ function generateVideosConfigToMldev(fromObject, parentObject) {
     if (getValueByPath(fromObject, ['lastFrame']) !== undefined) {
         throw new Error('lastFrame parameter is not supported in Gemini API.');
     }
+    if (getValueByPath(fromObject, ['compressionQuality']) !== undefined) {
+        throw new Error('compressionQuality parameter is not supported in Gemini API.');
+    }
     return toObject;
 }
 function generateVideosParametersToMldev(apiClient, fromObject) {
@@ -9500,6 +11310,12 @@ function generateContentConfigToVertex(apiClient, fromObject, parentObject) {
     if (fromResponseSchema != null) {
         setValueByPath(toObject, ['responseSchema'], schemaToVertex(tSchema(fromResponseSchema)));
     }
+    const fromResponseJsonSchema = getValueByPath(fromObject, [
+        'responseJsonSchema',
+    ]);
+    if (fromResponseJsonSchema != null) {
+        setValueByPath(toObject, ['responseJsonSchema'], fromResponseJsonSchema);
+    }
     const fromRoutingConfig = getValueByPath(fromObject, [
         'routingConfig',
     ]);
@@ -9988,6 +11804,18 @@ function upscaleImageAPIConfigInternalToVertex(fromObject, parentObject) {
     if (parentObject !== undefined && fromOutputCompressionQuality != null) {
         setValueByPath(parentObject, ['parameters', 'outputOptions', 'compressionQuality'], fromOutputCompressionQuality);
     }
+    const fromEnhanceInputImage = getValueByPath(fromObject, [
+        'enhanceInputImage',
+    ]);
+    if (parentObject !== undefined && fromEnhanceInputImage != null) {
+        setValueByPath(parentObject, ['parameters', 'upscaleConfig', 'enhanceInputImage'], fromEnhanceInputImage);
+    }
+    const fromImagePreservationFactor = getValueByPath(fromObject, [
+        'imagePreservationFactor',
+    ]);
+    if (parentObject !== undefined && fromImagePreservationFactor != null) {
+        setValueByPath(parentObject, ['parameters', 'upscaleConfig', 'imagePreservationFactor'], fromImagePreservationFactor);
+    }
     const fromNumberOfImages = getValueByPath(fromObject, [
         'numberOfImages',
     ]);
@@ -10256,6 +12084,12 @@ function generateVideosConfigToVertex(fromObject, parentObject) {
     if (parentObject !== undefined && fromLastFrame != null) {
         setValueByPath(parentObject, ['instances[0]', 'lastFrame'], imageToVertex(fromLastFrame));
     }
+    const fromCompressionQuality = getValueByPath(fromObject, [
+        'compressionQuality',
+    ]);
+    if (parentObject !== undefined && fromCompressionQuality != null) {
+        setValueByPath(parentObject, ['parameters', 'compressionQuality'], fromCompressionQuality);
+    }
     return toObject;
 }
 function generateVideosParametersToVertex(apiClient, fromObject) {
@@ -11880,13 +13714,17 @@ const FUNCTION_RESPONSE_REQUIRES_ID = 'FunctionResponse request must have an `id
  */
 async function handleWebSocketMessage(apiClient, onmessage, event) {
     const serverMessage = new LiveServerMessage();
-    let data;
+    let jsonData;
     if (event.data instanceof Blob) {
-        data = JSON.parse(await event.data.text());
+        jsonData = await event.data.text();
+    }
+    else if (event.data instanceof ArrayBuffer) {
+        jsonData = new TextDecoder().decode(event.data);
     }
     else {
-        data = JSON.parse(event.data);
+        jsonData = event.data;
     }
+    const data = JSON.parse(jsonData);
     if (apiClient.isVertexAI()) {
         const resp = liveServerMessageFromVertex(data);
         Object.assign(serverMessage, resp);
@@ -15647,6 +17485,7 @@ class GoogleGenAI {
         this.models = new Models(this.apiClient);
         this.live = new Live(this.apiClient, auth, new CrossWebSocketFactory());
         this.chats = new Chats(this.models, this.apiClient);
+        this.batches = new Batches(this.apiClient);
         this.caches = new Caches(this.apiClient);
         this.files = new Files(this.apiClient);
         this.operations = new Operations(this.apiClient);
@@ -15656,6 +17495,7 @@ class GoogleGenAI {
 }
 
 exports.ApiError = ApiError;
+exports.Batches = Batches;
 exports.Caches = Caches;
 exports.Chat = Chat;
 exports.Chats = Chats;
@@ -15677,6 +17517,8 @@ exports.GenerateImagesResponse = GenerateImagesResponse;
 exports.GenerateVideosResponse = GenerateVideosResponse;
 exports.GoogleGenAI = GoogleGenAI;
 exports.HttpResponse = HttpResponse;
+exports.InlinedResponse = InlinedResponse;
+exports.ListBatchJobsResponse = ListBatchJobsResponse;
 exports.ListCachedContentsResponse = ListCachedContentsResponse;
 exports.ListFilesResponse = ListFilesResponse;
 exports.ListModelsResponse = ListModelsResponse;