diffio 0.1.0

package/dist/api/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./resources"), exports);

package/dist/api/resources/audioIsolation/client/Client.d.ts

@@ -0,0 +1,41 @@
+import type { DiffioClient } from "../../../../Client";
+import type { AudioIsolationResult, RestoreMetadata } from "../../../types";
+export interface AudioIsolationRestoreOptions {
+    filePath: string;
+    contentType?: string;
+    contentLength?: number;
+    fileFormat?: string;
+    model?: string;
+    sampling?: Record<string, unknown>;
+    projectParams?: Record<string, unknown>;
+    generationParams?: Record<string, unknown>;
+    downloadType?: string;
+    pollInterval?: number;
+    timeout?: number;
+    timeoutInSeconds?: number;
+    onProgress?: (progress: unknown) => void | Promise<void>;
+    showProgress?: boolean;
+    requestOptions?: DiffioClient.RequestOptions;
+    progressRequestOptions?: DiffioClient.RequestOptions;
+    downloadRequestOptions?: DiffioClient.RequestOptions;
+    raiseOnError?: boolean;
+}
+export interface AudioIsolationIsolateOptions {
+    filePath: string;
+    contentType?: string;
+    contentLength?: number;
+    fileFormat?: string;
+    model?: string;
+    sampling?: Record<string, unknown>;
+    projectParams?: Record<string, unknown>;
+    generationParams?: Record<string, unknown>;
+    requestOptions?: DiffioClient.RequestOptions;
+}
+export declare class AudioIsolationClient {
+    private _parent;
+    constructor(parent: DiffioClient);
+    convert(options: AudioIsolationIsolateOptions): Promise<AudioIsolationResult>;
+    isolate(options: AudioIsolationIsolateOptions): Promise<AudioIsolationResult>;
+    restoreAudio(options: AudioIsolationRestoreOptions): Promise<[Uint8Array | null, RestoreMetadata]>;
+    restore(options: AudioIsolationRestoreOptions): Promise<[Uint8Array | null, RestoreMetadata]>;
+}

package/dist/api/resources/audioIsolation/client/Client.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioIsolationClient = void 0;
+class AudioIsolationClient {
+    constructor(parent) {
+        this._parent = parent;
+    }
+    async convert(options) {
+        return this.isolate(options);
+    }
+    async isolate(options) {
+        const { filePath, contentType, contentLength, fileFormat, model, sampling, projectParams, generationParams, requestOptions } = options;
+        return this._parent.audioIsolationIsolate({
+            filePath,
+            contentType,
+            contentLength,
+            fileFormat,
+            model,
+            sampling,
+            projectParams,
+            generationParams,
+            requestOptions
+        });
+    }
+    async restoreAudio(options) {
+        return this._parent.restoreAudio(options);
+    }
+    async restore(options) {
+        return this.restoreAudio(options);
+    }
+}
+exports.AudioIsolationClient = AudioIsolationClient;

package/dist/api/resources/generations/client/Client.d.ts

@@ -0,0 +1,47 @@
+import type { DiffioClient } from "../../../../Client";
+import type { CreateGenerationResponse, GenerationDownloadResponse, GenerationProgressResponse } from "../../../types";
+export interface GenerationCreateOptions {
+    apiProjectId: string;
+    model?: string;
+    sampling?: Record<string, unknown>;
+    params?: Record<string, unknown>;
+    requestOptions?: DiffioClient.RequestOptions;
+}
+export interface GenerationProgressOptions {
+    generationId: string;
+    apiProjectId?: string;
+    requestOptions?: DiffioClient.RequestOptions;
+}
+export interface GenerationDownloadOptions {
+    generationId: string;
+    apiProjectId: string;
+    downloadType?: string;
+    requestOptions?: DiffioClient.RequestOptions;
+}
+export interface GenerationWaitOptions {
+    generationId: string;
+    apiProjectId?: string;
+    pollInterval?: number;
+    timeout?: number;
+    timeoutInSeconds?: number;
+    onProgress?: (progress: GenerationProgressResponse) => void | Promise<void>;
+    showProgress?: boolean;
+    requestOptions?: DiffioClient.RequestOptions;
+}
+export interface GenerationCreateAndWaitOptions extends GenerationCreateOptions {
+    pollInterval?: number;
+    timeout?: number;
+    timeoutInSeconds?: number;
+    onProgress?: (progress: GenerationProgressResponse) => void | Promise<void>;
+    showProgress?: boolean;
+    progressRequestOptions?: DiffioClient.RequestOptions;
+}
+export declare class GenerationsClient {
+    private _parent;
+    constructor(parent: DiffioClient);
+    create(options: GenerationCreateOptions): Promise<CreateGenerationResponse>;
+    getProgress(options: GenerationProgressOptions): Promise<GenerationProgressResponse>;
+    getDownload(options: GenerationDownloadOptions): Promise<GenerationDownloadResponse>;
+    waitForComplete(options: GenerationWaitOptions): Promise<GenerationProgressResponse>;
+    createAndWait(options: GenerationCreateAndWaitOptions): Promise<[CreateGenerationResponse, GenerationProgressResponse]>;
+}

