@bedelightful/upload-sdk 0.0.7

package/dist/es/index.d.ts

@@ -0,0 +1,867 @@
+/**
+ * Error type namespace
+ * */
+declare namespace ErrorType {
+    interface BaseException {
+        /** Error message */
+        message: string;
+    }
+    interface BaseExceptionWithStatus extends BaseException {
+        /** Error code */
+        status: number;
+    }
+    interface UploadError extends Error {
+        status?: number;
+    }
+    interface UploadPartException extends BaseExceptionWithStatus {
+        name: string;
+        stack: string;
+        partNum: number;
+    }
+}
+
+type Method = "get" | "GET" | "post" | "POST" | "delete" | "DELETE" | "head" | "HEAD" | "options" | "OPTIONS" | "put" | "PUT" | "patch" | "PATCH";
+interface Result<T> {
+    code?: number;
+    data: T;
+    message?: string;
+    headers: Record<string, string>;
+}
+interface DataWrapperWithHeaders<T> {
+    data: T;
+    headers: Record<string, string>;
+}
+
+/**
+ * Aliyun Object Storage
+ */
+declare namespace OSS {
+    export interface Option {
+        /** access secret you create */
+        accessKeyId: string;
+        /** access secret you create */
+        accessKeySecret: string;
+        /** used by temporary authorization */
+        stsToken?: string | undefined;
+        /** the default bucket you want to access If you don't have any bucket, please use putBucket() create one first. */
+        bucket?: string | undefined;
+        /** oss region domain. It takes priority over region. */
+        endpoint?: string | undefined;
+        /** the bucket data region location, please see Data Regions, default is oss-cn-hangzhou. */
+        region?: string | undefined;
+        /** access OSS with aliyun internal network or not, default is false. If your servers are running on aliyun too, you can set true to save lot of money. */
+        internal?: boolean | undefined;
+        /** instruct OSS client to use HTTPS (secure: true) or HTTP (secure: false) protocol. */
+        secure?: boolean | undefined;
+        /** instance level timeout for all operations, default is 60s */
+        timeout?: string | number | undefined;
+        /** use custom domain name */
+        cname?: boolean | undefined;
+        /** use time (ms) of refresh STSToken interval it should be less than sts info expire interval, default is 300000ms(5min) when sts info expires. */
+        refreshSTSTokenInterval?: number;
+        /** used by auto set stsToken、accessKeyId、accessKeySecret when sts info expires. return value must be object contains stsToken、accessKeyId、accessKeySecret */
+        refreshSTSToken?: () => Promise<{
+            accessKeyId: string;
+            accessKeySecret: string;
+            stsToken: string;
+        }>;
+    }
+    export interface Headers {
+        [propName: string]: any;
+        "x-oss-date": string;
+        "x-oss-user-agent"?: string;
+    }
+    /** Credential fields returned by backend for Aliyun */
+    export interface AuthParams {
+        policy: string;
+        accessid: string;
+        signature: string;
+        host: string;
+        dir: string;
+        callback: string;
+    }
+    /** Credential fields returned by backend when STS is enabled */
+    export interface STSAuthParams {
+        region: string;
+        bucket: string;
+        dir: string;
+        access_key_secret: string;
+        access_key_id: string;
+        sts_token: string;
+        callback: string;
+    }
+    export interface DonePart {
+        number: number;
+        etag: string;
+    }
+    export interface Checkpoint {
+        /** The file object selected by the user, if the browser is restarted, it needs the user to manually trigger the settings */
+        file: any;
+        /** object key */
+        name: string;
+        fileSize: number;
+        partSize: number;
+        UploadId: string;
+        doneParts: DonePart[];
+    }
+    export interface InitMultipartUploadOption {
+        headers?: Record<string, string>;
+        mime?: string | null;
+    }
+    export interface MultipartUploadParams {
+        bucket: string;
+        region: string;
+        object: string;
+        accessKeyId: string;
+        accessKeySecret: string;
+        stsToken: string;
+        callback: string;
+        taskId?: TaskId;
+        xmlResponse?: boolean;
+    }
+    /** Multipart upload interface */
+    export interface MultipartUploadOption {
+        /** the number of parts to be uploaded in parallel */
+        parallel?: number;
+        /** the suggested size for each part */
+        partSize?: number;
+        /** the checkpoint to resume upload, if this is provided, it will continue the upload from where interrupted, otherwise a new multipart upload will be created. */
+        checkpoint?: Checkpoint;
+        mime?: string | null;
+        headers?: Record<string, string>;
+    }
+    export interface CompleteMultipartUploadOptions {
+        partSize: number;
+        callback?: string;
+        headers?: Record<string, string> | undefined;
+        progress?: Progress;
+    }
+    export interface ResumeMultipartOption extends MultipartUploadOption {
+        progress?: Progress;
+    }
+    export interface CreateRequestParams extends MultipartUploadParams {
+        method: Method;
+        subRes: string | Record<string, any>;
+        xmlResponse?: boolean | undefined;
+        query?: Record<string, string>;
+        content?: File | Blob | string | ArrayBuffer | Buffer;
+    }
+    export interface UploadPartError extends Error {
+        name: string;
+        message: string;
+        stack: string;
+        partNum: number;
+    }
+    export interface PartInfo {
+        content: string | ArrayBuffer | File | Blob | Buffer;
+        size: number;
+    }
+    interface OriginResponseData {
+        platform: PlatformType.OSS;
+        file_code: string;
+        path: string;
+        url: string;
+        expires: number;
+    }
+    export type PostResponse = Result<OriginResponseData>;
+    export type PutResponse = Result<OriginResponseData>;
+    /** Multipart upload init response */
+    export type InitMultipartUploadResponse = DataWrapperWithHeaders<{
+        InitiateMultipartUploadResult: {
+            Bucket: string;
+            Key: string;
+            UploadId: string;
+        };
+    }>;
+    export type UploadPartResponse = DataWrapperWithHeaders<null>;
+    export type CompleteMultipartUploadResponse = Result<OriginResponseData>;
+    export {  };
+}
+
+/**
+ * Qiniu cloud namespace
+ */
+declare namespace Kodo {
+    /** Backend return - Qiniu cloud credential fields */
+    type AuthParams = {
+        token: string;
+        dir: string;
+    };
+}
+
+/**
+ * Internal network upload
+ */
+declare namespace Local {
+    interface AuthParams {
+        dir: string;
+        host: string;
+        credential: string;
+    }
+}
+
+interface ISign {
+    signature(opt: ISigOptions, expiredAt: number, credentials?: ISigCredentials): string;
+    signatureHeader(opt: ISigOptions, expiredAt?: number, credentials?: ISigCredentials): Map<string, string>;
+    getSignatureQuery(opt: ISigOptions, expiredAt: number): {
+        [key: string]: any;
+    };
+}
+interface ISigCredentials {
+    GetSecretKey(): string;
+    GetAccessKey(): string;
+}
+interface ISigPolicyQuery {
+    policy: {
+        conditions: (string[] | {
+            bucket: string;
+        } | {
+            key: string;
+        })[];
+    };
+    datetime?: string;
+    query?: string;
+    path?: string;
+    method?: string;
+    headers?: {
+        [key: string]: string | undefined;
+    };
+}
+interface ISigOptions {
+    sigName?: string;
+    endpoints?: string;
+    bucket?: string;
+    headers?: {
+        [key: string]: string | undefined;
+    };
+    region?: string;
+    serviceName?: string;
+    algorithm?: string;
+    path: string;
+    method: string;
+    query?: string | Record<string, any>;
+    datetime?: string;
+    host?: string;
+    port?: number;
+}
+interface ISignV4Opt {
+    algorithm?: string;
+    region?: string;
+    serviceName?: string;
+    securityToken?: string;
+    bucket: string;
+}
+/**
+ * @api private
+ */
+declare class SignersV4 implements ISign {
+    private options;
+    private credentials;
+    constructor(opt: ISignV4Opt, credentials: ISigCredentials);
+    /**
+     * normal v4 signature
+     * */
+    signature: (opt: ISigOptions, expiredAt: number, credentials?: ISigCredentials) => string;
+    signatureHeader: (opt: ISigOptions, expiredAt?: number, credentials?: ISigCredentials) => Map<string, string>;
+    getSignatureQuery: (opt: ISigOptions, expiredAt: number) => {
+        [key: string]: any;
+    };
+    getSignaturePolicyQuery: (opt: ISigPolicyQuery, expiredAt: number) => {
+        [key: string]: any;
+    };
+    static hexEncodedBodyHash: () => string;
+    private authorization;
+    static getDateTime: () => string;
+    private credentialString;
+    static createScope: (date: string, region?: string, serviceName?: string) => string;
+    private getSigningKey;
+    private stringToSign;
+    static hexEncodedHash: (string: string) => string;
+    static canonicalString: (opt: ISigOptions) => string;
+    static canonicalStringPolicy: (opt: ISigOptions) => string;
+    static canonicalHeaders: (opt: ISigOptions) => string;
+    static canonicalHeaderValues: (values: string) => string;
+    static signedHeaders: (opt: ISigOptions) => string;
+    /**
+     * ! * ' () aren't transformed by encodeUrl, so they need be handled
+     */
+    static getEncodePath(path: string, encodeAll?: boolean): string;
+}
+
+declare namespace TOS {
+    interface VolcEnginePlatformSimpleUploadOption extends PlatformSimpleUploadOption {
+        tosCallbackParams: {
+            tenant_id: string;
+            organization_code: string;
+        };
+    }
+    interface VolcEnginePlatformMultipartUploadOption extends PlatformMultipartUploadOption {
+    }
+    interface CallbackResponse {
+        platform: "tos";
+        file_code: string;
+        path: string;
+        url: string;
+        expires: number;
+    }
+    interface AuthParams {
+        host: string;
+        "x-tos-algorithm": "TOS4-HMAC-SHA256";
+        "x-tos-date": string;
+        "x-tos-credential": string;
+        "x-tos-signature": string;
+        policy: string;
+        expires: number;
+        content_type: string;
+        dir: string;
+        "x-tos-callback": string;
+    }
+    type Headers = Record<string, string>;
+    interface STSAuthParams {
+        bucket: string;
+        callback: string;
+        credentials: {
+            AccessKeyId: string;
+            CurrentTime: string;
+            ExpiredTime: string;
+            SecretAccessKey: string;
+            SessionToken: string;
+        };
+        dir: string;
+        endpoint: string;
+        host: string;
+        expires: number;
+        region: string;
+    }
+    interface CreateRequestParams extends STSAuthParams {
+    }
+    interface InitMultipartUploadOption extends MultipartUploadOption {
+        headers: Headers;
+        mime?: string | null;
+    }
+    type DonePart = {
+        number: number;
+        etag: string;
+    };
+    interface Checkpoint {
+        /** The file object selected by the user, if the browser is restarted, it needs the user to manually trigger the settings */
+        file: any;
+        /** object key */
+        name: string;
+        fileSize: number;
+        partSize: number;
+        UploadId: string;
+        doneParts: DonePart[];
+    }
+    interface PartInfo {
+        content: Buffer;
+        size: Number;
+    }
+    interface MultipartUploadOption extends PlatformMultipartUploadOption {
+        signers: SignersV4;
+    }
+    interface CompleteMultipartUploadOptions extends MultipartUploadOption {
+    }
+    interface InitMultipartUploadResponse {
+        Bucket: string;
+        Key: string;
+        UploadId: string;
+    }
+    interface CompleteMultipartUploadResponse {
+        Location: string;
+        Bucket: string;
+        Key: string;
+        ETag: string;
+        headers: Record<string, string>;
+    }
+    type UploadPartResponse = DataWrapperWithHeaders<null>;
+    type PostResponse = DataWrapperWithHeaders<null>;
+    type PutResponse = DataWrapperWithHeaders<null>;
+}
+
+declare const enum OBSUploadFileEventType {
+    initiateMultipartUploadSucceed = "initiateMultipartUploadSucceed"
+}
+declare namespace OBS {
+    interface UploadFileEventResponse {
+        [OBSUploadFileEventType.initiateMultipartUploadSucceed]: InitMultipartUploadResponse;
+    }
+    interface AuthParams {
+        AccessKeyId: string;
+        host: string;
+        policy: string;
+        signature: string;
+        dir: string;
+        "content-type": string;
+    }
+    interface STSAuthParams {
+        host: string;
+        region: string;
+        endpoint: string;
+        credentials: {
+            access: string;
+            secret: string;
+            security_token: string;
+            expires_at: string;
+        };
+        bucket: string;
+        dir: string;
+        expires: number;
+        callback: string;
+    }
+    interface PartInfo {
+        content: Buffer;
+        size: number;
+    }
+    interface InitMultipartUploadOption extends PlatformMultipartUploadOption {
+        mime?: string | null;
+    }
+    interface CommonResponse<I> {
+        CommonMsg: {
+            Status: number;
+            Code: string;
+            Message: string;
+            HostId: string;
+            RequestId: string;
+            InterfaceResult: null;
+            Id2: string;
+        };
+        InterfaceResult: I;
+    }
+    interface InitMultipartUploadResponse {
+        InitiateMultipartUploadResult: {
+            Bucket: string;
+            Key: string;
+            UploadId: string;
+        };
+    }
+    interface InitMultipartUploadResult {
+        res: unknown;
+        bucket: string;
+        name: string;
+        UploadId: string;
+    }
+    type UploadPartResponse = DataWrapperWithHeaders<null>;
+    interface UploadPartResult {
+        name: string;
+        etag: string;
+        res: UploadPartResponse;
+    }
+    type CompleteMultipartUploadResponse = CommonResponse<{
+        ContentLength: string;
+        Date: string;
+        RequestId: string;
+        Id2: string;
+        Location: string;
+        Bucket: string;
+        Key: string;
+        ETag: string;
+    }>;
+    type UploadPart = DonePart;
+    type PutResponseData = CommonResponse<{
+        ContentLength: "0";
+        RequestId: "0000018C63BA1641B01B419F482B8B1E";
+        ETag: '"e00ca89591de6668570981e97c9663ea"';
+    }>;
+}
+
+/**
+ * AWS S3 / MinIO Object Storage
+ */
+declare namespace MinIO {
+    /** Simple upload using pre-signed URL */
+    export interface AuthParams {
+        url: string;
+        host: string;
+        method: string;
+        fields: Record<string, string>;
+        dir: string;
+        expires: number;
+    }
+    /** Credentials for MinIO/S3 authentication */
+    export interface Credentials {
+        access_key_id: string;
+        secret_access_key: string;
+        session_token: string;
+        expiration: string;
+    }
+    /** Upload using AccessKey/SecretKey with Signature V4 */
+    export interface STSAuthParams {
+        region: string;
+        endpoint: string;
+        bucket: string;
+        credentials: Credentials;
+        expires: number;
+        dir: string;
+    }
+    export type Headers = Record<string, string>;
+    export interface DonePart {
+        number: number;
+        etag: string;
+    }
+    export interface Checkpoint {
+        /** The file object selected by the user, if the browser is restarted, it needs the user to manually trigger the settings */
+        file: any;
+        /** object key */
+        name: string;
+        fileSize: number;
+        partSize: number;
+        UploadId: string;
+        doneParts: DonePart[];
+    }
+    export interface InitMultipartUploadOption extends PlatformMultipartUploadOption {
+        headers?: Headers;
+        mime?: string | null;
+    }
+    export interface MultipartUploadOption extends PlatformMultipartUploadOption {
+        headers?: Record<string, string>;
+    }
+    export interface CompleteMultipartUploadOptions extends MultipartUploadOption {
+        partSize: number;
+    }
+    export interface PartInfo {
+        content: Buffer | Blob | ArrayBuffer;
+        size: number;
+    }
+    export interface InitMultipartUploadResponse {
+        InitiateMultipartUploadResult: {
+            Bucket: string;
+            Key: string;
+            UploadId: string;
+        };
+    }
+    export interface CompleteMultipartUploadResponse {
+        CompleteMultipartUploadResult: {
+            Location: string;
+            Bucket: string;
+            Key: string;
+            ETag: string;
+        };
+    }
+    interface OriginResponseData {
+        platform: PlatformType.Minio;
+        file_code?: string;
+        path: string;
+        url?: string;
+        expires?: number;
+    }
+    export type PostResponse = Result<OriginResponseData>;
+    export type PutResponse = DataWrapperWithHeaders<null>;
+    export type InitMultipartUploadResponseType = DataWrapperWithHeaders<InitMultipartUploadResponse>;
+    export type UploadPartResponse = DataWrapperWithHeaders<null>;
+    export type CompleteMultipartUploadResponseType = Result<OriginResponseData>;
+    export {  };
+}
+
+/**
+ * @description Unified success response
+ * @param code 1000 for successful request
+ * @param message Request status information
+ * @param data Return data payload
+ */
+interface NormalSuccessResponse {
+    code: number;
+    message: string;
+    headers: Record<string, string>;
+    data: {
+        platform: PlatformType;
+        path: string;
+    };
+}
+/**
+ * @param url Request URL
+ * @param method Request method
+ * @param headers Request headers
+ * @param body Request body
+ */
+interface Request {
+    url: string;
+    method: Method;
+    headers?: Record<string, string>;
+    body?: any;
+}
+/**
+ * @description: Image processing configuration
+ * @param type // Image processing type, e.g.: resize, watermark
+ * @param params  Image processing parameters, refer to: https://help.aliyun.com/document_detail/144582.html
+ */
+interface TransformImageConfig {
+    type: "resize" | "watermark" | "crop" | "quality" | "format" | "auto-orient" | "circle" | "indexcrop" | "rounded-corners" | "blur" | "rotate" | "interlace" | "bright" | "sharpen" | "contrast";
+    params: Record<string, any>;
+}
+/**
+ * @description: Download configuration
+ * @param url Request URL
+ * @param method Request method
+ * @param headers Request headers
+ * @param body Request body
+ */
+interface DownloadConfig extends Request {
+    option?: {
+        image?: TransformImageConfig[];
+    };
+}
+type UploadConfigOption = UploadCommonOption & PlatformSimpleUploadOption & PlatformMultipartUploadOption;
+/**
+ * @description: Common upload configuration
+ * @param rewriteFileName Whether to rename the file
+ */
+interface UploadCommonOption {
+    rewriteFileName?: boolean;
+}
+/**
+ * @description: Custom upload credential configuration
+ * @param platform Platform type
+ * @param credentials Credential information
+ * @param expire Expiration timestamp (optional)
+ */
+interface CustomCredentials {
+    platform: PlatformType;
+    temporary_credential: PlatformParams;
+    expire?: number;
+}
+/**
+ * @description: Upload configuration, requires developers to configure upload credential request, SDK handles upload request internally
+ * @param url  Request upload credential - URL (optional when using custom credentials)
+ * @param method Request upload credential - request method (optional when using custom credentials)
+ * @param headers Request upload credential - request headers (optional when using custom credentials)
+ * @param body Request upload credential - request body (optional when using custom credentials)
+ * @param {File | Blob} file File to be uploaded
+ * @param fileName File name
+ * @param option Optional upload configuration
+ * @param customCredentials Custom upload credentials (optional, will skip credential request when provided)
+ */
+interface UploadConfig {
+    url?: string;
+    method?: Method;
+    headers?: Record<string, string>;
+    body?: any;
+    file: File | Blob;
+    fileName: string;
+    option?: UploadConfigOption;
+    customCredentials?: CustomCredentials;
+}
+/** Upload callback */
+interface UploadCallBack extends TaskCallBack {
+}
+type DonePart = {
+    number: number;
+    etag: string;
+};
+interface Checkpoint {
+    /** The file object selected by the user, if the browser is restarted, it needs the user to manually trigger the settings */
+    file: any;
+    /** object key */
+    name: string;
+    fileSize: number;
+    partSize: number;
+    UploadId: string;
+    doneParts: DonePart[];
+}
+/** percent: percentage progress loaded: bytes uploaded total: total bytes checkpoint: upload checkpoint information */
+type Progress = (percent: number, loaded: number, total: number, checkpoint: Checkpoint | null) => void;
+/** PlatformType cloud storage provider enum type */
+declare enum PlatformType {
+    OSS = "aliyun",
+    Kodo = "qiniu",
+    TOS = "tos",
+    OBS = "obs",
+    Local = "local",
+    Minio = "minio"
+}
+/** Aggregated platform parameters */
+type PlatformParams = OSS.AuthParams | OSS.STSAuthParams | Kodo.AuthParams | Local.AuthParams | TOS.AuthParams | TOS.STSAuthParams | OBS.AuthParams | OBS.STSAuthParams | MinIO.AuthParams | MinIO.STSAuthParams;
+/** Object storage platform base Option */
+interface PlatformOption {
+    headers?: Record<string, string>;
+    taskId?: TaskId;
+    progress?: Progress;
+    reUploadedCount?: number;
+}
+/** Multipart upload Option optional fields */
+interface PlatformMultipartUploadOption extends PlatformOption {
+    parallel?: number;
+    partSize?: number;
+    checkpoint?: OSS.Checkpoint;
+    mime?: string | null;
+}
+/** Simple upload Option optional fields */
+interface PlatformSimpleUploadOption extends PlatformOption {
+}
+/** Upload file implementation interface for different object storage platforms */
+type PlatformRequest<P, O> = (file: File | Blob, key: string, params: P, option: O) => Promise<NormalSuccessResponse>;
+/** A TaskId is generated when a file upload starts */
+type TaskId = string;
+/** Upload progress callback parameters */
+interface ProgressCallbackProps {
+    percent?: number;
+    loaded?: number;
+    total?: number;
+    checkpoint?: OSS.Checkpoint | null;
+}
+/** Success hook callback */
+type SuccessCallback = (response?: NormalSuccessResponse) => void;
+/** Failure hook callback */
+type FailCallback = (err?: ErrorType.UploadError) => void;
+/** Progress hook callback */
+type ProgressCallback = (percent?: ProgressCallbackProps["percent"], loaded?: ProgressCallbackProps["loaded"], total?: ProgressCallbackProps["total"], checkpoint?: ProgressCallbackProps["checkpoint"]) => void;
+/** Upload task callbacks */
+interface TaskCallBack {
+    success?: (callback: SuccessCallback) => void;
+    fail?: (callback: FailCallback) => void;
+    progress?: (callback: ProgressCallback) => void;
+    cancel?: () => void;
+    pause?: () => void;
+    resume?: () => void;
+}
+
+declare const PlatformModules: Record<PlatformType, Record<string, PlatformRequest<OSS.AuthParams, PlatformSimpleUploadOption> | PlatformRequest<OSS.STSAuthParams, PlatformMultipartUploadOption> | PlatformRequest<Kodo.AuthParams, PlatformSimpleUploadOption> | PlatformRequest<TOS.AuthParams, PlatformMultipartUploadOption> | PlatformRequest<TOS.STSAuthParams, PlatformMultipartUploadOption> | PlatformRequest<OBS.STSAuthParams, PlatformMultipartUploadOption> | PlatformRequest<OBS.AuthParams, PlatformMultipartUploadOption> | PlatformRequest<Local.AuthParams, PlatformSimpleUploadOption> | PlatformRequest<MinIO.AuthParams, PlatformSimpleUploadOption> | PlatformRequest<MinIO.STSAuthParams, PlatformMultipartUploadOption>>>;
+
+/**
+ * Log module namespace
+ * */
+declare namespace LogModule {
+    type LogType = "SUCCESS" | "ERROR" | "WARN" | "DEBUG";
+    type CallBack = (log: any) => void;
+    type LogEventType = "upload" | "download";
+    type CreateLogConfig = {
+        type: LogType;
+        /** Event name */
+        eventName: LogEventType;
+        /** Event parameters */
+        eventParams?: any;
+        /** Event response */
+        eventResponse?: any;
+        error?: ErrorType.UploadError;
+        /** Additional content */
+        extra?: string;
+    };
+    /**
+     * Log data structure
+     */
+    interface LogData {
+        /** Status type */
+        type: LogType;
+        /** Event name */
+        event_name: LogEventType;
+        /** Event parameters */
+        event_params: any;
+        /** Event response */
+        event_response: any;
+        /** Exception type */
+        exception_type: string;
+        /** Exception message */
+        exception_message: string;
+        /** File where exception was triggered */
+        exception_file: string;
+        /** Line number where exception was triggered */
+        exception_line: string;
+        /** Column number where exception was triggered */
+        exception_row: string;
+        /** Additional content */
+        extra?: string;
+        /** Record time */
+        time: Date;
+        /** SDK name and version */
+        version: string;
+    }
+}
+
+declare class UploadManger {
+    private tasks;
+    private detach;
+    private notifySuccess;
+    private notifyError;
+    private notifyProgress;
+    createTask(file: File | Blob, key: string, uploadConfig: UploadConfig, option: PlatformMultipartUploadOption | PlatformSimpleUploadOption): TaskCallBack;
+    private upload;
+    pauseAllTask(): void;
+    resumeAllTask(): void;
+    cancelAllTask(): void;
+}
+
+declare function STSUpload$1(file: File | Blob, key: string, params: TOS.STSAuthParams, option: PlatformSimpleUploadOption | PlatformMultipartUploadOption): Promise<NormalSuccessResponse>;
+
+declare const _default$5: {
+    upload: PlatformRequest<TOS.AuthParams | TOS.STSAuthParams, PlatformSimpleUploadOption | PlatformMultipartUploadOption>;
+    defaultUpload: PlatformRequest<TOS.AuthParams, PlatformSimpleUploadOption>;
+    MultipartUpload: PlatformRequest<TOS.STSAuthParams, PlatformMultipartUploadOption>;
+    STSUpload: typeof STSUpload$1;
+};
+
+declare const _default$4: {
+    upload: PlatformRequest<OSS.AuthParams | OSS.STSAuthParams, PlatformSimpleUploadOption | PlatformMultipartUploadOption>;
+    defaultUpload: PlatformRequest<OSS.AuthParams, PlatformSimpleUploadOption>;
+    MultipartUpload: PlatformRequest<OSS.STSAuthParams, PlatformMultipartUploadOption>;
+    STSUpload: PlatformRequest<OSS.STSAuthParams, PlatformMultipartUploadOption>;
+};
+
+/**
+ * Huawei Cloud PUT upload
+ * @param file File
+ * @param key File name
+ * @param params Upload credential parameters
+ * @param option Upload configuration
+ * @returns
+ */
+declare function STSUpload(file: File | Blob, key: string, params: OBS.STSAuthParams, option: PlatformSimpleUploadOption | PlatformMultipartUploadOption): Promise<NormalSuccessResponse>;
+
+declare const _default$3: {
+    upload: PlatformRequest<OBS.AuthParams | OBS.STSAuthParams, PlatformSimpleUploadOption | PlatformMultipartUploadOption>;
+    defaultUpload: PlatformRequest<OBS.AuthParams, PlatformSimpleUploadOption>;
+    MultipartUpload: PlatformRequest<OBS.STSAuthParams, PlatformMultipartUploadOption>;
+    STSUpload: typeof STSUpload;
+};
+
+declare const _default$2: {
+    upload: PlatformRequest<Kodo.AuthParams, PlatformSimpleUploadOption>;
+};
+
+declare const _default$1: {
+    upload: PlatformRequest<Local.AuthParams, PlatformSimpleUploadOption>;
+};
+
+declare const _default: {
+    upload: PlatformRequest<MinIO.AuthParams | MinIO.STSAuthParams, PlatformSimpleUploadOption | PlatformMultipartUploadOption>;
+    defaultUpload: PlatformRequest<MinIO.AuthParams, PlatformSimpleUploadOption>;
+    signedUpload: PlatformRequest<MinIO.STSAuthParams, PlatformSimpleUploadOption>;
+    MultipartUpload: PlatformRequest<MinIO.STSAuthParams, PlatformMultipartUploadOption>;
+    STSUpload: PlatformRequest<MinIO.STSAuthParams, PlatformSimpleUploadOption>;
+};
+
+declare class Upload {
+    /** Package version */
+    static version: string;
+    uploadManger: UploadManger;
+    constructor();
+    /**
+     * @description: Generate temporary URL for file download/preview
+     * @param {DownloadConfig} downloadConfig
+     * @return Promise<any>
+     */
+    static download(downloadConfig: DownloadConfig): Promise<any>;
+    /**
+     * @description: File upload interface, including simple upload/multipart upload/resumable upload, will select the corresponding platform and upload method based on upload credential information
+     * @param {UploadConfig} uploadConfig Upload configuration
+     * @return {UploadCallBack} uploadCallBack Upload callback
+     */
+    upload(uploadConfig: UploadConfig): UploadCallBack;
+    /**
+     * @description: Pause all file uploads (multipart upload)
+     */
+    pause(): void;
+    /**
+     * @description: Resume all file uploads (multipart upload)
+     */
+    resume(): void;
+    /**
+     * @description: Cancel all file uploads (multipart upload)
+     */
+    cancel(): void;
+    /**
+     * @description: Pass in callback function to subscribe to log content
+     */
+    static subscribeLogs(callback: LogModule.CallBack): void;
+}
+
+export { type DownloadConfig, _default$2 as Kodo, _default$1 as Local, _default as MinIO, _default$3 as OBS, _default$4 as OSS, PlatformModules, PlatformType, _default$5 as TOS, Upload, type UploadCallBack, type UploadConfig };