chamelaion 0.2.0 → 0.4.0

package/src/client.ts

@@ -19,28 +19,17 @@ import * as API from './resources/index';
 import { APIPromise } from './core/api-promise';
 import { Health, HealthCheckResponse } from './resources/health';
 import { UserRetrieveCurrentResponse, Users } from './resources/users';
-import {
-  Lipsync,
-  LipsyncGenerate,
-  LipsyncGenerateParams,
-  LipsyncGenerateWithMediaParams,
-} from './resources/lipsync/lipsync';
+import { Lipsync, LipsyncGenerate, LipsyncGenerateParams, LipsyncGenerateWithMediaParams } from './resources/lipsync/lipsync';
 import { type Fetch } from './internal/builtin-types';
 import { HeadersLike, NullableHeaders, buildHeaders } from './internal/headers';
 import { FinalRequestOptions, RequestOptions } from './internal/request-options';
 import { readEnv } from './internal/utils/env';
-import {
-  type LogLevel,
-  type Logger,
-  formatRequestDetails,
-  loggerFor,
-  parseLogLevel,
-} from './internal/utils/log';
+import { type LogLevel, type Logger, formatRequestDetails, loggerFor, parseLogLevel } from './internal/utils/log';
 import { isEmptyObj } from './internal/utils/values';
 
 const environments = {
   production: 'https://api.chamelaion.com/api',
-  environment_1: 'https://dev.api.chamelaion.com/api',
+  staging: 'https://api.dev.chamelaion.com/api',
 };
 type Environment = keyof typeof environments;
 