package/dist/api/resources/generations/client/Client.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerationsClient = void 0;
+class GenerationsClient {
+    constructor(parent) {
+        this._parent = parent;
+    }
+    async create(options) {
+        return this._parent.createGeneration(options);
+    }
+    async getProgress(options) {
+        return this._parent.getGenerationProgress(options);
+    }
+    async getDownload(options) {
+        return this._parent.getGenerationDownload(options);
+    }
+    async waitForComplete(options) {
+        return this._parent.waitForGeneration(options);
+    }
+    async createAndWait(options) {
+        const { progressRequestOptions, ...createOptions } = options;
+        const generation = await this.create(createOptions);
+        const progress = await this.waitForComplete({
+            generationId: generation.generationId,
+            apiProjectId: generation.apiProjectId,
+            pollInterval: options.pollInterval,
+            timeout: options.timeout,
+            timeoutInSeconds: options.timeoutInSeconds,
+            onProgress: options.onProgress,
+            showProgress: options.showProgress,
+            requestOptions: progressRequestOptions ?? options.requestOptions
+        });
+        return [generation, progress];
+    }
+}
+exports.GenerationsClient = GenerationsClient;

package/dist/api/resources/index.d.ts

@@ -0,0 +1,4 @@
+export { AudioIsolationClient } from "./audioIsolation/client/Client";
+export { GenerationsClient } from "./generations/client/Client";
+export { ProjectsClient } from "./projects/client/Client";
+export { WebhooksClient } from "./webhooks/client/Client";

package/dist/api/resources/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhooksClient = exports.ProjectsClient = exports.GenerationsClient = exports.AudioIsolationClient = void 0;
+var Client_1 = require("./audioIsolation/client/Client");
+Object.defineProperty(exports, "AudioIsolationClient", { enumerable: true, get: function () { return Client_1.AudioIsolationClient; } });
+var Client_2 = require("./generations/client/Client");
+Object.defineProperty(exports, "GenerationsClient", { enumerable: true, get: function () { return Client_2.GenerationsClient; } });
+var Client_3 = require("./projects/client/Client");
+Object.defineProperty(exports, "ProjectsClient", { enumerable: true, get: function () { return Client_3.ProjectsClient; } });
+var Client_4 = require("./webhooks/client/Client");
+Object.defineProperty(exports, "WebhooksClient", { enumerable: true, get: function () { return Client_4.WebhooksClient; } });

package/dist/api/resources/projects/client/Client.d.ts

@@ -0,0 +1,15 @@
+import type { DiffioClient } from "../../../../Client";
+import type { ListProjectGenerationsResponse, ListProjectsResponse } from "../../../types";
+export interface ProjectsListOptions {
+    requestOptions?: DiffioClient.RequestOptions;
+}
+export interface ProjectsListGenerationsOptions {
+    apiProjectId: string;
+    requestOptions?: DiffioClient.RequestOptions;
+}
+export declare class ProjectsClient {
+    private _parent;
+    constructor(parent: DiffioClient);
+    list(options?: ProjectsListOptions): Promise<ListProjectsResponse>;
+    listGenerations(options: ProjectsListGenerationsOptions): Promise<ListProjectGenerationsResponse>;
+}

