@cloudbase/js-sdk 3.8.2-beta.1 → 3.8.2-beta.2

package/realtime/dist/message.d.ts

@@ -0,0 +1,3 @@
+import { IResponseMessage, IResponseMessageInitEventMsg } from '@cloudbase/js-sdk/types/realtime';
+export declare function genRequestId(prefix?: string): string;
+export declare function isInitEventMessage(msg: IResponseMessage): msg is IResponseMessageInitEventMsg;

package/realtime/dist/snapshot.d.ts

@@ -0,0 +1,17 @@
+import { SnapshotType, ISnapshot } from '@cloudbase/js-sdk/types/realtime';
+import { ISingleDBEvent } from '@cloudbase/js-sdk/types/database';
+interface ISnapshotConstructorOptions {
+    id: number;
+    docChanges: ISingleDBEvent[];
+    docs: Record<string, any>[];
+    type?: SnapshotType;
+    msgType?: String;
+}
+export declare class Snapshot implements ISnapshot {
+    id: number;
+    docChanges: ISingleDBEvent[];
+    docs: Record<string, any>[];
+    type?: 'init';
+    constructor(options: ISnapshotConstructorOptions);
+}
+export {};

package/realtime/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms?: number) => Promise<unknown>;

package/realtime/dist/virtual-websocket-client.d.ts

@@ -0,0 +1,62 @@
+import { IResponseMessage, IWatchOptions } from '@cloudbase/js-sdk/types/realtime';
+import { RealtimeListener } from './listener';
+import { IWSSendOptions } from './websocket-client';
+interface IVirtualWebSocketClientConstructorOptions extends IWatchOptions {
+    envId?: string;
+    collectionName: string;
+    query: string;
+    limit?: number;
+    orderBy?: Record<string, string>;
+    send: <T = any>(opts: IWSSendOptions) => Promise<T>;
+    login: (envId?: string, refresh?: boolean) => Promise<any>;
+    isWSConnected: () => boolean;
+    onceWSConnected: () => Promise<void>;
+    getWaitExpectedTimeoutLength: () => number;
+    onWatchStart: (client: VirtualWebSocketClient, queryID: string) => void;
+    onWatchClose: (client: VirtualWebSocketClient, queryID: string) => void;
+    debug?: boolean;
+}
+export declare class VirtualWebSocketClient {
+    watchId: string;
+    listener: RealtimeListener;
+    private envId?;
+    private collectionName;
+    private query;
+    private limit;
+    private orderBy;
+    private send;
+    private login;
+    private isWSConnected;
+    private onceWSConnected;
+    private getWaitExpectedTimeoutLength;
+    private onWatchStart;
+    private onWatchClose;
+    private debug?;
+    private watchStatus;
+    private availableRetries;
+    private ackTimeoutId?;
+    private initWatchPromise?;
+    private rebuildWatchPromise?;
+    private sessionInfo?;
+    private waitExpectedTimeoutId?;
+    constructor(options: IVirtualWebSocketClientConstructorOptions);
+    onMessage(msg: IResponseMessage): void;
+    closeWithError(error: any): void;
+    pause(): void;
+    resume(): Promise<void>;
+    private wsLogin;
+    private initWatch;
+    private rebuildWatch;
+    private handleWatchEstablishmentError;
+    private closeWatch;
+    private scheduleSendACK;
+    private clearACKSchedule;
+    private sendACK;
+    private handleCommonError;
+    private useRetryTicket;
+    private handleServerEvents;
+    private handleServerEventsInternel;
+    private postHandleServerEventsValidityCheck;
+    private clearWaitExpectedEvent;
+}
+export {};

package/realtime/dist/websocket-client.d.ts