@@ -60,7 +49,7 @@ export interface ClientOptions {
    *
    * Each environment maps to a different base URL:
    * - `production` corresponds to `https://api.chamelaion.com/api`
-   * - `environment_1` corresponds to `https://dev.api.chamelaion.com/api`
+   * - `staging` corresponds to `https://api.dev.chamelaion.com/api`
    */
   environment?: Environment | undefined;
 
@@ -134,7 +123,7 @@ export interface ClientOptions {
 }
 
 /**
- * API Client for interfacing with the Chamelaion API.
+ * API Client for interfacing with the Chamelaion API. 
  */
 export class Chamelaion {
   bearerToken: string | null;
@@ -172,6 +161,7 @@ export class Chamelaion {
     apiKey = readEnv('CHAMELAION_API_KEY') ?? null,
     ...opts
   }: ClientOptions = {}) {
+
     const options: ClientOptions = {
       bearerToken,
       apiKey,
@@ -182,8 +172,8 @@ export class Chamelaion {
 
     if (baseURL && opts.environment) {
       throw new Errors.ChamelaionError(
-        'Ambiguous URL; The `baseURL` option (or CHAMELAION_BASE_URL env var) and the `environment` option are given. If you want to use the environment you must pass baseURL: null',
-      );
+        'Ambiguous URL; The `baseURL` option (or CHAMELAION_BASE_URL env var) and the `environment` option are given. If you want to use the environment you must pass baseURL: null'
+      )
     }
 
     this.baseURL = options.baseURL || environments[options.environment || 'production'];
@@ -192,10 +182,7 @@ export class Chamelaion {
     const defaultLogLevel = 'warn';
     // Set default logLevel early so that we can log a warning in parseLogLevel.
     this.logLevel = defaultLogLevel;
-    this.logLevel =
-      parseLogLevel(options.logLevel, 'ClientOptions.logLevel', this) ??
-      parseLogLevel(readEnv('CHAMELAION_LOG'), "process.env['CHAMELAION_LOG']", this) ??
-      defaultLogLevel;
+    this.logLevel = parseLogLevel(options.logLevel, 'ClientOptions.logLevel', this) ?? parseLogLevel(readEnv('CHAMELAION_LOG'), 'process.env[\'CHAMELAION_LOG\']', this) ?? defaultLogLevel;
     this.fetchOptions = options.fetchOptions;
     this.maxRetries = options.maxRetries ?? 2;
     this.fetch = options.fetch ?? Shims.getDefaultFetch();
@@ -223,7 +210,7 @@ export class Chamelaion {
       fetchOptions: this.fetchOptions,
       bearerToken: this.bearerToken,
       apiKey: this.apiKey,
-      ...options,
+      ...options
     });
     return client;
   }
@@ -236,7 +223,7 @@ export class Chamelaion {
   }
 
   protected defaultQuery(): Record<string, string | undefined> | undefined {
-    return this._options.defaultQuery;
+    return this._options.defaultQuery
   }
 
   protected validateHeaders({ values, nulls }: NullableHeaders) {
@@ -254,19 +241,11 @@ export class Chamelaion {
       return;
     }
 
-    throw new Error(
-      'Could not resolve authentication method. Expected either bearerToken or apiKey to be set. Or for one of the "Authorization" or "x-api-key" headers to be explicitly omitted',
-    );
+    throw new Error('Could not resolve authentication method. Expected either bearerToken or apiKey to be set. Or for one of the "Authorization" or "x-api-key" headers to be explicitly omitted')
   }
 
-  protected async authHeaders(
-    opts: FinalRequestOptions,
-    schemes: { bearerAuth?: boolean; apiKeyAuth?: boolean },
-  ): Promise<NullableHeaders | undefined> {
-    return buildHeaders([
-      schemes.bearerAuth ? await this.bearerAuth(opts) : null,
-      schemes.apiKeyAuth ? await this.apiKeyAuth(opts) : null,
-    ]);
+  protected async authHeaders(opts: FinalRequestOptions, schemes: { bearerAuth?: boolean, apiKeyAuth?: boolean }): Promise<NullableHeaders | undefined> {
+    return buildHeaders([schemes.bearerAuth ? await this.bearerAuth(opts) : null, schemes.apiKeyAuth ? await this.apiKeyAuth(opts) : null]);
   }
 
   protected async bearerAuth(opts: FinalRequestOptions): Promise<NullableHeaders | undefined> {
@@ -307,11 +286,7 @@ export class Chamelaion {
     return Errors.APIError.generate(status, error, message, headers);
   }
 
-  buildURL(
-    path: string,
-    query: Record<string, unknown> | null | undefined,
-    defaultBaseURL?: string | undefined,
-  ): string {
+  buildURL(path: string, query: Record<string, unknown> | null | undefined, defaultBaseURL?: string | undefined): string {
     const baseURL = (!this.#baseURLOverridden() && defaultBaseURL) || this.baseURL;
     const url =
       isAbsoluteURL(path) ?
@@ -399,9 +374,7 @@ export class Chamelaion {
 
     await this.prepareOptions(options);
 
-    const { req, url, timeout } = await this.buildRequest(options, {
-      retryCount: maxRetries - retriesRemaining,
-    });
+    const { req, url, timeout } = await this.buildRequest(options, { retryCount: maxRetries - retriesRemaining });
 
     await this.prepareRequest(req, { url, options });
 
@@ -410,16 +383,7 @@ export class Chamelaion {
     const retryLogStr = retryOfRequestLogID === undefined ? '' : `, retryOf: ${retryOfRequestLogID}`;
     const startTime = Date.now();
 
-    loggerFor(this).debug(
-      `[${requestLogID}] sending request`,
-      formatRequestDetails({
-        retryOfRequestLogID,
-        method: options.method,
-        url,
-        options,
-        headers: req.headers,
-      }),
-    );
+    loggerFor(this).debug(`[${requestLogID}] sending request`, formatRequestDetails({ retryOfRequestLogID, method: options.method, url, options, headers: req.headers }));
 
     if (options.signal?.aborted) {
       throw new Errors.APIUserAbortError();
@@ -438,45 +402,21 @@ export class Chamelaion {
       // deno throws "TypeError: error sending request for url (https://example/): client error (Connect): tcp connect error: Operation timed out (os error 60): Operation timed out (os error 60)"
       // undici throws "TypeError: fetch failed" with cause "ConnectTimeoutError: Connect Timeout Error (attempted address: example:443, timeout: 1ms)"
       // others do not provide enough information to distinguish timeouts from other connection errors
-      const isTimeout =
-        isAbortError(response) ||
-        /timed? ?out/i.test(String(response) + ('cause' in response ? String(response.cause) : ''));
+      const isTimeout = isAbortError(response) || /timed? ?out/i.test(String(response) + ('cause' in response ? String(response.cause) : ''))
       if (retriesRemaining) {
-        loggerFor(this).info(
-          `[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - ${retryMessage}`,
-        );
-        loggerFor(this).debug(
-          `[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (${retryMessage})`,
-          formatRequestDetails({
-            retryOfRequestLogID,
-            url,
-            durationMs: headersTime - startTime,
-            message: response.message,
-          }),
-        );
+        loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - ${retryMessage}`)
+        loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (${retryMessage})`, formatRequestDetails({ retryOfRequestLogID, url, durationMs: headersTime - startTime, message: response.message }));
         return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID);
       }
-      loggerFor(this).info(
-        `[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - error; no more retries left`,
-      );
-      loggerFor(this).debug(
-        `[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (error; no more retries left)`,
-        formatRequestDetails({
-          retryOfRequestLogID,
-          url,
-          durationMs: headersTime - startTime,
-          message: response.message,
-        }),
-      );
+      loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - error; no more retries left`)
+      loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (error; no more retries left)`, formatRequestDetails({ retryOfRequestLogID, url, durationMs: headersTime - startTime, message: response.message }));
       if (isTimeout) {
         throw new Errors.APIConnectionTimeoutError();
       }
       throw new Errors.APIConnectionError({ cause: response });
     }
 
-    const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${
-      response.ok ? 'succeeded' : 'failed'
-    } with status ${response.status} in ${headersTime - startTime}ms`;
+    const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${response.ok ? 'succeeded' : 'failed'} with status ${response.status} in ${headersTime - startTime}ms`;
 
     if (!response.ok) {
       const shouldRetry = await this.shouldRetry(response);
@@ -485,60 +425,27 @@ export class Chamelaion {
 
         // We don't need the body of this response.
         await Shims.CancelReadableStream(response.body);
-        loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
-        loggerFor(this).debug(
-          `[${requestLogID}] response error (${retryMessage})`,
-          formatRequestDetails({
-            retryOfRequestLogID,
-            url: response.url,
-            status: response.status,
-            headers: response.headers,
-            durationMs: headersTime - startTime,
-          }),
-        );
-        return this.retryRequest(
-          options,
-          retriesRemaining,
-          retryOfRequestLogID ?? requestLogID,
-          response.headers,
-        );
+        loggerFor(this).info(`${responseInfo} - ${retryMessage}`)
+        loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({ retryOfRequestLogID, url: response.url, status: response.status, headers: response.headers, durationMs: headersTime - startTime }));
+        return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID, response.headers);
       }
 
       const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`;
 
-      loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
+      loggerFor(this).info(`${responseInfo} - ${retryMessage}`)
 
       const errText = await response.text().catch((err: any) => castToError(err).message);
       const errJSON = safeJSON(errText) as any;
       const errMessage = errJSON ? undefined : errText;
 
-      loggerFor(this).debug(
-        `[${requestLogID}] response error (${retryMessage})`,
-        formatRequestDetails({
-          retryOfRequestLogID,
-          url: response.url,
-          status: response.status,
-          headers: response.headers,
-          message: errMessage,
-          durationMs: Date.now() - startTime,
-        }),
-      );
+      loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({ retryOfRequestLogID, url: response.url, status: response.status, headers: response.headers, message: errMessage, durationMs: Date.now() - startTime }));
 
       const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
       throw err;
     }
 
-    loggerFor(this).info(responseInfo);
-    loggerFor(this).debug(
-      `[${requestLogID}] response start`,
-      formatRequestDetails({
-        retryOfRequestLogID,
-        url: response.url,
-        status: response.status,
-        headers: response.headers,
-        durationMs: headersTime - startTime,
-      }),
-    );
+    loggerFor(this).info(responseInfo)
+    loggerFor(this).debug(`[${requestLogID}] response start`, formatRequestDetails({ retryOfRequestLogID, url: response.url, status: response.status, headers: response.headers, durationMs: headersTime - startTime }));
 
     return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
   }
@@ -555,9 +462,7 @@ export class Chamelaion {
 
     const timeout = setTimeout(abort, ms);
 
-    const isReadableBody =
-      ((globalThis as any).ReadableStream && options.body instanceof (globalThis as any).ReadableStream) ||
-      (typeof options.body === 'object' && options.body !== null && Symbol.asyncIterator in options.body);
+    const isReadableBody = ((globalThis as any).ReadableStream && options.body instanceof (globalThis as any).ReadableStream) || (typeof options.body === "object" && options.body !== null && Symbol.asyncIterator in options.body);
 
     const fetchOptions: RequestInit = {
       signal: controller.signal as any,
@@ -572,6 +477,7 @@ export class Chamelaion {
     }
 
     try {
+
       // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
       return await this.fetch.call(undefined, url, fetchOptions);
     } finally {
@@ -672,12 +578,11 @@ export class Chamelaion {
     const req: FinalizedRequestInit = {
       method,
       headers: reqHeaders,
-      ...(options.signal && { signal: options.signal }),
-      ...((globalThis as any).ReadableStream &&
-        body instanceof (globalThis as any).ReadableStream && { duplex: 'half' }),
+      ...(options.signal && { signal: options.signal}),
+      ...((globalThis as any).ReadableStream && body instanceof (globalThis as any).ReadableStream && { duplex: "half" }),
       ...(body && { body }),
-      ...((this.fetchOptions as any) ?? {}),
-      ...((options.fetchOptions as any) ?? {}),
+      ...(this.fetchOptions as any ?? {}),
+      ...(options.fetchOptions as any ?? {}),
     };
 
     return { req, url, timeout: options.timeout };
@@ -702,17 +607,15 @@ export class Chamelaion {
 
     const headers = buildHeaders([
       idempotencyHeaders,
-      {
-        Accept: 'application/json',
-        'User-Agent': this.getUserAgent(),
-        'X-Stainless-Retry-Count': String(retryCount),
-        ...(options.timeout ? { 'X-Stainless-Timeout': String(Math.trunc(options.timeout / 1000)) } : {}),
-        ...getPlatformHeaders(),
-      },
-      await this.authHeaders(options, options.__security ?? { bearerAuth: true, apiKeyAuth: true }),
+      {Accept: 'application/json',
+      'User-Agent': this.getUserAgent(),
+      'X-Stainless-Retry-Count': String(retryCount),
+      ...(options.timeout ? { 'X-Stainless-Timeout': String(Math.trunc(options.timeout / 1000)) } : {}),
+      ...getPlatformHeaders()},
+      await this.authHeaders(options, options.__security ?? { bearerAuth: true,apiKeyAuth: true }),
       this._options.defaultHeaders,
       bodyHeaders,
-      options.headers,
+      options.headers
     ]);
 
     this.validateHeaders(headers);
@@ -739,9 +642,11 @@ export class Chamelaion {
       ArrayBuffer.isView(body) ||
       body instanceof ArrayBuffer ||
       body instanceof DataView ||
-      (typeof body === 'string' &&
+      (
+        typeof body === 'string' &&
         // Preserve legacy string encoding behavior for now
-        headers.values.has('content-type')) ||
+        headers.values.has('content-type')
+      ) ||
       // `Blob` is superset of `File`
       ((globalThis as any).Blob && body instanceof (globalThis as any).Blob) ||
       // `FormData` -> `multipart/form-data`
@@ -772,7 +677,7 @@ export class Chamelaion {
   }
 
   static Chamelaion = this;
-  static DEFAULT_TIMEOUT = 60000; // 1 minute
+  static DEFAULT_TIMEOUT = 60000 // 1 minute
 
   static ChamelaionError = Errors.ChamelaionError;
   static APIError = Errors.APIError;
@@ -809,16 +714,22 @@ Chamelaion.Users = Users;
 Chamelaion.Lipsync = Lipsync;
 
 export declare namespace Chamelaion {
-  export type RequestOptions = Opts.RequestOptions;
+      export type RequestOptions = Opts.RequestOptions;
 
-  export { Health as Health, type HealthCheckResponse as HealthCheckResponse };
+      export {
+  Health as Health,
+  type HealthCheckResponse as HealthCheckResponse
+};
 
-  export { Users as Users, type UserRetrieveCurrentResponse as UserRetrieveCurrentResponse };
+export {
+  Users as Users,
+  type UserRetrieveCurrentResponse as UserRetrieveCurrentResponse
+};
 
-  export {
-    Lipsync as Lipsync,
-    type LipsyncGenerate as LipsyncGenerate,
-    type LipsyncGenerateParams as LipsyncGenerateParams,
-    type LipsyncGenerateWithMediaParams as LipsyncGenerateWithMediaParams,
-  };
-}
+export {
+  Lipsync as Lipsync,
+  type LipsyncGenerate as LipsyncGenerate,
+  type LipsyncGenerateParams as LipsyncGenerateParams,
+  type LipsyncGenerateWithMediaParams as LipsyncGenerateWithMediaParams
+};
+    }

package/src/core/api-promise.ts

@@ -16,10 +16,7 @@ export class APIPromise<T> extends Promise<T> {
   constructor(
     client: Chamelaion,
     private responsePromise: Promise<APIResponseProps>,
-    private parseResponse: (
-      client: Chamelaion,
-      props: APIResponseProps,
-    ) => PromiseOrValue<T> = defaultParseResponse,
+    private parseResponse: (client: Chamelaion, props: APIResponseProps) => PromiseOrValue<T> = defaultParseResponse,
   ) {
     super((resolve) => {
       // this is maybe a bit weird but this has to be a no-op to not implicitly
@@ -31,9 +28,7 @@ export class APIPromise<T> extends Promise<T> {
   }
 
   _thenUnwrap<U>(transform: (data: T, props: APIResponseProps) => U): APIPromise<U> {
-    return new APIPromise(this.#client, this.responsePromise, async (client, props) =>
-      transform(await this.parseResponse(client, props), props),
-    );
+    return new APIPromise(this.#client, this.responsePromise, async (client, props) => transform(await this.parseResponse(client, props), props));
   }
 
   /**

package/src/core/error.ts

@@ -2,13 +2,10 @@
 
 import { castToError } from '../internal/errors';
 
-export class ChamelaionError extends Error {}
+export class ChamelaionError extends Error {
+}
 
-export class APIError<
-  TStatus extends number | undefined = number | undefined,
-  THeaders extends Headers | undefined = Headers | undefined,
-  TError extends Object | undefined = Object | undefined,
-> extends ChamelaionError {
+export class APIError<TStatus extends number | undefined = number | undefined, THeaders extends Headers | undefined = Headers | undefined, TError extends Object | undefined = Object | undefined> extends ChamelaionError {
   /** HTTP status for the response that caused the error */
   readonly status: TStatus;
   /** HTTP headers for the response that caused the error */
@@ -16,6 +13,9 @@ export class APIError<
   /** JSON body of the response that caused the error */
   readonly error: TError;
 
+
+  ;
+
   constructor(status: TStatus, error: TError, message: string | undefined, headers: THeaders) {
     super(`${APIError.makeMessage(status, error, message)}`);
     this.status = status;
@@ -26,8 +26,7 @@ export class APIError<
   private static makeMessage(status: number | undefined, error: any, message: string | undefined) {
     const msg =
       error?.message ?
-        typeof error.message === 'string' ?
-          error.message
+        typeof error.message === 'string' ? error.message
         : JSON.stringify(error.message)
       : error ? JSON.stringify(error)
       : message;
@@ -44,12 +43,7 @@ export class APIError<
     return '(no status code or body)';
   }
 
-  static generate(
-    status: number | undefined,
-    errorResponse: Object | undefined,
-    message: string | undefined,
-    headers: Headers | undefined,
-  ): APIError {
+  static generate(status: number | undefined, errorResponse: Object | undefined, message: string | undefined, headers: Headers | undefined): APIError {
     if (!status || !headers) {
       return new APIConnectionError({ message, cause: castToError(errorResponse) });
     }
@@ -113,18 +107,26 @@ export class APIConnectionTimeoutError extends APIConnectionError {
   }
 }
 
-export class BadRequestError extends APIError<400, Headers> {}
+export class BadRequestError extends APIError<400, Headers> {
+}
 
-export class AuthenticationError extends APIError<401, Headers> {}
+export class AuthenticationError extends APIError<401, Headers> {
+}
 
-export class PermissionDeniedError extends APIError<403, Headers> {}
+export class PermissionDeniedError extends APIError<403, Headers> {
+}
 
-export class NotFoundError extends APIError<404, Headers> {}
+export class NotFoundError extends APIError<404, Headers> {
+}
 
-export class ConflictError extends APIError<409, Headers> {}
+export class ConflictError extends APIError<409, Headers> {
+}
 
-export class UnprocessableEntityError extends APIError<422, Headers> {}
+export class UnprocessableEntityError extends APIError<422, Headers> {
+}
 
-export class RateLimitError extends APIError<429, Headers> {}
+export class RateLimitError extends APIError<429, Headers> {
+}
 
-export class InternalServerError extends APIError<number, Headers> {}
+export class InternalServerError extends APIError<number, Headers> {
+}

package/src/error.ts

@@ -1,2 +1,2 @@
 /** @deprecated Import from ./core/error instead */
-export * from './core/error';
+export * from "./core/error"

package/src/index.ts

@@ -5,18 +5,4 @@ export { Chamelaion as default } from './client';
 export { type Uploadable, toFile } from './core/uploads';
 export { APIPromise } from './core/api-promise';
 export { Chamelaion, type ClientOptions } from './client';
-export {
-  ChamelaionError,
-  APIError,
-  APIConnectionError,
-  APIConnectionTimeoutError,
-  APIUserAbortError,
-  NotFoundError,
-  ConflictError,
-  RateLimitError,
-  BadRequestError,
-  AuthenticationError,
-  InternalServerError,
-  PermissionDeniedError,
-  UnprocessableEntityError,
-} from './core/error';
+export { ChamelaionError, APIError, APIConnectionError, APIConnectionTimeoutError, APIUserAbortError, NotFoundError, ConflictError, RateLimitError, BadRequestError, AuthenticationError, InternalServerError, PermissionDeniedError, UnprocessableEntityError } from './core/error';

package/src/internal/builtin-types.ts

@@ -1,20 +1,23 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export type Fetch = (
+  input: string | URL | Request,
+  init?: RequestInit,
+) => Promise<Response>
 
 /**
  * An alias to the builtin `RequestInit` type so we can
  * easily alias it in import statements if there are name clashes.
- *
- * https://developer.mozilla.org/docs/Web/API/RequestInit
+     *
+     * https://developer.mozilla.org/docs/Web/API/RequestInit
  */
 type _RequestInit = RequestInit;
 
 /**
  * An alias to the builtin `Response` type so we can
  * easily alias it in import statements if there are name clashes.
- *
- * https://developer.mozilla.org/docs/Web/API/Response
+     *
+     * https://developer.mozilla.org/docs/Web/API/Response
  */
 type _Response = Response;
 
@@ -51,15 +54,7 @@ type _Array<T> = Array<T>;
  */
 type _Record<K extends keyof any, T> = Record<K, T>;
 
-export type {
-  _Array as Array,
-  _BodyInit as BodyInit,
-  _HeadersInit as HeadersInit,
-  _Record as Record,
-  _RequestInfo as RequestInfo,
-  _RequestInit as RequestInit,
-  _Response as Response,
-};
+export type { _Array as Array, _BodyInit as BodyInit, _HeadersInit as HeadersInit, _Record as Record, _RequestInfo as RequestInfo, _RequestInit as RequestInit, _Response as Response };
 
 /**
  * A copy of the builtin `EndingType` type as it isn't fully supported in certain

package/src/internal/detect-platform.ts

@@ -25,11 +25,7 @@ function getDetectedPlatform(): DetectedPlatform {
   if (typeof EdgeRuntime !== 'undefined') {
     return 'edge';
   }
-  if (
-    Object.prototype.toString.call(
-      typeof (globalThis as any).process !== 'undefined' ? (globalThis as any).process : 0,
-    ) === '[object process]'
-  ) {
+  if (Object.prototype.toString.call(typeof (globalThis as any).process !== 'undefined' ? (globalThis as any).process : 0) === '[object process]') {
     return 'node';
   }
   return 'unknown';

package/src/internal/errors.ts

@@ -2,12 +2,12 @@
 
 export function isAbortError(err: unknown) {
   return (
-    typeof err === 'object' &&
-    err !== null &&
-    // Spec-compliant fetch implementations
-    (('name' in err && (err as any).name === 'AbortError') ||
+    typeof err === 'object' && err !== null && (
+      // Spec-compliant fetch implementations
+      ('name' in err && (err as any).name === 'AbortError') ||
       // Expo fetch
-      ('message' in err && String((err as any).message).includes('FetchRequestCanceledException')))
+      ('message' in err && String((err as any).message).includes('FetchRequestCanceledException'))
+    )
   );
 }
 
@@ -24,10 +24,10 @@ export const castToError = (err: any): Error => {
         if (err.name) error.name = err.name;
         return error;
       }
-    } catch {}
+    } catch { }
     try {
       return new Error(JSON.stringify(err));
-    } catch {}
+    } catch { }
   }
   return new Error(err);
 };

package/src/internal/headers.ts

@@ -1,6 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { isReadonlyArray } from './utils/values';
+import { isReadonlyArray } from "./utils/values";
 
 type HeaderValue = string | undefined | null;
 export type HeadersLike =
@@ -51,7 +51,7 @@ function* iterateHeaders(headers: HeadersLike): IterableIterator<readonly [strin
   }
   for (let row of iter) {
     const name = row[0];
-    if (typeof name !== 'string') throw new TypeError('expected header name to be a string');
+    if (typeof name !== "string") throw new TypeError("expected header name to be a string")
     const values = isReadonlyArray(row[1]) ? row[1] : [row[1]];
     let didClear = false;
     for (const value of values) {

package/src/internal/parse.ts

@@ -16,6 +16,7 @@ export type APIResponseProps = {
 export async function defaultParseResponse<T>(client: Chamelaion, props: APIResponseProps): Promise<T> {
   const { response, requestLogID, retryOfRequestLogID, startTime } = props;
   const body = await (async () => {
+
     // fetch refuses to read the body when the status code is 204.
     if (response.status === 204) {
       return null as T;
@@ -42,15 +43,6 @@ export async function defaultParseResponse<T>(client: Chamelaion, props: APIResp
     const text = await response.text();
     return text as unknown as T;
   })();
-  loggerFor(client).debug(
-    `[${requestLogID}] response parsed`,
-    formatRequestDetails({
-      retryOfRequestLogID,
-      url: response.url,
-      status: response.status,
-      body,
-      durationMs: Date.now() - startTime,
-    }),
-  );
+  loggerFor(client).debug(`[${requestLogID}] response parsed`, formatRequestDetails({ retryOfRequestLogID, url: response.url, status: response.status, body, durationMs: Date.now() - startTime }));
   return body;
 }