package/dist/api/resources/projects/client/Client.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectsClient = void 0;
+class ProjectsClient {
+    constructor(parent) {
+        this._parent = parent;
+    }
+    async list(options = {}) {
+        return this._parent.listProjects(options);
+    }
+    async listGenerations(options) {
+        return this._parent.listProjectGenerations(options);
+    }
+}
+exports.ProjectsClient = ProjectsClient;

package/dist/api/resources/webhooks/client/Client.d.ts

@@ -0,0 +1,20 @@
+import type { DiffioClient } from "../../../../Client";
+import type { WebhookPortalResponse, WebhookTestEventResponse } from "../../../types";
+export interface WebhookPortalAccessOptions {
+    mode: string;
+    apiKeyId?: string;
+    requestOptions?: DiffioClient.RequestOptions;
+}
+export interface WebhookTestEventOptions {
+    eventType: string;
+    mode: string;
+    apiKeyId?: string;
+    samplePayload?: Record<string, unknown>;
+    requestOptions?: DiffioClient.RequestOptions;
+}
+export declare class WebhooksClient {
+    private _parent;
+    constructor(parent: DiffioClient);
+    getPortalAccess(options: WebhookPortalAccessOptions): Promise<WebhookPortalResponse>;
+    sendTestEvent(options: WebhookTestEventOptions): Promise<WebhookTestEventResponse>;
+}

package/dist/api/resources/webhooks/client/Client.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhooksClient = void 0;
+class WebhooksClient {
+    constructor(parent) {
+        this._parent = parent;
+    }
+    async getPortalAccess(options) {
+        return this._parent.getWebhooksPortalAccess(options);
+    }
+    async sendTestEvent(options) {
+        return this._parent.sendWebhookTestEvent(options);
+    }
+}
+exports.WebhooksClient = WebhooksClient;

package/dist/api/serialization.d.ts

@@ -0,0 +1,14 @@
+import type { AudioIsolationResult, CreateGenerationResponse, CreateProjectResponse, GenerationWebhookEvent, GenerationDownloadResponse, GenerationProgressResponse, GenerationProgressStage, ListProjectGenerationsResponse, ListProjectsResponse, ProjectGenerationSummary, ProjectSummary, WebhookPortalResponse, WebhookTestEventResponse } from "./types";
+export declare function parseCreateProjectResponse(data: any): CreateProjectResponse;
+export declare function parseProjectSummary(data: any): ProjectSummary;
+export declare function parseListProjectsResponse(data: any): ListProjectsResponse;
+export declare function parseCreateGenerationResponse(data: any): CreateGenerationResponse;
+export declare function parseProjectGenerationSummary(data: any): ProjectGenerationSummary;
+export declare function parseListProjectGenerationsResponse(data: any): ListProjectGenerationsResponse;
+export declare function parseGenerationProgressStage(data: any): GenerationProgressStage;
+export declare function parseGenerationProgressResponse(data: any): GenerationProgressResponse;
+export declare function parseGenerationDownloadResponse(data: any): GenerationDownloadResponse;
+export declare function parseWebhookPortalResponse(data: any): WebhookPortalResponse;
+export declare function parseWebhookTestEventResponse(data: any): WebhookTestEventResponse;
+export declare function parseGenerationWebhookEvent(data: any): GenerationWebhookEvent;
+export declare function createAudioIsolationResult(project: CreateProjectResponse, generation: CreateGenerationResponse): AudioIsolationResult;

