openai 7.20.0 → 7.21.0

package/src/resources/realtime/calls.ts

@@ -9,6 +9,13 @@ import { RequestOptions } from '../../internal/request-options';
 import { path } from '../../internal/utils/path';
 import { encodedMultipartFormRequestOptions } from '../../internal/multipart-encoding';
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
 export class Calls extends APIResource {
   /**
    * Create a new Realtime API call over WebRTC and receive the SDP answer needed to
@@ -24,20 +31,22 @@ export class Calls extends APIResource {
   create(body: CallCreateParams, options?: RequestOptions): APIPromise<Response> {
     return this._client.post(
       '/realtime/calls',
-      encodedMultipartFormRequestOptions(
-        {
-          body,
-          ...options,
-          headers: buildHeaders([{ Accept: 'application/sdp' }, options?.headers]),
-          __security: { bearerAuth: true },
-          __binaryResponse: true,
-        },
-        this._client,
-        {
-          sdp: { content_type: 'application/sdp', json: false },
-          session: { content_type: 'application/json', json: true },
-        },
-        'sdp',
+      resolveResourceRequestOptions(options, (options) =>
+        encodedMultipartFormRequestOptions(
+          {
+            body,
+            ...options,
+            headers: buildHeaders([{ Accept: 'application/sdp' }, options?.headers]),
+            __security: { bearerAuth: true },
+            __binaryResponse: true,
+          },
+          this._client,
+          {
+            sdp: { content_type: 'application/sdp', json: false },
+            session: { content_type: 'application/json', json: true },
+          },
+          'sdp',
+        ),
       ),
     );
   }
@@ -54,12 +63,15 @@ export class Calls extends APIResource {
    * ```
    */
   accept(callID: string, body: CallAcceptParams, options?: RequestOptions): APIPromise<void> {
-    return this._client.post(path`/realtime/calls/${callID}/accept`, {
-      body,
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-      __security: { bearerAuth: true },
-    });
+    return this._client.post(
+      path`/realtime/calls/${callID}/accept`,
+      resolveResourceRequestOptions(options, (options) => ({
+        body,
+        ...options,
+        headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+        __security: { bearerAuth: true },
+      })),
+    );
   }
 
   /**
@@ -71,11 +83,14 @@ export class Calls extends APIResource {
    * ```
    */
   hangup(callID: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.post(path`/realtime/calls/${callID}/hangup`, {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-      __security: { bearerAuth: true },
-    });
+    return this._client.post(
+      path`/realtime/calls/${callID}/hangup`,
+      resolveResourceRequestOptions(options, (options) => ({
+        ...options,
+        headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+        __security: { bearerAuth: true },
+      })),
+    );
   }
 
   /**
@@ -89,12 +104,15 @@ export class Calls extends APIResource {
    * ```
    */
   refer(callID: string, body: CallReferParams, options?: RequestOptions): APIPromise<void> {
-    return this._client.post(path`/realtime/calls/${callID}/refer`, {
-      body,
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-      __security: { bearerAuth: true },
-    });
+    return this._client.post(
+      path`/realtime/calls/${callID}/refer`,
+      resolveResourceRequestOptions(options, (options) => ({
+        body,
+        ...options,
+        headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+        __security: { bearerAuth: true },
+      })),
+    );
   }
 
   /**
@@ -110,12 +128,15 @@ export class Calls extends APIResource {
     body: CallRejectParams | null | undefined = {},
     options?: RequestOptions,
   ): APIPromise<void> {
-    return this._client.post(path`/realtime/calls/${callID}/reject`, {
-      body,
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-      __security: { bearerAuth: true },
-    });
+    return this._client.post(
+      path`/realtime/calls/${callID}/reject`,
+      resolveResourceRequestOptions(options, (options) => ({
+        body,
+        ...options,
+        headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+        __security: { bearerAuth: true },
+      })),
+    );
   }
 }
 

package/src/resources/realtime/client-secrets.ts

@@ -7,6 +7,13 @@ import * as ResponsesAPI from '../responses/responses';
 import { APIPromise } from '../../core/api-promise';
 import { RequestOptions } from '../../internal/request-options';
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
 export class ClientSecrets extends APIResource {
   /**
    * Create a Realtime client secret with an associated session configuration.
@@ -32,11 +39,14 @@ export class ClientSecrets extends APIResource {
    * ```
    */
   create(body: ClientSecretCreateParams, options?: RequestOptions): APIPromise<ClientSecretCreateResponse> {
-    return this._client.post('/realtime/client_secrets', {
-      body,
-      ...options,
-      __security: { bearerAuth: true },
-    });
+    return this._client.post(
+      '/realtime/client_secrets',
+      resolveResourceRequestOptions(options, (options) => ({
+        body,
+        ...options,
+        __security: { bearerAuth: true },
+      })),
+    );
   }
 }
 