@@ -0,0 +1,78 @@
+import { VirtualWebSocketClient } from './virtual-websocket-client';
+import { IDatabaseServiceContext } from '@cloudbase/js-sdk/types/database';
+import { IWatchOptions, DBRealtimeListener, IRequestMessage } from '@cloudbase/js-sdk/types/realtime';
+import { CloseEventCode } from './ws-event';
+export interface IRealtimeWebSocketClientConstructorOptions {
+    maxReconnect?: number;
+    reconnectInterval?: number;
+    context: IDatabaseServiceContext;
+}
+export interface ISignature {
+    envId: string;
+    secretVersion: number;
+    signStr: string;
+    wsUrl: string;
+    expireTS: number;
+}
+export interface ILoginInfo {
+    loggedIn: boolean;
+    loggingInPromise?: Promise<ILoginResult>;
+    loginStartTS?: number;
+    loginResult?: ILoginResult;
+}
+export interface ILoginResult {
+    envId: string;
+}
+export interface IWSSendOptions {
+    msg: IRequestMessage;
+    waitResponse?: boolean;
+    skipOnMessage?: boolean;
+    timeout?: number;
+}
+export interface IWSWatchOptions extends IWatchOptions {
+    envId?: string;
+    collectionName: string;
+    query: string;
+    limit?: number;
+    orderBy?: Record<string, string>;
+}
+export declare class RealtimeWebSocketClient {
+    private virtualWSClient;
+    private queryIdClientMap;
+    private watchIdClientMap;
+    private maxReconnect;
+    private reconnectInterval;
+    private context;
+    private ws?;
+    private lastPingSendTS?;
+    private pingFailed;
+    private pongMissed;
+    private pingTimeoutId?;
+    private pongTimeoutId?;
+    private logins;
+    private wsInitPromise?;
+    private wsReadySubsribers;
+    private wsResponseWait;
+    private rttObserved;
+    private reconnectState;
+    private wsSign;
+    constructor(options: IRealtimeWebSocketClientConstructorOptions);
+    clearHeartbeat(): void;
+    send: <T = any>(opts: IWSSendOptions) => Promise<T>;
+    close(code: CloseEventCode): void;
+    closeAllClients: (error: any) => void;
+    pauseClients: (clients?: Set<VirtualWebSocketClient>) => void;
+    resumeClients: (clients?: Set<VirtualWebSocketClient>) => void;
+    watch(options: IWSWatchOptions): DBRealtimeListener;
+    private initWebSocketConnection;
+    private initWebSocketEvent;
+    private isWSConnected;
+    private onceWSConnected;
+    private webLogin;
+    private getWsSign;
+    private getWaitExpectedTimeoutLength;
+    private heartbeat;
+    private ping;
+    private onWatchStart;
+    private onWatchClose;
+}

package/realtime/dist/ws-event.d.ts

@@ -0,0 +1,126 @@
+import { CloudSDKError } from './error';
+export declare const CLOSE_EVENT_CODE_INFO: {
+    1000: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1001: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1002: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1003: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1005: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1006: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1007: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1008: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1009: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1010: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1011: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1012: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1013: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1014: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    1015: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    3000: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    3001: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    3002: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    3003: {
+        code: number;
+        name: string;
+        description: string;
+    };
+    3050: {
+        code: number;
+        name: string;
+        description: string;
+    };
+};
+export declare enum CloseEventCode {
+    NormalClosure = 1000,
+    GoingAway = 1001,
+    ProtocolError = 1002,
+    UnsupportedData = 1003,
+    NoStatusReceived = 1005,
+    AbnormalClosure = 1006,
+    InvalidFramePayloadData = 1007,
+    PolicyViolation = 1008,
+    MessageTooBig = 1009,
+    MissingExtension = 1010,
+    InternalError = 1011,
+    ServiceRestart = 1012,
+    TryAgainLater = 1013,
+    BadGateway = 1014,
+    TLSHandshake = 1015,
+    ReconnectWebSocket = 3000,
+    NoRealtimeListeners = 3001,
+    HeartbeatPingError = 3002,
+    HeartbeatPongTimeoutError = 3003,
+    NoAuthentication = 3050
+}
+export declare const getWSCloseError: (code: CloseEventCode, reason?: string) => CloudSDKError;

package/storage/dist/cloudbase-storage.d.ts