package/dist/api/serialization.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCreateProjectResponse = parseCreateProjectResponse;
+exports.parseProjectSummary = parseProjectSummary;
+exports.parseListProjectsResponse = parseListProjectsResponse;
+exports.parseCreateGenerationResponse = parseCreateGenerationResponse;
+exports.parseProjectGenerationSummary = parseProjectGenerationSummary;
+exports.parseListProjectGenerationsResponse = parseListProjectGenerationsResponse;
+exports.parseGenerationProgressStage = parseGenerationProgressStage;
+exports.parseGenerationProgressResponse = parseGenerationProgressResponse;
+exports.parseGenerationDownloadResponse = parseGenerationDownloadResponse;
+exports.parseWebhookPortalResponse = parseWebhookPortalResponse;
+exports.parseWebhookTestEventResponse = parseWebhookTestEventResponse;
+exports.parseGenerationWebhookEvent = parseGenerationWebhookEvent;
+exports.createAudioIsolationResult = createAudioIsolationResult;
+function parseCreateProjectResponse(data) {
+    return {
+        apiProjectId: data.apiProjectId,
+        uploadUrl: data.uploadUrl,
+        uploadMethod: data.uploadMethod || "PUT",
+        objectPath: data.objectPath,
+        bucket: data.bucket,
+        expiresAt: data.expiresAt
+    };
+}
+function parseProjectSummary(data) {
+    return {
+        apiProjectId: data.apiProjectId,
+        status: data.status || "uploading",
+        originalFileName: data.originalFileName ?? null,
+        contentType: data.contentType ?? null,
+        hasVideo: Boolean(data.hasVideo),
+        generationCount: Number(data.generationCount || 0),
+        createdAt: data.createdAt ?? null,
+        updatedAt: data.updatedAt ?? null
+    };
+}
+function parseListProjectsResponse(data) {
+    const items = Array.isArray(data?.projects) ? data.projects : [];
+    return { projects: items.filter(Boolean).map(parseProjectSummary) };
+}
+function parseCreateGenerationResponse(data) {
+    return {
+        generationId: data.generationId,
+        apiProjectId: data.apiProjectId,
+        modelKey: data.modelKey,
+        status: data.status
+    };
+}
+function parseProjectGenerationSummary(data) {
+    const progress = data.progress;
+    return {
+        generationId: data.generationId,
+        status: data.status || "queued",
+        modelKey: data.modelKey ?? null,
+        progress: progress != null ? Number(progress) : null,
+        createdAt: data.createdAt ?? null,
+        updatedAt: data.updatedAt ?? null
+    };
+}
+function parseListProjectGenerationsResponse(data) {
+    const items = Array.isArray(data?.generations) ? data.generations : [];
+    return {
+        apiProjectId: data.apiProjectId,
+        generations: items.filter(Boolean).map(parseProjectGenerationSummary)
+    };
+}
+function parseGenerationProgressStage(data) {
+    return {
+        jobId: data?.jobId ?? null,
+        jobState: data?.jobState ?? null,
+        status: data?.status || "pending",
+        progress: Number(data?.progress || 0),
+        statusMessage: data?.statusMessage ?? null,
+        error: data?.error ?? null,
+        errorDetails: data?.errorDetails ?? null
+    };
+}
+function parseGenerationProgressResponse(data) {
+    const restoredVideo = data?.restoredVideo;
+    return {
+        generationId: data.generationId,
+        apiProjectId: data.apiProjectId,
+        status: data.status,
+        hasVideo: Boolean(data.hasVideo),
+        preProcessing: parseGenerationProgressStage(data.preProcessing),
+        inference: parseGenerationProgressStage(data.inference),
+        restoredVideo: restoredVideo ? parseGenerationProgressStage(restoredVideo) : null,
+        error: data.error ?? null,
+        errorDetails: data.errorDetails ?? null
+    };
+}
+function parseGenerationDownloadResponse(data) {
+    return {
+        generationId: data.generationId,
+        apiProjectId: data.apiProjectId,
+        downloadType: data.downloadType,
+        downloadUrl: data.downloadUrl,
+        fileName: data.fileName,
+        storagePath: data.storagePath,
+        bucket: data.bucket,
+        mimeType: data.mimeType
+    };
+}
+function parseWebhookPortalResponse(data) {
+    return {
+        portalUrl: data.portalUrl,
+        mode: data.mode ?? null,
+        apiKeyId: data.apiKeyId ?? null
+    };
+}
+function parseWebhookTestEventResponse(data) {
+    return {
+        svixMessageId: data.svixMessageId,
+        eventId: data.eventId,
+        eventType: data.eventType,
+        mode: data.mode ?? null,
+        apiKeyId: data.apiKeyId ?? null
+    };
+}
+function parseGenerationWebhookEvent(data) {
+    return {
+        eventType: data.eventType,
+        eventId: data.eventId,
+        createdAt: data.createdAt,
+        apiKeyId: data.apiKeyId,
+        apiProjectId: data.apiProjectId ?? null,
+        generationId: data.generationId,
+        status: data.status,
+        hasVideo: data.hasVideo ?? null,
+        modelKey: data.modelKey ?? null,
+        error: data.error ?? null,
+        errorDetails: data.errorDetails ?? null
+    };
+}
+function createAudioIsolationResult(project, generation) {
+    return { project, generation };
+}