package/src/resources/responses/input-items.ts

@@ -7,6 +7,13 @@ import { CursorPage, type CursorPageParams, PagePromise } from '../../core/pagin
 import { RequestOptions } from '../../internal/request-options';
 import { path } from '../../internal/utils/path';
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
 // Recognizable options across SDK runtime versions. Keep this independent of
 // private RequestOptions fields so older handwritten runtimes still compile.
 const normalizeRequestOptionsForQueryKeys = new Set([
@@ -114,6 +121,9 @@ function normalizeRequestOptionsForQuery(
   };
 }
 
+/**
+ * Create and manage model responses.
+ */
 export class InputItems extends APIResource {
   /**
    * Returns a list of input items for a given response.
@@ -230,7 +240,11 @@ export class InputItems extends APIResource {
     return this._client.getAPIList(
       path`/responses/${responseID}/input_items`,
       CursorPage<ResponsesAPI.ResponseItem>,
-      { query, ...options, __security: { bearerAuth: true } },
+      resolveResourceRequestOptions(options, (options) => ({
+        query,
+        ...options,
+        __security: { bearerAuth: true },
+      })),
     );
   }
 }

package/src/resources/responses/input-tokens.ts

@@ -6,6 +6,16 @@ import * as ResponsesAPI from './responses';
 import { APIPromise } from '../../core/api-promise';
 import { RequestOptions } from '../../internal/request-options';
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
+/**
+ * Create and manage model responses.
+ */
 export class InputTokens extends APIResource {
   /**
    * Returns input token counts of the request.
@@ -22,11 +32,14 @@ export class InputTokens extends APIResource {
     body: InputTokenCountParams | null | undefined = {},
     options?: RequestOptions,
   ): APIPromise<InputTokenCountResponse> {
-    return this._client.post('/responses/input_tokens', {
-      body,
-      ...options,
-      __security: { bearerAuth: true },
-    });
+    return this._client.post(
+      '/responses/input_tokens',
+      resolveResourceRequestOptions(options, (options) => ({
+        body,
+        ...options,
+        __security: { bearerAuth: true },
+      })),
+    );
   }
 }
 

package/src/resources/responses/responses.ts

@@ -73,6 +73,13 @@ export interface ParsedResponse<ParsedT> extends Response {
 
 export type ResponseParseParams = ResponseCreateParamsNonStreaming;
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
 // Recognizable options across SDK runtime versions. Keep this independent of
 // private RequestOptions fields so older handwritten runtimes still compile.
 const normalizeRequestOptionsForQueryKeys = new Set([
@@ -180,6 +187,9 @@ function normalizeRequestOptionsForQuery(
   };
 }
 
+/**
+ * Create and manage model responses.
+ */
 export class Responses extends APIResource {
   inputItems: InputItemsAPI.InputItems = new InputItemsAPI.InputItems(this._client);
   inputTokens: InputTokensAPI.InputTokens = new InputTokensAPI.InputTokens(this._client);
@@ -216,12 +226,15 @@ export class Responses extends APIResource {
     options?: RequestOptions,
   ): APIPromise<Response> | APIPromise<Stream<ResponseStreamEvent>> {
     return (
-      this._client.post('/responses', {
-        body,
-        ...options,
-        stream: body.stream ?? false,
-        __security: { bearerAuth: true },
-      }) as APIPromise<Response> | APIPromise<Stream<ResponseStreamEvent>>
+      this._client.post(
+        '/responses',
+        resolveResourceRequestOptions(options, (options) => ({
+          body,
+          ...options,
+          stream: body.stream ?? false,
+          __security: { bearerAuth: true },
+        })),
+      ) as APIPromise<Response> | APIPromise<Stream<ResponseStreamEvent>>
     )._thenUnwrap((rsp) => {
       if ('object' in rsp && rsp.object === 'response') {
         addOutputText(rsp as Response);
@@ -402,12 +415,15 @@ export class Responses extends APIResource {
     }
     query = query as ResponseRetrieveParams | undefined;
     return (
-      this._client.get(path`/responses/${responseID}`, {
-        query,
-        ...options,
-        stream: query?.stream ?? false,
-        __security: { bearerAuth: true },
-      }) as APIPromise<Response> | APIPromise<Stream<ResponseStreamEvent>>
+      this._client.get(
+        path`/responses/${responseID}`,
+        resolveResourceRequestOptions(options, (options) => ({
+          query,
+          ...options,
+          stream: query?.stream ?? false,
+          __security: { bearerAuth: true },
+        })),
+      ) as APIPromise<Response> | APIPromise<Stream<ResponseStreamEvent>>
     )._thenUnwrap((rsp) => {
       if ('object' in rsp && rsp.object === 'response') {
         addOutputText(rsp as Response);
@@ -428,11 +444,14 @@ export class Responses extends APIResource {
    * ```
    */
   delete(responseID: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.delete(path`/responses/${responseID}`, {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-      __security: { bearerAuth: true },
-    });
+    return this._client.delete(
+      path`/responses/${responseID}`,
+      resolveResourceRequestOptions(options, (options) => ({
+        ...options,
+        headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+        __security: { bearerAuth: true },
+      })),
+    );
   }
 
   parse<Params extends ResponseCreateParamsWithTools, ParsedT = ExtractParsedContentFromParams<Params>>(
@@ -467,10 +486,10 @@ export class Responses extends APIResource {
    * ```
    */
   cancel(responseID: string, options?: RequestOptions): APIPromise<Response> {
-    return this._client.post(path`/responses/${responseID}/cancel`, {
-      ...options,
-      __security: { bearerAuth: true },
-    });
+    return this._client.post(
+      path`/responses/${responseID}/cancel`,
+      resolveResourceRequestOptions(options, (options) => ({ ...options, __security: { bearerAuth: true } })),
+    );
   }
 
   /**
@@ -489,7 +508,14 @@ export class Responses extends APIResource {
    * ```
    */
   compact(body: ResponseCompactParams, options?: RequestOptions): APIPromise<CompactedResponse> {
-    return this._client.post('/responses/compact', { body, ...options, __security: { bearerAuth: true } });
+    return this._client.post(
+      '/responses/compact',
+      resolveResourceRequestOptions(options, (options) => ({
+        body,
+        ...options,
+        __security: { bearerAuth: true },
+      })),
+    );
   }
 }
 

package/src/resources/safety/alerts.ts

@@ -5,12 +5,22 @@ import { APIPromise } from '../../core/api-promise';
 import { RequestOptions } from '../../internal/request-options';
 import { path } from '../../internal/utils/path';
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
 export class Alerts extends APIResource {
   /**
    * Get a safety alert belonging to the authenticated API project.
    */
   retrieve(id: string, options?: RequestOptions): APIPromise<SafetyAlert> {
-    return this._client.get(path`/safety/alerts/${id}`, { ...options, __security: { bearerAuth: true } });
+    return this._client.get(
+      path`/safety/alerts/${id}`,
+      resolveResourceRequestOptions(options, (options) => ({ ...options, __security: { bearerAuth: true } })),
+    );
   }
 }
 

package/src/resources/safety/cases.ts

@@ -5,12 +5,22 @@ import { APIPromise } from '../../core/api-promise';
 import { RequestOptions } from '../../internal/request-options';
 import { path } from '../../internal/utils/path';
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
 export class Cases extends APIResource {
   /**
    * Get a safety case by ID.
    */
   retrieve(id: string, options?: RequestOptions): APIPromise<SafetyCase> {
-    return this._client.get(path`/safety/cases/${id}`, { ...options, __security: { bearerAuth: true } });
+    return this._client.get(
+      path`/safety/cases/${id}`,
+      resolveResourceRequestOptions(options, (options) => ({ ...options, __security: { bearerAuth: true } })),
+    );
   }
 }
 

package/src/resources/safety/safety.ts

@@ -7,15 +7,15 @@ import * as CasesAPI from './cases';
 import { Cases, SafetyCase } from './cases';
 
 export class Safety extends APIResource {
-  alerts: AlertsAPI.Alerts = new AlertsAPI.Alerts(this._client);
   cases: CasesAPI.Cases = new CasesAPI.Cases(this._client);
+  alerts: AlertsAPI.Alerts = new AlertsAPI.Alerts(this._client);
 }
 
-Safety.Alerts = Alerts;
 Safety.Cases = Cases;
+Safety.Alerts = Alerts;
 
 export declare namespace Safety {
-  export { Alerts as Alerts, type SafetyAlert as SafetyAlert };
-
   export { Cases as Cases, type SafetyCase as SafetyCase };
+
+  export { Alerts as Alerts, type SafetyAlert as SafetyAlert };
 }

package/src/resources/skills/content.ts

@@ -6,16 +6,26 @@ import { buildHeaders } from '../../internal/headers';
 import { RequestOptions } from '../../internal/request-options';
 import { path } from '../../internal/utils/path';
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
 export class Content extends APIResource {
   /**
    * Download a skill zip bundle by its ID.
    */
   retrieve(skillID: string, options?: RequestOptions): APIPromise<Response> {
-    return this._client.get(path`/skills/${skillID}/content`, {
-      ...options,
-      headers: buildHeaders([{ Accept: 'application/binary' }, options?.headers]),
-      __security: { bearerAuth: true },
-      __binaryResponse: true,
-    });
+    return this._client.get(
+      path`/skills/${skillID}/content`,
+      resolveResourceRequestOptions(options, (options) => ({
+        ...options,
+        headers: buildHeaders([{ Accept: 'application/binary' }, options?.headers]),
+        __security: { bearerAuth: true },
+        __binaryResponse: true,
+      })),
+    );
   }
 }

package/src/resources/skills/skills.ts

@@ -22,6 +22,13 @@ import { RequestOptions } from '../../internal/request-options';
 import { maybeMultipartFormRequestOptions } from '../../internal/uploads';
 import { path } from '../../internal/utils/path';
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
 // Recognizable options across SDK runtime versions. Keep this independent of
 // private RequestOptions fields so older handwritten runtimes still compile.
 const normalizeRequestOptionsForQueryKeys = new Set([
@@ -149,18 +156,24 @@ export class Skills extends APIResource {
    * Get a skill by its ID.
    */
   retrieve(skillID: string, options?: RequestOptions): APIPromise<Skill> {
-    return this._client.get(path`/skills/${skillID}`, { ...options, __security: { bearerAuth: true } });
+    return this._client.get(
+      path`/skills/${skillID}`,
+      resolveResourceRequestOptions(options, (options) => ({ ...options, __security: { bearerAuth: true } })),
+    );
   }
 
   /**
    * Update the default version pointer for a skill.
    */
   update(skillID: string, body: SkillUpdateParams, options?: RequestOptions): APIPromise<Skill> {
-    return this._client.post(path`/skills/${skillID}`, {
-      body,
-      ...options,
-      __security: { bearerAuth: true },
-    });
+    return this._client.post(
+      path`/skills/${skillID}`,
+      resolveResourceRequestOptions(options, (options) => ({
+        body,
+        ...options,
+        __security: { bearerAuth: true },
+      })),
+    );
   }
 
   /**
@@ -262,18 +275,25 @@ export class Skills extends APIResource {
       query = {};
     }
     query = query as SkillListParams | null | undefined;
-    return this._client.getAPIList('/skills', CursorPage<Skill>, {
-      query,
-      ...options,
-      __security: { bearerAuth: true },
-    });
+    return this._client.getAPIList(
+      '/skills',
+      CursorPage<Skill>,
+      resolveResourceRequestOptions(options, (options) => ({
+        query,
+        ...options,
+        __security: { bearerAuth: true },
+      })),
+    );
   }
 
   /**
    * Delete a skill by its ID.
    */
   delete(skillID: string, options?: RequestOptions): APIPromise<DeletedSkill> {
-    return this._client.delete(path`/skills/${skillID}`, { ...options, __security: { bearerAuth: true } });
+    return this._client.delete(
+      path`/skills/${skillID}`,
+      resolveResourceRequestOptions(options, (options) => ({ ...options, __security: { bearerAuth: true } })),
+    );
   }
 }
 

package/src/resources/skills/versions/content.ts

@@ -6,18 +6,28 @@ import { buildHeaders } from '../../../internal/headers';
 import { RequestOptions } from '../../../internal/request-options';
 import { path } from '../../../internal/utils/path';
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
 export class Content extends APIResource {
   /**
    * Download a skill version zip bundle.
    */
   retrieve(version: string, params: ContentRetrieveParams, options?: RequestOptions): APIPromise<Response> {
     const { skill_id } = params;
-    return this._client.get(path`/skills/${skill_id}/versions/${version}/content`, {
-      ...options,
-      headers: buildHeaders([{ Accept: 'application/binary' }, options?.headers]),
-      __security: { bearerAuth: true },
-      __binaryResponse: true,
-    });
+    return this._client.get(
+      path`/skills/${skill_id}/versions/${version}/content`,
+      resolveResourceRequestOptions(options, (options) => ({
+        ...options,
+        headers: buildHeaders([{ Accept: 'application/binary' }, options?.headers]),
+        __security: { bearerAuth: true },
+        __binaryResponse: true,
+      })),
+    );
   }
 }
 

package/src/resources/skills/versions/versions.ts

@@ -10,6 +10,13 @@ import { RequestOptions } from '../../../internal/request-options';
 import { maybeMultipartFormRequestOptions } from '../../../internal/uploads';
 import { path } from '../../../internal/utils/path';
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
 // Recognizable options across SDK runtime versions. Keep this independent of
 // private RequestOptions fields so older handwritten runtimes still compile.
 const normalizeRequestOptionsForQueryKeys = new Set([
@@ -145,10 +152,10 @@ export class Versions extends APIResource {
     options?: RequestOptions,
   ): APIPromise<SkillVersion> {
     const { skill_id } = params;
-    return this._client.get(path`/skills/${skill_id}/versions/${version}`, {
-      ...options,
-      __security: { bearerAuth: true },
-    });
+    return this._client.get(
+      path`/skills/${skill_id}/versions/${version}`,
+      resolveResourceRequestOptions(options, (options) => ({ ...options, __security: { bearerAuth: true } })),
+    );
   }
 
   /**
@@ -253,11 +260,15 @@ export class Versions extends APIResource {
       query = {};
     }
     query = query as VersionListParams | null | undefined;
-    return this._client.getAPIList(path`/skills/${skillID}/versions`, CursorPage<SkillVersion>, {
-      query,
-      ...options,
-      __security: { bearerAuth: true },
-    });
+    return this._client.getAPIList(
+      path`/skills/${skillID}/versions`,
+      CursorPage<SkillVersion>,
+      resolveResourceRequestOptions(options, (options) => ({
+        query,
+        ...options,
+        __security: { bearerAuth: true },
+      })),
+    );
   }
 
   /**
@@ -269,10 +280,10 @@ export class Versions extends APIResource {
     options?: RequestOptions,
   ): APIPromise<DeletedSkillVersion> {
     const { skill_id } = params;
-    return this._client.delete(path`/skills/${skill_id}/versions/${version}`, {
-      ...options,
-      __security: { bearerAuth: true },
-    });
+    return this._client.delete(
+      path`/skills/${skill_id}/versions/${version}`,
+      resolveResourceRequestOptions(options, (options) => ({ ...options, __security: { bearerAuth: true } })),
+    );
   }
 }
 

package/src/resources/uploads/parts.ts

@@ -7,6 +7,13 @@ import { RequestOptions } from '../../internal/request-options';
 import { multipartFormRequestOptions } from '../../internal/uploads';
 import { path } from '../../internal/utils/path';
 
+function resolveResourceRequestOptions(
+  options: RequestOptions | undefined,
+  buildOptions: (options: RequestOptions | undefined) => RequestOptions | Promise<RequestOptions>,
+): Promise<RequestOptions> {
+  return Promise.resolve(options).then(buildOptions);
+}
+
 /**
  * Use Uploads to upload large files in multiple parts.
  */
@@ -28,7 +35,9 @@ export class Parts extends APIResource {
   create(uploadID: string, body: PartCreateParams, options?: RequestOptions): APIPromise<UploadPart> {
     return this._client.post(
       path`/uploads/${uploadID}/parts`,
-      multipartFormRequestOptions({ body, ...options, __security: { bearerAuth: true } }, this._client),
+      resolveResourceRequestOptions(options, (options) =>
+        multipartFormRequestOptions({ body, ...options, __security: { bearerAuth: true } }, this._client),
+      ),
     );
   }
 }