@@ -0,0 +1,58 @@
+import { ICloudbaseUploadFileParams, ICloudbaseUploadFileResult, ICloudbaseGetUploadMetadataParams, ICloudbaseDeleteFileParams, ICloudbaseDeleteFileResult, ICloudbaseGetTempFileURLResult, ICloudbaseGetTempFileURLParams, ICloudbaseDownloadFileResult, ICloudbaseDownloadFileParams, ICloudbaseCopyFileParams, ICloudbaseCopyFileResult } from '@cloudbase/js-sdk/types/storage';
+export declare enum EUploadMethod {
+    put = "put",
+    post = "post"
+}
+export interface IUploadMetadata {
+    url: string;
+    token: string;
+    authorization: string;
+    fileId: string;
+    cosFileId: string;
+    download_url?: string;
+}
+export declare const COMPONENT_NAME = "storage";
+type SignedHeader = Record<string, string[]>;
+export interface ICloudbaseContext {
+    config: any;
+    request: any;
+}
+type TempFileURLItem = NonNullable<ICloudbaseGetTempFileURLResult['fileList']>[number];
+type FileInfoItem = Pick<TempFileURLItem, 'code' | 'fileID' | 'tempFileURL'> & {
+    message?: TempFileURLItem['message'];
+    fileName?: string;
+    cloudId?: TempFileURLItem['fileID'];
+    contentType?: string;
+    mime?: string;
+    size?: number;
+    cacheControl?: string;
+    lastModified?: string;
+    etag?: string;
+};
+export declare class CloudbaseStorage {
+    protected context?: ICloudbaseContext;
+    constructor(context?: ICloudbaseContext);
+    get config(): any;
+    get request(): any;
+    isGateWay(): boolean;
+    uploadFile(params: Omit<ICloudbaseUploadFileParams, 'filePath'> & {
+        filePath?: string;
+    }, callback?: Function): Promise<ICloudbaseUploadFileResult>;
+    getUploadMetadata(params: ICloudbaseGetUploadMetadataParams & {
+        method?: EUploadMethod;
+        headers?: Record<string, string>;
+        signedHeader?: SignedHeader;
+    }, callback?: Function): Promise<{
+        data: IUploadMetadata;
+        requestId: string;
+    }>;
+    deleteFile(params: ICloudbaseDeleteFileParams, callback?: Function): Promise<ICloudbaseDeleteFileResult>;
+    getTempFileURL(params: ICloudbaseGetTempFileURLParams, callback?: Function): Promise<ICloudbaseGetTempFileURLResult>;
+    downloadFile(params: ICloudbaseDownloadFileParams, callback?: Function): Promise<ICloudbaseDownloadFileResult>;
+    copyFile(params: ICloudbaseCopyFileParams, callback?: Function): Promise<ICloudbaseCopyFileResult>;
+    getFileInfo(params: ICloudbaseGetTempFileURLParams): Promise<{
+        fileList: FileInfoItem[];
+        requestId: string;
+    }>;
+}
+export {};

package/storage/dist/download-builder.d.ts