package/dist/api/types.d.ts

@@ -0,0 +1,122 @@
+export type ModelKey = "diffio-2" | "diffio-2-flash" | "diffio-3";
+export type DownloadType = "audio" | "video";
+export type WebhookMode = "test" | "live";
+export type WebhookEventType = "generation.queued" | "generation.processing" | "generation.failed" | "generation.completed";
+export type GenerationWebhookStatus = "queued" | "processing" | "error" | "complete";
+export interface CreateProjectResponse {
+    apiProjectId: string;
+    uploadUrl: string;
+    uploadMethod: string;
+    objectPath: string;
+    bucket: string;
+    expiresAt: string;
+}
+export interface ProjectSummary {
+    apiProjectId: string;
+    status: string;
+    originalFileName?: string | null;
+    contentType?: string | null;
+    hasVideo: boolean;
+    generationCount: number;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+}
+export interface ListProjectsResponse {
+    projects: ProjectSummary[];
+}
+export interface CreateGenerationResponse {
+    generationId: string;
+    apiProjectId: string;
+    modelKey: ModelKey | string;
+    status: string;
+}
+export interface ProjectGenerationSummary {
+    generationId: string;
+    status: string;
+    modelKey?: ModelKey | string | null;
+    progress?: number | null;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+}
+export interface ListProjectGenerationsResponse {
+    apiProjectId: string;
+    generations: ProjectGenerationSummary[];
+}
+export interface GenerationProgressStage {
+    jobId?: string | null;
+    jobState?: string | null;
+    status: string;
+    progress: number;
+    statusMessage?: string | null;
+    error?: string | null;
+    errorDetails?: string | null;
+}
+export interface GenerationProgressResponse {
+    generationId: string;
+    apiProjectId: string;
+    status: string;
+    hasVideo: boolean;
+    preProcessing: GenerationProgressStage;
+    inference: GenerationProgressStage;
+    restoredVideo?: GenerationProgressStage | null;
+    error?: string | null;
+    errorDetails?: string | null;
+}
+export interface GenerationDownloadResponse {
+    generationId: string;
+    apiProjectId: string;
+    downloadType: DownloadType | string;
+    downloadUrl: string;
+    fileName: string;
+    storagePath: string;
+    bucket: string;
+    mimeType: string;
+}
+export interface AudioIsolationResult {
+    project: CreateProjectResponse;
+    generation: CreateGenerationResponse;
+}
+export interface WebhookPortalResponse {
+    portalUrl: string;
+    mode?: WebhookMode | string | null;
+    apiKeyId?: string | null;
+}
+export interface WebhookTestEventResponse {
+    svixMessageId: string;
+    eventId: string;
+    eventType: WebhookEventType | string;
+    mode?: WebhookMode | string | null;
+    apiKeyId?: string | null;
+}
+export interface GenerationWebhookEvent {
+    eventType: WebhookEventType | string;
+    eventId: string;
+    createdAt: string;
+    apiKeyId: string;
+    apiProjectId?: string | null;
+    generationId: string;
+    status: GenerationWebhookStatus | string;
+    hasVideo?: boolean | null;
+    modelKey?: ModelKey | string | null;
+    error?: string | null;
+    errorDetails?: string | null;
+}
+export interface RestoreMetadata {
+    ok: boolean;
+    stage: string;
+    apiProjectId: string | null;
+    generationId: string | null;
+    project: CreateProjectResponse | null;
+    generation: CreateGenerationResponse | null;
+    progress: GenerationProgressResponse | null;
+    download: GenerationDownloadResponse | null;
+    downloadType: DownloadType | string | null;
+    downloadUrl: string | null;
+    fileName: string | null;
+    mimeType: string | null;
+    status: string | null;
+    error: string | null;
+    errorDetails: string | null;
+    exceptionType: string | null;
+    exceptionMessage: string | null;
+}