@@ -0,0 +1,24 @@
+import { Http } from './http';
+import { Result, DownloadOptions, FetchParameters } from './types';
+export interface DownloadContext {
+    http: Http;
+    bucketId: string;
+    cleanName: string;
+    options?: DownloadOptions;
+    parameters?: FetchParameters;
+    headers?: Record<string, string>;
+    shouldThrowOnError: boolean;
+}
+export declare class StreamDownloadBuilder implements PromiseLike<Result<ReadableStream<Uint8Array>>> {
+    private ctx;
+    constructor(ctx: DownloadContext);
+    then<TResult1 = Result<ReadableStream<Uint8Array>>, TResult2 = never>(onfulfilled?: ((value: Result<ReadableStream<Uint8Array>>) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+    private execute;
+}
+export declare class DownloadBuilder implements PromiseLike<Result<Blob>> {
+    private ctx;
+    constructor(ctx: DownloadContext);
+    asStream(): StreamDownloadBuilder;
+    then<TResult1 = Result<Blob>, TResult2 = never>(onfulfilled?: ((value: Result<Blob>) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+    private execute;
+}

package/storage/dist/encoding.d.ts

@@ -0,0 +1,3 @@
+export declare function getStringByteLength(data: string): number | undefined;
+export declare function toBase64(data: string): string;
+export declare function encodeObjectName(cleanName: string): string;

package/storage/dist/http.d.ts

@@ -0,0 +1,38 @@
+import { Result, FetchParameters } from './types';
+export interface Context {
+    config: any;
+    request: any;
+}
+export declare function handleOperation<T>(fn: () => Promise<T>, shouldThrowOnError: boolean): Promise<Result<T>>;
+export declare class Http {
+    readonly ctx: Context;
+    constructor(ctx: Context);
+    private get request();
+    gatewayOrigin(): string;
+    buildUrl(path: string, query?: Record<string, any>): string;
+    toFullUrl(maybeRelative: string): string;
+    send<T = any>(opts: {
+        method: string;
+        path: string;
+        json?: any;
+        rawBody?: any;
+        headers?: Record<string, string>;
+        query?: Record<string, any>;
+        withCredentials?: boolean;
+        signal?: AbortSignal;
+        cache?: FetchParameters['cache'];
+    }): Promise<T>;
+    download(opts: {
+        path: string;
+        headers?: Record<string, string>;
+        query?: Record<string, any>;
+        withCredentials?: boolean;
+        signal?: AbortSignal;
+        cache?: FetchParameters['cache'];
+    }): Promise<{
+        response: Response;
+        status: number;
+        header: any;
+    }>;
+    private unwrap;
+}

package/storage/dist/index.d.ts

@@ -1,2 +1,13 @@
-import { ICloudbase } from '@cloudbase/types';
-export declare const registerStorage: (app: ICloudbase) => void;
+import { ICloudbase } from '@cloudbase/js-sdk/types';
+import { StorageFileApi } from './storage-file-api-neo';
+import { StorageBucketApi } from './storage-bucket-api-neo';
+import { ClassicStorageFileApi } from './storage-file-api-classic';
+export { COMPONENT_NAME, CloudbaseStorage } from './cloudbase-storage';
+export type { ICloudbaseContext } from './cloudbase-storage';
+export { ClassicStorageFileApi } from './storage-file-api-classic';
+export { StorageFileApi } from './storage-file-api-neo';
+export declare class StorageClient extends StorageBucketApi {
+    from(): ClassicStorageFileApi;
+    from<const B extends string>(bucketId: B): StorageFileApi;
+}
+export declare function registerStorage(app: Pick<ICloudbase, 'registerComponent'>): void;

package/storage/dist/node-types.d.ts

@@ -0,0 +1,6 @@
+export interface NodeReadableStreamLike {
+    pipe(destination: any, options?: any): any;
+}
+export type MaybeNodeBuffer = typeof globalThis extends {
+    Buffer: new (...args: any[]) => infer B;
+} ? B : never;

package/storage/dist/storage-bucket-api-neo.d.ts

@@ -0,0 +1,15 @@
+import { Context, Http } from './http';
+import { Result, Bucket, ListBucketOptions, CreateBucketOptions, UpdateBucketOptions, MessageResponse } from './types';
+export declare class StorageBucketApi {
+    protected http: Http;
+    protected shouldThrowOnError: boolean;
+    constructor(context?: Context, shouldThrowOnError?: boolean);
+    throwOnError(): this;
+    listBuckets(options?: ListBucketOptions): Promise<Result<Bucket[]>>;
+    getBucket(bucketId: string): Promise<Result<Bucket>>;
+    createBucket(bucketId: string, options?: CreateBucketOptions): Promise<Result<{
+        name: string;
+    }>>;
+    updateBucket(bucketId: string, options: UpdateBucketOptions): Promise<Result<MessageResponse>>;
+    deleteBucket(bucketId: string): Promise<Result<MessageResponse>>;
+}

package/storage/dist/storage-file-api-classic.d.ts

@@ -0,0 +1,80 @@
+import { Camelize, FileBody, FileObject, FileObjectV2, FileOptions, TransformOptions } from './supabase/types';
+import { Result } from './types';
+import { StorageError } from './supabase/errors';
+import { ICloudbaseContext } from './cloudbase-storage';
+export declare class ClassicStorageFileApi {
+    protected shouldThrowOnError: boolean;
+    protected bucketId: string;
+    protected context?: ICloudbaseContext;
+    private storage;
+    constructor(context?: ICloudbaseContext, shouldThrowOnError?: boolean);
+    get config(): any;
+    get request(): any;
+    throwOnError(): this;
+    upload(path: string, fileBody: FileBody, fileOptions?: FileOptions): Promise<Result<{
+        id: string;
+        path: string;
+        fullPath: string;
+    }>>;
+    uploadToSignedUrl(path: string, _token: string, fileBody: FileBody, fileOptions?: FileOptions): Promise<Result<{
+        id: string;
+        path: string;
+        fullPath: string;
+    }>>;
+    createSignedUploadUrl(path: string): Promise<Result<{
+        signedUrl: string;
+        token: string;
+        path: string;
+        authorization?: string;
+        id?: string;
+        cosFileId?: string;
+        downloadUrl?: string;
+    }>>;
+    update(path: string, fileBody: FileBody, fileOptions?: FileOptions): Promise<Result<{
+        id: string;
+        path: string;
+        fullPath: string;
+    }>>;
+    move(fromPath: string, toPath: string): Promise<Result<{
+        message: string;
+    }>>;
+    copy(fromPath: string, toPath: string): Promise<Result<{
+        path: string;
+    }>>;
+    createSignedUrl(path: string, expiresIn: number, options?: {
+        download?: string | boolean;
+        transform?: TransformOptions;
+    }): Promise<Result<{
+        signedUrl: string;
+    }>>;
+    createSignedUrls(paths: string[], expiresIn: number): Promise<Result<Array<{
+        path: string;
+        signedUrl: string;
+        error: string | null;
+    }>>>;
+    download(path: string, options?: TransformOptions): Promise<{
+        data: Blob | null;
+        error: StorageError | null;
+    }>;
+    info(pathOrFileId: string): Promise<Result<Camelize<FileObjectV2>>>;
+    exists(pathOrFileId: string): Promise<Result<boolean>>;
+    getPublicUrl(path: string, options?: {
+        download?: string | boolean;
+        transform?: TransformOptions;
+    }): Promise<{
+        data: {
+            publicUrl: string;
+        };
+    } | {
+        data: null;
+        error: StorageError;
+    }>;
+    remove(paths: string[]): Promise<Result<FileObject[]>>;
+    list(): Promise<void>;
+    private getCloudPath;
+    private normalizeCloudId;
+    private toBase64;
+    private transformOptsToQueryString;
+    private extractPathFromFileId;
+    private extractBucketFromFileId;
+}

package/storage/dist/storage-file-api-neo.d.ts

@@ -0,0 +1,48 @@
+import { Http } from './http';
+import { DownloadBuilder } from './download-builder';
+import { FileBody, Result, UploadOptions, UploadResult, DownloadOptions, ListOptions, ListObjectsResponse, ObjectInfo, FullObject, DestinationOptions, SignedUrlOptions, SignedUrlResult, SignedUrlsResultItem, CreateSignedUploadUrlResult, PublicUrlOptions, FetchParameters } from './types';
+export declare class StorageFileApi {
+    readonly bucketId: string;
+    private http;
+    private shouldThrowOnError;
+    private headers;
+    constructor(http: Http, bucketId: string, shouldThrowOnError?: boolean);
+    throwOnError(): this;
+    setHeader(name: string, value: string): this;
+    upload(path: string, fileBody: FileBody, fileOptions?: UploadOptions): Promise<Result<UploadResult>>;
+    update(path: string, fileBody: FileBody, fileOptions?: UploadOptions): Promise<Result<UploadResult>>;
+    download(path: string, options?: DownloadOptions, parameters?: FetchParameters): DownloadBuilder;
+    list(path?: string, options?: ListOptions, parameters?: FetchParameters): Promise<Result<ListObjectsResponse>>;
+    remove(paths: string[]): Promise<Result<FullObject[]>>;
+    copy(fromPath: string, toPath: string, options?: DestinationOptions): Promise<Result<{
+        path: string;
+    }>>;
+    move(fromPath: string, toPath: string, options?: DestinationOptions): Promise<Result<{
+        message: string;
+    }>>;
+    info(path: string): Promise<Result<ObjectInfo>>;
+    exists(path: string): Promise<Result<boolean>>;
+    createSignedUrl(path: string, expiresIn: number, options?: SignedUrlOptions): Promise<Result<SignedUrlResult>>;
+    createSignedUrls(paths: string[], expiresIn: number, options?: SignedUrlOptions): Promise<Result<SignedUrlsResultItem[]>>;
+    createSignedUploadUrl(path: string, options?: {
+        upsert?: boolean;
+    }): Promise<Result<CreateSignedUploadUrlResult>>;
+    uploadToSignedUrl(path: string, token: string, fileBody: FileBody, fileOptions?: UploadOptions): Promise<Result<{
+        path: string;
+        fullPath: string;
+    }>>;
+    getPublicUrl(path: string, options?: PublicUrlOptions): {
+        data: {
+            publicUrl: string;
+        };
+    };
+    private send;
+    private uploadOrUpdate;
+    private cleanPath;
+    private encodePath;
+    private buildUploadBody;
+    private extractFromFormData;
+    private buildCopyMoveHeaders;
+    private appendUrlOptions;
+    private toBase64;
+}

package/storage/dist/supabase/errors.d.ts

@@ -0,0 +1,20 @@
+export declare class StorageError extends Error {
+    protected __isStorageError: boolean;
+    constructor(message: string);
+}
+export declare function isStorageError(error: unknown): error is StorageError;
+export declare class StorageApiError extends StorageError {
+    status: number;
+    statusCode: string;
+    constructor(message: string, status: number, statusCode: string);
+    toJSON(): {
+        name: string;
+        message: string;
+        status: number;
+        statusCode: string;
+    };
+}
+export declare class StorageUnknownError extends StorageError {
+    originalError: unknown;
+    constructor(message: string, originalError: unknown);
+}

package/storage/dist/supabase/types.d.ts

@@ -0,0 +1,63 @@
+import { MaybeNodeBuffer, NodeReadableStreamLike } from '../node-types';
+export type FileBody = ArrayBuffer | ArrayBufferView | Blob | File | FormData | MaybeNodeBuffer | NodeReadableStreamLike | ReadableStream<Uint8Array> | URLSearchParams | string;
+export type BucketType = 'STANDARD' | 'ANALYTICS';
+export interface Bucket {
+    id: string;
+    type?: BucketType;
+    name: string;
+    owner: string;
+    file_size_limit?: number;
+    allowed_mime_types?: string[];
+    created_at: string;
+    updated_at: string;
+    public: boolean;
+}
+export interface FileObject {
+    name: string;
+    bucket_id: string;
+    owner: string;
+    id: string;
+    updated_at: string;
+    created_at: string;
+    last_accessed_at: string;
+    metadata: Record<string, any>;
+    buckets: Bucket;
+}
+export interface FileObjectV2 {
+    id: string;
+    version: string;
+    name: string;
+    bucket_id: string;
+    updated_at: string;
+    created_at: string;
+    last_accessed_at: string;
+    size?: number;
+    cache_control?: string;
+    content_type?: string;
+    etag?: string;
+    last_modified?: string;
+    metadata?: Record<string, any>;
+}
+export interface FileOptions {
+    cacheControl?: string;
+    contentType?: string;
+    upsert?: boolean;
+    duplex?: string;
+    metadata?: Record<string, any>;
+    headers?: Record<string, string>;
+}
+export interface DestinationOptions {
+    destinationBucket?: string;
+}
+export interface TransformOptions {
+    width?: number;
+    height?: number;
+    resize?: 'cover' | 'contain' | 'fill';
+    quality?: number;
+    format?: 'origin';
+}
+type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}` ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}` : S;
+export type Camelize<T> = {
+    [K in keyof T as CamelCase<Extract<K, string>>]: T[K];
+};
+export {};