package/dist/api/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/headers.d.ts

@@ -0,0 +1,6 @@
+import { type Supplier as SupplierType } from "./supplier";
+export type HeaderValue = string | SupplierType<string | null | undefined> | null | undefined;
+export type HeaderRecord = Record<string, HeaderValue>;
+export declare function mergeHeaders(...sets: Array<HeaderRecord | null | undefined>): HeaderRecord;
+export declare function mergeOnlyDefinedHeaders(headers: HeaderRecord): HeaderRecord;
+export declare function resolveHeaders(headers: HeaderRecord | null | undefined): Promise<Record<string, string>>;

package/dist/core/headers.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeHeaders = mergeHeaders;
+exports.mergeOnlyDefinedHeaders = mergeOnlyDefinedHeaders;
+exports.resolveHeaders = resolveHeaders;
+const supplier_1 = require("./supplier");
+function mergeHeaders(...sets) {
+    const result = {};
+    for (const set of sets) {
+        if (!set) {
+            continue;
+        }
+        for (const [key, value] of Object.entries(set)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function mergeOnlyDefinedHeaders(headers) {
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (value !== undefined) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+async function resolveHeaders(headers) {
+    const resolved = {};
+    if (!headers) {
+        return resolved;
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        if (value == null) {
+            continue;
+        }
+        const resolvedValue = await supplier_1.Supplier.get(value);
+        if (resolvedValue == null) {
+            continue;
+        }
+        resolved[key] = resolvedValue;
+    }
+    return resolved;
+}

package/dist/core/retry.d.ts

@@ -0,0 +1,7 @@
+export declare function sleep(ms: number): Promise<void>;
+export interface RetryOptions {
+    maxRetries: number;
+    retryBackoff: number;
+    retryStatusCodes: number[];
+}
+export declare function requestWithRetries(requestFn: () => Promise<Response>, { maxRetries, retryBackoff, retryStatusCodes }: RetryOptions): Promise<Response>;

package/dist/core/retry.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = sleep;
+exports.requestWithRetries = requestWithRetries;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function requestWithRetries(requestFn, { maxRetries, retryBackoff, retryStatusCodes }) {
+    let attempt = 0;
+    while (true) {
+        try {
+            const response = await requestFn();
+            if (retryStatusCodes.length > 0 &&
+                retryStatusCodes.includes(response.status) &&
+                attempt < maxRetries) {
+                response.body?.cancel?.();
+                await sleep(retryBackoff * 1000 * 2 ** attempt);
+                attempt += 1;
+                continue;
+            }
+            return response;
+        }
+        catch (error) {
+            if (attempt >= maxRetries) {
+                throw error;
+            }
+            await sleep(retryBackoff * 1000 * 2 ** attempt);
+            attempt += 1;
+        }
+    }
+}

package/dist/core/supplier.d.ts

@@ -0,0 +1,4 @@
+export type Supplier<T> = T | (() => T | Promise<T>);
+export declare const Supplier: {
+    get<T>(value: Supplier<T> | null | undefined): Promise<T | undefined>;
+};

package/dist/core/supplier.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Supplier = void 0;
+exports.Supplier = {
+    async get(value) {
+        if (value == null) {
+            return undefined;
+        }
+        if (typeof value === "function") {
+            return value();
+        }
+        return value;
+    }
+};

package/dist/core/url.d.ts

@@ -0,0 +1 @@
+export declare function join(base: string, ...paths: string[]): string;