@types/ali-oss

  • Version 6.16.3
  • Published
  • 41.2 kB
  • No dependencies
  • MIT license

Install

npm i @types/ali-oss
yarn add @types/ali-oss
pnpm add @types/ali-oss

Overview

TypeScript definitions for ali-oss

Index

Classes

Interfaces

Type Aliases

Classes

class ClusterClient

class ClusterClient {}

    constructor

    constructor(options: ClusterOptions);

      method copy

      copy: (
      name: string,
      sourceName: string,
      options?: CopyObjectOptions
      ) => Promise<CopyAndPutMetaResult>;

        method delete

        delete: (
        name: string,
        options?: RequestOptions
        ) => Promise<NormalSuccessResponse>;

          method deleteMulti

          deleteMulti: (
          names: string[],
          options?: DeleteMultiOptions
          ) => Promise<DeleteMultiResult>;

            method get

            get: (
            name: string,
            file?: any,
            options?: GetObjectOptions
            ) => Promise<GetObjectResult>;

              method getStream

              getStream: (
              name?: string,
              options?: GetStreamOptions
              ) => Promise<GetStreamResult>;

                method head

                head: (name: string, options?: HeadObjectOptions) => Promise<HeadObjectResult>;

                  method list

                  list: (
                  query: ListObjectsQuery | null,
                  options: RequestOptions
                  ) => Promise<ListObjectResult>;

                    method listV2

                    listV2: (
                    query: ListV2ObjectsQuery | null,
                    options: RequestOptions
                    ) => Promise<ListObjectResult>;
                    • 6.12.0

                    method put

                    put: (
                    name: string,
                    file: any,
                    options?: PutObjectOptions
                    ) => Promise<PutObjectResult>;

                      method putACL

                      putACL: (
                      name: string,
                      acl: ACLType,
                      options?: RequestOptions
                      ) => Promise<NormalSuccessResponse>;

                        method putMeta

                        putMeta: (
                        name: string,
                        meta: UserMeta,
                        options: RequestOptions
                        ) => Promise<CopyAndPutMetaResult>;

                          method putStream

                          putStream: (
                          name: string,
                          stream: any,
                          options?: PutStreamOptions
                          ) => Promise<{ name: string; res: NormalSuccessResponse }>;

                            method restore

                            restore: (
                            name: string,
                            options?: RequestOptions
                            ) => Promise<NormalSuccessResponse>;

                              method signatureUrl

                              signatureUrl: (name: string, options?: SignatureUrlOptions) => string;

                                class ImageClient

                                class ImageClient {}

                                  constructor

                                  constructor(options: ImageClientOptions);

                                    method deleteStyle

                                    deleteStyle: (
                                    styleName: string,
                                    options?: RequestOptions
                                    ) => Promise<NormalSuccessResponse>;
                                    • todo

                                    method get

                                    get: (
                                    name: string,
                                    file?: any,
                                    options?: ImageGetOptions
                                    ) => Promise<{ content: any; res: NormalSuccessResponse }>;
                                    • Get an image from the image channel.

                                    method getExif

                                    getExif: (
                                    name: string,
                                    options?: RequestOptions
                                    ) => Promise<{ data: object; res: NormalSuccessResponse }>;
                                    • Get a image exif info by image object name from the image channel.

                                    method getInfo

                                    getInfo: (
                                    name: string,
                                    options?: RequestOptions
                                    ) => Promise<{ data: object; res: NormalSuccessResponse }>;
                                    • Get a image info and exif info by image object name from the image channel.

                                    method getStream

                                    getStream: (
                                    name: string,
                                    options?: ImageGetOptions
                                    ) => Promise<{ stream: any; res: NormalSuccessResponse }>;
                                    • Get an image read stream.

                                    method getStyle

                                    getStyle: (
                                    name: string,
                                    options?: RequestOptions
                                    ) => Promise<{ data: StyleData; res: NormalSuccessResponse }>;
                                    • Get a style by name from the image channel.

                                    method listStyle

                                    listStyle: (options?: RequestOptions) => Promise<StyleData[]>;
                                    • Get all styles from the image channel.

                                    method putStyle

                                    putStyle: (
                                    name: string,
                                    style: string,
                                    options?: RequestOptions
                                    ) => Promise<{ data: object; res: NormalSuccessResponse }>;
                                    • todo

                                    method signatureUrl

                                    signatureUrl: (
                                    name: string,
                                    options?: { expires?: string | undefined; timeout?: string | undefined }
                                    ) => string;
                                    • Create a signature url for directly download.

                                    class OSS

                                    class OSS {}

                                      constructor

                                      constructor(options: OSS.Options);

                                        method abortMultipartUpload

                                        abortMultipartUpload: (
                                        name: string,
                                        uploadId: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Abort a multipart upload for object.

                                        method append

                                        append: (
                                        name: string,
                                        file: any,
                                        options?: OSS.AppendObjectOptions
                                        ) => Promise<OSS.AppendObjectResult>;
                                        • Append an object to the bucket, it's almost same as put, but it can add content to existing object rather than override it.

                                        method calculatePostSignature

                                        calculatePostSignature: (policy: object | string) => OSS.PostObjectParams;
                                        • get postObject params.

                                        method completeMultipartUpload

                                        completeMultipartUpload: (
                                        name: string,
                                        uploadId: string,
                                        parts: Array<{ number: number; etag: string }>,
                                        options?: OSS.CompleteMultipartUploadOptions
                                        ) => Promise<OSS.CompleteMultipartUploadResult>;
                                        • After uploading all data parts, you must call the Complete Multipart Upload API to complete Multipart Upload for the entire file.

                                        method copy

                                        copy: (
                                        name: string,
                                        sourceName: string,
                                        options?: OSS.CopyObjectOptions
                                        ) => Promise<OSS.CopyAndPutMetaResult>;
                                        • Copy an object from sourceName to name.

                                        method createVod

                                        createVod: (
                                        id: string,
                                        name: string,
                                        time: { startTime: number; endTime: number },
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Create a VOD playlist for the channel.

                                        method delete

                                        delete: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Delete an object from the bucket.

                                        method deleteBucket

                                        deleteBucket: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Delete an empty bucket.

                                        method deleteBucketCORS

                                        deleteBucketCORS: (name: string) => Promise<OSS.NormalSuccessResponse>;
                                        • Delete CORS rules of the bucket object.

                                        method deleteBucketLifecycle

                                        deleteBucketLifecycle: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Delete the bucket object lifecycle.

                                        method deleteBucketLogging

                                        deleteBucketLogging: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Delete the bucket logging settings.

                                        method deleteBucketPolicy

                                        deleteBucketPolicy: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<{ status: number; res: OSS.NormalSuccessResponse }>;
                                        • Deletes the policy added for a bucket.

                                        method deleteBucketReferer

                                        deleteBucketReferer: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Delete the bucket request Referer white list.

                                        method deleteBucketWebsite

                                        deleteBucketWebsite: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Delete the bucket website config.

                                        method deleteChannel

                                        deleteChannel: (
                                        id: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Delete a live channel.

                                        method deleteMulti

                                        deleteMulti: (
                                        names: string[],
                                        options?: OSS.DeleteMultiOptions
                                        ) => Promise<OSS.DeleteMultiResult>;
                                        • Delete multi objects in one request.

                                        method generateObjectUrl

                                        generateObjectUrl: (name: string, baseUrl?: string) => string;
                                        • Get the Object url. If provide baseUrl, will use baseUrl instead the default bucket and endpoint. Suggest use generateObjectUrl instead of getObjectUrl.

                                        method get

                                        get: (
                                        name: string,
                                        file?: any,
                                        options?: OSS.GetObjectOptions
                                        ) => Promise<OSS.GetObjectResult>;
                                        • Get an object from the bucket.

                                        method getACL

                                        getACL: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.GetACLResult>;
                                        • Get object's ACL.

                                        method getBucketACL

                                        getBucketACL: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<{ acl: string; res: OSS.NormalSuccessResponse }>;
                                        • Get the bucket ACL. acl - acl settings string

                                        method getBucketCORS

                                        getBucketCORS: (
                                        name: string
                                        ) => Promise<{ rules: OSS.CORSRule[]; res: OSS.NormalSuccessResponse }>;
                                        • Get CORS rules of the bucket object.

                                        method getBucketInfo

                                        getBucketInfo: (name: string) => Promise<any>;
                                        • Get bucket information,include CreationDate、ExtranetEndpoint、IntranetEndpoint、Location、Name、StorageClass、 Owner、AccessControlList

                                        method getBucketLifecycle

                                        getBucketLifecycle: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<{ rules: OSS.LifecycleRule[]; res: OSS.NormalSuccessResponse }>;
                                        • Get the bucket object lifecycle.

                                        method getBucketLocation

                                        getBucketLocation: (name: string) => Promise<any>;
                                        • Get bucket location

                                        method getBucketLogging

                                        getBucketLogging: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<{
                                        enable: boolean;
                                        prefix: string | null;
                                        res: OSS.NormalSuccessResponse;
                                        }>;
                                        • Get the bucket logging settings.

                                        method getBucketPolicy

                                        getBucketPolicy: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.GetBucketPolicyResult>;
                                        • Obtains the policy for a bucket.

                                        method getBucketReferer

                                        getBucketReferer: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<{
                                        allowEmpty: boolean;
                                        referers: string[];
                                        res: OSS.NormalSuccessResponse;
                                        }>;
                                        • Get the bucket request Referer white list.

                                        method getBucketWebsite

                                        getBucketWebsite: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<{ index: string; error: string; res: OSS.NormalSuccessResponse }>;
                                        • Get the bucket website config.

                                        method getChannel

                                        getChannel: (
                                        id: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<{ data: OSS.PutChannelConf; res: OSS.NormalSuccessResponse }>;
                                        • Get live channel info.

                                        method getChannelHistory

                                        getChannelHistory: (
                                        id: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.ChannelHistoryResult>;
                                        • Get the live channel history.

                                        method getChannelStatus

                                        getChannelStatus: (
                                        id: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.GetChannelResult>;
                                        • Get the live channel status.

                                        method getObjectUrl

                                        getObjectUrl: (name: string, baseUrl?: string) => string;
                                        • Get the Object url. If provide baseUrl, will use baseUrl instead the default endpoint.

                                        method getRtmpUrl

                                        getRtmpUrl: (channelId?: string, options?: OSS.GetRtmpUrlOptions) => string;
                                        • Get signatured rtmp url for publishing.

                                        method getStream

                                        getStream: (
                                        name?: string,
                                        options?: OSS.GetStreamOptions
                                        ) => Promise<OSS.GetStreamResult>;
                                        • Get an object read stream.

                                        method head

                                        head: (
                                        name: string,
                                        options?: OSS.HeadObjectOptions
                                        ) => Promise<OSS.HeadObjectResult>;
                                        • Head an object and get the meta info.

                                        method initMultipartUpload

                                        initMultipartUpload: (
                                        name: string,
                                        options?: OSS.InitMultipartUploadOptions
                                        ) => Promise<OSS.InitMultipartUploadResult>;
                                        • multi upload

                                        method list

                                        list: (
                                        query: OSS.ListObjectsQuery | null,
                                        options: OSS.RequestOptions
                                        ) => Promise<OSS.ListObjectResult>;
                                        • List objects in the bucket.

                                        method listBuckets

                                        listBuckets: (
                                        query: OSS.ListBucketsQueryType | null,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.Bucket[]>;
                                        • List buckets in this account.

                                        method listChannels

                                        listChannels: (
                                        query: OSS.ListChannelsQuery,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.ListChannelsResult>;
                                        • List channels.

                                        method listParts

                                        listParts: (
                                        name: string,
                                        uploadId: string,
                                        query?: OSS.ListPartsQuery,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.ListPartsResult>;
                                        • The ListParts command can be used to list all successfully uploaded parts mapped to a specific upload ID, i.e.: those not completed and not aborted.

                                        method listUploads

                                        listUploads: (
                                        query: OSS.ListUploadsQuery,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.ListUploadsResult>;
                                        • List on-going multipart uploads, i.e.: those not completed and not aborted.

                                        method multipartUpload

                                        multipartUpload: (
                                        name: string,
                                        file: any,
                                        options: OSS.MultipartUploadOptions
                                        ) => Promise<OSS.MultipartUploadResult>;
                                        • Upload file with OSS multipart.

                                        method multipartUploadCopy

                                        multipartUploadCopy: (
                                        name: string,
                                        sourceData: OSS.MultipartUploadCopySourceData,
                                        options?: OSS.MultipartUploadOptions
                                        ) => Promise<OSS.MultipartUploadCopyResult>;
                                        • Copy file with OSS multipart. this function contains head, initMultipartUpload, uploadPartCopy, completeMultipartUpload. When copying a file larger than 1 GB, you should use the Upload Part Copy method. If you want to copy a file smaller than 1 GB, see Copy Object.

                                        method put

                                        put: (
                                        name: string,
                                        file: any,
                                        options?: OSS.PutObjectOptions
                                        ) => Promise<OSS.PutObjectResult>;
                                        • Add an object to the bucket.

                                        method putACL

                                        putACL: (
                                        name: string,
                                        acl: OSS.ACLType,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Set object's ACL.

                                        method putBucket

                                        putBucket: (
                                        name: string,
                                        options?: OSS.PutBucketOptions
                                        ) => Promise<{ bucket: string; res: OSS.NormalSuccessResponse }>;
                                        • Create a new bucket.

                                        method putBucketACL

                                        putBucketACL: (
                                        name: string,
                                        acl: OSS.ACLType,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Update the bucket ACL.

                                        method putBucketCORS

                                        putBucketCORS: (
                                        name: string,
                                        rules: OSS.CORSRule[],
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Set CORS rules of the bucket object

                                        method putBucketLifecycle

                                        putBucketLifecycle: (
                                        name: string,
                                        rules: OSS.LifecycleRule[],
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Set the bucket object lifecycle.

                                        method putBucketLogging

                                        putBucketLogging: (
                                        name: string,
                                        prefix?: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Update the bucket logging settings. Log file will create every one hour and name format: -YYYY-mm-DD-HH-MM-SS-UniqueString.

                                        method putBucketPolicy

                                        putBucketPolicy: (
                                        name: string,
                                        policy: OSS.BucketPolicy,
                                        options?: OSS.RequestOptions
                                        ) => Promise<{ status: number; res: OSS.NormalSuccessResponse }>;
                                        • Adds or modify policy for a bucket.

                                        method putBucketReferer

                                        putBucketReferer: (
                                        name: string,
                                        allowEmpty: boolean,
                                        referers: string[],
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Set the bucket request Referer white list.

                                        method putBucketWebsite

                                        putBucketWebsite: (
                                        name: string,
                                        config: OSS.PutBucketWebsiteConfig
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Set the bucket as a static website.

                                        method putChannel

                                        putChannel: (
                                        id: string,
                                        conf: OSS.PutChannelConf,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.PutChannelResult>;
                                        • Create a live channel.

                                        method putChannelStatus

                                        putChannelStatus: (
                                        id: string,
                                        status?: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Change the live channel status.

                                        method putMeta

                                        putMeta: (
                                        name: string,
                                        meta: OSS.UserMeta,
                                        options: OSS.RequestOptions
                                        ) => Promise<OSS.CopyAndPutMetaResult>;
                                        • Set an exists object meta.

                                        method putStream

                                        putStream: (
                                        name: string,
                                        stream: any,
                                        options?: OSS.PutStreamOptions
                                        ) => Promise<{ name: string; res: OSS.NormalSuccessResponse }>;
                                        • Add a stream object to the bucket.

                                        method restore

                                        restore: (
                                        name: string,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.NormalSuccessResponse>;
                                        • Restore Object.

                                        method signatureUrl

                                        signatureUrl: (name: string, options?: OSS.SignatureUrlOptions) => string;
                                        • Create a signature url for download or upload object. When you put object with signatureUrl ,you need to pass Content-Type.Please look at the example.

                                        method uploadPart

                                        uploadPart: (
                                        name: string,
                                        uploadId: string,
                                        partNo: number,
                                        file: any,
                                        start: number,
                                        end: number,
                                        options?: OSS.RequestOptions
                                        ) => Promise<OSS.UploadPartResult>;
                                        • After initiating a Multipart Upload event, you can upload data in parts based on the specified object name and Upload ID.

                                        method uploadPartCopy

                                        uploadPartCopy: (
                                        name: string,
                                        uploadId: string,
                                        partNo: number,
                                        range: string,
                                        sourceData: { sourceKey: string; sourceBucketName: string },
                                        options: { timeout?: number | undefined; headers?: object | undefined }
                                        ) => Promise<OSS.UploadPartResult>;
                                        • Using Upload Part Copy, you can copy data from an existing object and upload a part of the data. When copying a file larger than 1 GB, you must use the Upload Part Copy method. If you want to copy a file smaller than 1 GB, see Copy Object.

                                        method useBucket

                                        useBucket: (name: string) => void;
                                        • Use the bucket.

                                        class STS

                                        class STS {}
                                        • Generate STS Authorization

                                        constructor

                                        constructor(options: STSOptions);

                                          method assumeRole

                                          assumeRole: (
                                          roleArn: string,
                                          policy?: object | string,
                                          expirationSeconds?: number,
                                          session?: string,
                                          options?: { timeout: number; ctx: any }
                                          ) => Promise<{ credentials: Credentials }>;

                                            Interfaces

                                            interface AppendObjectOptions

                                            interface AppendObjectOptions {}

                                              property headers

                                              headers?: object | undefined;

                                                property meta

                                                meta?: UserMeta | undefined;

                                                  property mime

                                                  mime?: string | undefined;
                                                  • custom mime, will send with Content-Type entity header

                                                  property position

                                                  position?: string | undefined;
                                                  • specify the position which is the content length of the latest object

                                                  property timeout

                                                  timeout?: number | undefined;
                                                  • the operation timeout

                                                  interface AppendObjectResult

                                                  interface AppendObjectResult {}

                                                    property name

                                                    name: string;

                                                      property nextAppendPosition

                                                      nextAppendPosition: string;
                                                      • the next position

                                                      property res

                                                      res: NormalSuccessResponse;

                                                        property url

                                                        url: string;
                                                        • the url of oss

                                                        interface Bucket

                                                        interface Bucket {}

                                                          property creationDate

                                                          creationDate: string;

                                                            property name

                                                            name: string;

                                                              property region

                                                              region: string;

                                                                property StorageClass

                                                                StorageClass: StorageType;

                                                                  interface BucketPolicy

                                                                  interface BucketPolicy {}

                                                                    property Statement

                                                                    Statement: Array<{
                                                                    Action: string[];
                                                                    Effect: 'Allow' | 'Deny';
                                                                    Principal: string[];
                                                                    Resource: string[];
                                                                    }>;

                                                                      property Version

                                                                      Version: string;

                                                                        interface Channel

                                                                        interface Channel {}

                                                                          property Description

                                                                          Description: string;

                                                                            property LastModified

                                                                            LastModified: string;

                                                                              property Name

                                                                              Name: string;

                                                                                property PlayUrls

                                                                                PlayUrls: string[];

                                                                                  property PublishUrls

                                                                                  PublishUrls: string[];

                                                                                    property Status

                                                                                    Status: string;

                                                                                      interface ChannelHistory

                                                                                      interface ChannelHistory {}

                                                                                        property EndTime

                                                                                        EndTime: string;

                                                                                          property RemoteAddr

                                                                                          RemoteAddr: string;
                                                                                          • the remote addr

                                                                                          property StartTime

                                                                                          StartTime: string;

                                                                                            interface ChannelHistoryResult

                                                                                            interface ChannelHistoryResult {}

                                                                                              property records

                                                                                              records: ChannelHistory;

                                                                                                property res

                                                                                                res: NormalSuccessResponse;

                                                                                                  interface Checkpoint

                                                                                                  interface Checkpoint {}

                                                                                                    property doneParts

                                                                                                    doneParts: Array<{ number: number; etag: string }>;

                                                                                                      property file

                                                                                                      file: any;
                                                                                                      • The file object selected by the user, if the browser is restarted, it needs the user to manually trigger the settings

                                                                                                      property fileSize

                                                                                                      fileSize: number;

                                                                                                        property name

                                                                                                        name: string;
                                                                                                        • object key

                                                                                                        property partSize

                                                                                                        partSize: number;

                                                                                                          property uploadId

                                                                                                          uploadId: string;

                                                                                                            interface ClusterOptions

                                                                                                            interface ClusterOptions {}

                                                                                                              property clusters

                                                                                                              clusters: ClusterType[];

                                                                                                                property schedule

                                                                                                                schedule?: string | undefined;

                                                                                                                  interface ClusterType

                                                                                                                  interface ClusterType {}

                                                                                                                    property accessKeyId

                                                                                                                    accessKeyId: string;

                                                                                                                      property accessKeySecret

                                                                                                                      accessKeySecret: string;

                                                                                                                        property host

                                                                                                                        host: string;

                                                                                                                          interface CompleteMultipartUploadOptions

                                                                                                                          interface CompleteMultipartUploadOptions {}

                                                                                                                            property callback

                                                                                                                            callback?: ObjectCallback | undefined;

                                                                                                                              property headers

                                                                                                                              headers?: object | undefined;

                                                                                                                                property timeout

                                                                                                                                timeout?: number | undefined;

                                                                                                                                  interface CompleteMultipartUploadResult

                                                                                                                                  interface CompleteMultipartUploadResult {}

                                                                                                                                    property bucket

                                                                                                                                    bucket: string;

                                                                                                                                      property data

                                                                                                                                      data: object;

                                                                                                                                        property etag

                                                                                                                                        etag: string;

                                                                                                                                          property name

                                                                                                                                          name: string;

                                                                                                                                            property res

                                                                                                                                            res: NormalSuccessResponse;

                                                                                                                                              interface CopyAndPutMetaResult

                                                                                                                                              interface CopyAndPutMetaResult {}

                                                                                                                                                property data

                                                                                                                                                data: ModifyData;

                                                                                                                                                  property res

                                                                                                                                                  res: NormalSuccessResponse;

                                                                                                                                                    interface CopyObjectOptions

                                                                                                                                                    interface CopyObjectOptions {}

                                                                                                                                                      property headers

                                                                                                                                                      headers?: object | undefined;

                                                                                                                                                        property meta

                                                                                                                                                        meta?: UserMeta | undefined;

                                                                                                                                                          property timeout

                                                                                                                                                          timeout?: number | undefined;

                                                                                                                                                            interface CORSRule

                                                                                                                                                            interface CORSRule {}

                                                                                                                                                              property allowedHeader

                                                                                                                                                              allowedHeader?: string | string[] | undefined;
                                                                                                                                                              • configure for Access-Control-Allow-Headers header

                                                                                                                                                              property allowedMethod

                                                                                                                                                              allowedMethod: string | string[];
                                                                                                                                                              • configure for Access-Control-Allow-Methods header

                                                                                                                                                              property allowedOrigin

                                                                                                                                                              allowedOrigin: string | string[];
                                                                                                                                                              • configure for Access-Control-Allow-Origin header

                                                                                                                                                              property exposeHeader

                                                                                                                                                              exposeHeader?: string | string[] | undefined;
                                                                                                                                                              • configure for Access-Control-Expose-Headers header

                                                                                                                                                              property maxAgeSeconds

                                                                                                                                                              maxAgeSeconds?: string | string[] | undefined;
                                                                                                                                                              • configure for Access-Control-Max-Age header

                                                                                                                                                              interface Credentials

                                                                                                                                                              interface Credentials {}

                                                                                                                                                                property AccessKeyId

                                                                                                                                                                AccessKeyId: string;
                                                                                                                                                                • STS access key id.

                                                                                                                                                                property AccessKeySecret

                                                                                                                                                                AccessKeySecret: string;
                                                                                                                                                                • STS access key secret.

                                                                                                                                                                property Expiration

                                                                                                                                                                Expiration: string;
                                                                                                                                                                • STS expiration UTC time in ISO format.

                                                                                                                                                                property SecurityToken

                                                                                                                                                                SecurityToken: string;
                                                                                                                                                                • STS token.

                                                                                                                                                                interface DeleteMultiOptions

                                                                                                                                                                interface DeleteMultiOptions {}

                                                                                                                                                                  property quiet

                                                                                                                                                                  quiet?: boolean | undefined;
                                                                                                                                                                  • quite mode or verbose mode, default is false

                                                                                                                                                                  property timeout

                                                                                                                                                                  timeout?: number | undefined;

                                                                                                                                                                    interface DeleteMultiResult

                                                                                                                                                                    interface DeleteMultiResult {}

                                                                                                                                                                      property deleted

                                                                                                                                                                      deleted?: string[] | undefined;
                                                                                                                                                                      • deleted object names list

                                                                                                                                                                      property res

                                                                                                                                                                      res: NormalSuccessResponse;

                                                                                                                                                                        interface GetACLResult

                                                                                                                                                                        interface GetACLResult {}

                                                                                                                                                                          property acl

                                                                                                                                                                          acl: ACLType;

                                                                                                                                                                            property res

                                                                                                                                                                            res: NormalSuccessResponse;

                                                                                                                                                                              interface GetBucketPolicyResult

                                                                                                                                                                              interface GetBucketPolicyResult {}

                                                                                                                                                                                property policy

                                                                                                                                                                                policy: BucketPolicy | null;

                                                                                                                                                                                  property res

                                                                                                                                                                                  res: NormalSuccessResponse;

                                                                                                                                                                                    property status

                                                                                                                                                                                    status: number;

                                                                                                                                                                                      interface GetChannelResult

                                                                                                                                                                                      interface GetChannelResult {}

                                                                                                                                                                                        property Audio

                                                                                                                                                                                        Audio?: object | undefined;

                                                                                                                                                                                          property ConnectedTime

                                                                                                                                                                                          ConnectedTime?: string | undefined;

                                                                                                                                                                                            property RemoteAddr

                                                                                                                                                                                            RemoteAddr?: string | undefined;

                                                                                                                                                                                              property res

                                                                                                                                                                                              res: NormalSuccessResponse;

                                                                                                                                                                                                property Status

                                                                                                                                                                                                Status: string;

                                                                                                                                                                                                  property Video

                                                                                                                                                                                                  Video?: object | undefined;

                                                                                                                                                                                                    interface GetObjectOptions

                                                                                                                                                                                                    interface GetObjectOptions {}

                                                                                                                                                                                                      property headers

                                                                                                                                                                                                      headers?: object | undefined;

                                                                                                                                                                                                        property process

                                                                                                                                                                                                        process?: string | undefined;
                                                                                                                                                                                                        • The Content-Type of the callback requests initiatiated, It supports application/x-www-form-urlencoded and application/json, and the former is the default value.

                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                        timeout?: number | undefined;

                                                                                                                                                                                                          interface GetObjectResult

                                                                                                                                                                                                          interface GetObjectResult {}

                                                                                                                                                                                                            property content

                                                                                                                                                                                                            content?: any;
                                                                                                                                                                                                            • file content buffer if file parameter is null or ignore

                                                                                                                                                                                                            property res

                                                                                                                                                                                                            res: NormalSuccessResponse;

                                                                                                                                                                                                              interface GetRtmpUrlOptions

                                                                                                                                                                                                              interface GetRtmpUrlOptions {}

                                                                                                                                                                                                                property expires

                                                                                                                                                                                                                expires?: number | undefined;
                                                                                                                                                                                                                • the expire time in seconds of the url

                                                                                                                                                                                                                property params

                                                                                                                                                                                                                params?: object | undefined;
                                                                                                                                                                                                                • the additional parameters for url, e.g.: {playlistName: 'play.m3u8'}

                                                                                                                                                                                                                property timeout

                                                                                                                                                                                                                timeout?: number | undefined;
                                                                                                                                                                                                                • the operation timeout

                                                                                                                                                                                                                interface GetStreamOptions

                                                                                                                                                                                                                interface GetStreamOptions {}

                                                                                                                                                                                                                  property headers

                                                                                                                                                                                                                  headers?: object | undefined;

                                                                                                                                                                                                                    property process

                                                                                                                                                                                                                    process?: string | undefined;
                                                                                                                                                                                                                    • The Content-Type of the callback requests initiatiated, It supports application/x-www-form-urlencoded and application/json, and the former is the default value.

                                                                                                                                                                                                                    property timeout

                                                                                                                                                                                                                    timeout?: number | undefined;

                                                                                                                                                                                                                      interface GetStreamResult

                                                                                                                                                                                                                      interface GetStreamResult {}

                                                                                                                                                                                                                        property res

                                                                                                                                                                                                                        res: NormalSuccessResponse;

                                                                                                                                                                                                                          property stream

                                                                                                                                                                                                                          stream?: any;
                                                                                                                                                                                                                          • readable stream instance if response status is not 200, stream will be null.

                                                                                                                                                                                                                          interface HeadObjectOptions

                                                                                                                                                                                                                          interface HeadObjectOptions {}

                                                                                                                                                                                                                            property headers

                                                                                                                                                                                                                            headers?: object | undefined;

                                                                                                                                                                                                                              property timeout

                                                                                                                                                                                                                              timeout?: number | undefined;

                                                                                                                                                                                                                                interface HeadObjectResult

                                                                                                                                                                                                                                interface HeadObjectResult {}

                                                                                                                                                                                                                                  property meta

                                                                                                                                                                                                                                  meta: UserMeta;

                                                                                                                                                                                                                                    property res

                                                                                                                                                                                                                                    res: NormalSuccessResponse;

                                                                                                                                                                                                                                      property status

                                                                                                                                                                                                                                      status: number;
                                                                                                                                                                                                                                      • response status, maybe 200 or 304

                                                                                                                                                                                                                                      interface ImageClientOptions

                                                                                                                                                                                                                                      interface ImageClientOptions {}

                                                                                                                                                                                                                                        property accessKeyId

                                                                                                                                                                                                                                        accessKeyId: string;
                                                                                                                                                                                                                                        • access key you create on aliyun console website

                                                                                                                                                                                                                                        property accessKeySecret

                                                                                                                                                                                                                                        accessKeySecret: string;
                                                                                                                                                                                                                                        • access secret you create

                                                                                                                                                                                                                                        property bucket

                                                                                                                                                                                                                                        bucket: string;
                                                                                                                                                                                                                                        • the default bucket you want to access If you don't have any bucket, please use putBucket() create one first.

                                                                                                                                                                                                                                        property imageHost

                                                                                                                                                                                                                                        imageHost: string;
                                                                                                                                                                                                                                        • your image service domain that binding to a OSS bucket

                                                                                                                                                                                                                                        property internal

                                                                                                                                                                                                                                        internal?: boolean | 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.

                                                                                                                                                                                                                                        property region

                                                                                                                                                                                                                                        region?: string | undefined;
                                                                                                                                                                                                                                        • the bucket data region location, please see Data Regions, default is oss-cn-hangzhou

                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                        timeout?: string | number | undefined;
                                                                                                                                                                                                                                        • instance level timeout for all operations, default is 60s

                                                                                                                                                                                                                                        interface ImageGetOptions

                                                                                                                                                                                                                                        interface ImageGetOptions {}

                                                                                                                                                                                                                                          property headers

                                                                                                                                                                                                                                          headers?: object | undefined;

                                                                                                                                                                                                                                            property timeout

                                                                                                                                                                                                                                            timeout?: number | undefined;

                                                                                                                                                                                                                                              interface InitMultipartUploadOptions

                                                                                                                                                                                                                                              interface InitMultipartUploadOptions {}

                                                                                                                                                                                                                                                property headers

                                                                                                                                                                                                                                                headers?: object | undefined;

                                                                                                                                                                                                                                                  property meta

                                                                                                                                                                                                                                                  meta?: UserMeta | undefined;

                                                                                                                                                                                                                                                    property mime

                                                                                                                                                                                                                                                    mime?: string | undefined;
                                                                                                                                                                                                                                                    • Mime file type

                                                                                                                                                                                                                                                    property timeout

                                                                                                                                                                                                                                                    timeout?: number | undefined;

                                                                                                                                                                                                                                                      interface InitMultipartUploadResult

                                                                                                                                                                                                                                                      interface InitMultipartUploadResult {}

                                                                                                                                                                                                                                                        property bucket

                                                                                                                                                                                                                                                        bucket: string;
                                                                                                                                                                                                                                                        • bucket name

                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                        name: string;
                                                                                                                                                                                                                                                        • object name store on OSS

                                                                                                                                                                                                                                                        property res

                                                                                                                                                                                                                                                        res: { status: number; headers: object; size: number; rt: number };

                                                                                                                                                                                                                                                          property uploadId

                                                                                                                                                                                                                                                          uploadId: string;
                                                                                                                                                                                                                                                          • upload id, use for uploadPart, completeMultipart

                                                                                                                                                                                                                                                          interface LifecycleRule

                                                                                                                                                                                                                                                          interface LifecycleRule {}

                                                                                                                                                                                                                                                            property date

                                                                                                                                                                                                                                                            date: string;
                                                                                                                                                                                                                                                            • expire date, e.g.: 2022-10-11T00:00:00.000Z date and days only set one.

                                                                                                                                                                                                                                                            property days

                                                                                                                                                                                                                                                            days?: number | string | undefined;
                                                                                                                                                                                                                                                            • expire after the days

                                                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                                                            id?: string | undefined;
                                                                                                                                                                                                                                                            • rule id, if not set, OSS will auto create it with random string.

                                                                                                                                                                                                                                                            property prefix

                                                                                                                                                                                                                                                            prefix: string;
                                                                                                                                                                                                                                                            • store prefix

                                                                                                                                                                                                                                                            property status

                                                                                                                                                                                                                                                            status: RuleStatusType;
                                                                                                                                                                                                                                                            • rule status, allow values: Enabled or Disabled

                                                                                                                                                                                                                                                            interface ListBucketsQueryType

                                                                                                                                                                                                                                                            interface ListBucketsQueryType {}

                                                                                                                                                                                                                                                              property 'max-keys'

                                                                                                                                                                                                                                                              'max-keys'?: string | number | undefined;
                                                                                                                                                                                                                                                              • max buckets, default is 100, limit to 1000

                                                                                                                                                                                                                                                              property marker

                                                                                                                                                                                                                                                              marker?: string | undefined;
                                                                                                                                                                                                                                                              • search start from marker, including marker key

                                                                                                                                                                                                                                                              property prefix

                                                                                                                                                                                                                                                              prefix?: string | undefined;
                                                                                                                                                                                                                                                              • search buckets using prefix key

                                                                                                                                                                                                                                                              interface ListChannelsQuery

                                                                                                                                                                                                                                                              interface ListChannelsQuery {}

                                                                                                                                                                                                                                                                property 'max-keys '

                                                                                                                                                                                                                                                                'max-keys ': number;
                                                                                                                                                                                                                                                                • max number of channels to return

                                                                                                                                                                                                                                                                property marker

                                                                                                                                                                                                                                                                marker: string;
                                                                                                                                                                                                                                                                • the channel id marker (returns channels after this id)

                                                                                                                                                                                                                                                                property prefix

                                                                                                                                                                                                                                                                prefix: string;
                                                                                                                                                                                                                                                                • the channel id prefix (returns channels with this prefix)

                                                                                                                                                                                                                                                                interface ListChannelsResult

                                                                                                                                                                                                                                                                interface ListChannelsResult {}

                                                                                                                                                                                                                                                                  property channels

                                                                                                                                                                                                                                                                  channels: Channel[];

                                                                                                                                                                                                                                                                    property isTruncated

                                                                                                                                                                                                                                                                    isTruncated: boolean;

                                                                                                                                                                                                                                                                      property nextMarker

                                                                                                                                                                                                                                                                      nextMarker: string | null;

                                                                                                                                                                                                                                                                        property res

                                                                                                                                                                                                                                                                        res: NormalSuccessResponse;

                                                                                                                                                                                                                                                                          interface ListObjectResult

                                                                                                                                                                                                                                                                          interface ListObjectResult {}

                                                                                                                                                                                                                                                                            property isTruncated

                                                                                                                                                                                                                                                                            isTruncated: boolean;

                                                                                                                                                                                                                                                                              property nextMarker

                                                                                                                                                                                                                                                                              nextMarker: string;

                                                                                                                                                                                                                                                                                property objects

                                                                                                                                                                                                                                                                                objects: ObjectMeta[];

                                                                                                                                                                                                                                                                                  property prefixes

                                                                                                                                                                                                                                                                                  prefixes: string[];

                                                                                                                                                                                                                                                                                    property res

                                                                                                                                                                                                                                                                                    res: NormalSuccessResponse;

                                                                                                                                                                                                                                                                                      interface ListObjectsQuery

                                                                                                                                                                                                                                                                                      interface ListObjectsQuery {}

                                                                                                                                                                                                                                                                                        property 'encoding-type'

                                                                                                                                                                                                                                                                                        'encoding-type'?: 'url' | '';
                                                                                                                                                                                                                                                                                        • Specifies that the object names in the response are URL-encoded.

                                                                                                                                                                                                                                                                                        property 'max-keys'

                                                                                                                                                                                                                                                                                        'max-keys': string | number;
                                                                                                                                                                                                                                                                                        • max objects, default is 100, limit to 1000

                                                                                                                                                                                                                                                                                        property delimiter

                                                                                                                                                                                                                                                                                        delimiter?: string | undefined;
                                                                                                                                                                                                                                                                                        • only search current dir, not including subdir

                                                                                                                                                                                                                                                                                        property marker

                                                                                                                                                                                                                                                                                        marker?: string | undefined;
                                                                                                                                                                                                                                                                                        • search start from marker, including marker key

                                                                                                                                                                                                                                                                                        property prefix

                                                                                                                                                                                                                                                                                        prefix?: string | undefined;
                                                                                                                                                                                                                                                                                        • search object using prefix key

                                                                                                                                                                                                                                                                                        interface ListPartsQuery

                                                                                                                                                                                                                                                                                        interface ListPartsQuery {}

                                                                                                                                                                                                                                                                                          property 'encoding-type'

                                                                                                                                                                                                                                                                                          'encoding-type': string;
                                                                                                                                                                                                                                                                                          • Specify the encoding of the returned content and the encoding type. Optional value: url

                                                                                                                                                                                                                                                                                          property 'max-parts'

                                                                                                                                                                                                                                                                                          'max-parts': number;
                                                                                                                                                                                                                                                                                          • The maximum part number in the response of the OSS. default value: 1000.

                                                                                                                                                                                                                                                                                          property 'part-number-marker'

                                                                                                                                                                                                                                                                                          'part-number-marker': number;
                                                                                                                                                                                                                                                                                          • Starting position of a specific list. A part is listed only when the part number is greater than the value of this parameter.

                                                                                                                                                                                                                                                                                          interface ListPartsResult

                                                                                                                                                                                                                                                                                          interface ListPartsResult {}

                                                                                                                                                                                                                                                                                            property bucket

                                                                                                                                                                                                                                                                                            bucket: string;

                                                                                                                                                                                                                                                                                              property isTruncated

                                                                                                                                                                                                                                                                                              isTruncated: boolean;

                                                                                                                                                                                                                                                                                                property maxParts

                                                                                                                                                                                                                                                                                                maxParts: number;

                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                    property nextPartNumberMarker

                                                                                                                                                                                                                                                                                                    nextPartNumberMarker: number;

                                                                                                                                                                                                                                                                                                      property PartNumberMarker

                                                                                                                                                                                                                                                                                                      PartNumberMarker: number;

                                                                                                                                                                                                                                                                                                        property parts

                                                                                                                                                                                                                                                                                                        parts: ObjectPart[];

                                                                                                                                                                                                                                                                                                          property res

                                                                                                                                                                                                                                                                                                          res: NormalSuccessResponse;

                                                                                                                                                                                                                                                                                                            property uploadId

                                                                                                                                                                                                                                                                                                            uploadId: string;

                                                                                                                                                                                                                                                                                                              interface ListUploadsQuery

                                                                                                                                                                                                                                                                                                              interface ListUploadsQuery {}

                                                                                                                                                                                                                                                                                                                property 'key-marker'

                                                                                                                                                                                                                                                                                                                'key-marker'?: string | undefined;

                                                                                                                                                                                                                                                                                                                  property 'max-uploads'

                                                                                                                                                                                                                                                                                                                  'max-uploads'?: number | undefined;

                                                                                                                                                                                                                                                                                                                    property 'upload-id-marker'

                                                                                                                                                                                                                                                                                                                    'upload-id-marker'?: string | undefined;

                                                                                                                                                                                                                                                                                                                      property prefix

                                                                                                                                                                                                                                                                                                                      prefix?: string | undefined;

                                                                                                                                                                                                                                                                                                                        interface ListUploadsResult

                                                                                                                                                                                                                                                                                                                        interface ListUploadsResult {}

                                                                                                                                                                                                                                                                                                                          property bucket

                                                                                                                                                                                                                                                                                                                          bucket: string;

                                                                                                                                                                                                                                                                                                                            property isTruncated

                                                                                                                                                                                                                                                                                                                            isTruncated: boolean;

                                                                                                                                                                                                                                                                                                                              property nextKeyMarker

                                                                                                                                                                                                                                                                                                                              nextKeyMarker: any;

                                                                                                                                                                                                                                                                                                                                property nextUploadIdMarker

                                                                                                                                                                                                                                                                                                                                nextUploadIdMarker: any;

                                                                                                                                                                                                                                                                                                                                  property res

                                                                                                                                                                                                                                                                                                                                  res: NormalSuccessResponse;

                                                                                                                                                                                                                                                                                                                                    property uploads

                                                                                                                                                                                                                                                                                                                                    uploads: Upload[];

                                                                                                                                                                                                                                                                                                                                      interface ListV2ObjectsQuery

                                                                                                                                                                                                                                                                                                                                      interface ListV2ObjectsQuery {}

                                                                                                                                                                                                                                                                                                                                        property 'continuation-token'

                                                                                                                                                                                                                                                                                                                                        'continuation-token'?: string;
                                                                                                                                                                                                                                                                                                                                        • search start from token, including token key

                                                                                                                                                                                                                                                                                                                                        property 'encoding-type'

                                                                                                                                                                                                                                                                                                                                        'encoding-type'?: 'url' | '';
                                                                                                                                                                                                                                                                                                                                        • Specifies that the object names in the response are URL-encoded.

                                                                                                                                                                                                                                                                                                                                        property 'fetch-owner'

                                                                                                                                                                                                                                                                                                                                        'fetch-owner'?: boolean;
                                                                                                                                                                                                                                                                                                                                        • Specifies whether to include the information about object owners in the response.

                                                                                                                                                                                                                                                                                                                                        property 'max-keys'

                                                                                                                                                                                                                                                                                                                                        'max-keys'?: string;
                                                                                                                                                                                                                                                                                                                                        • max objects, default is 100, limit to 1000

                                                                                                                                                                                                                                                                                                                                        property 'start-after'

                                                                                                                                                                                                                                                                                                                                        'start-after'?: string;
                                                                                                                                                                                                                                                                                                                                        • The name of the object from which the list operation begins. If this parameter is specified, objects whose names are alphabetically greater than the start-after parameter value are returned.

                                                                                                                                                                                                                                                                                                                                        property delimiter

                                                                                                                                                                                                                                                                                                                                        delimiter?: string | number;
                                                                                                                                                                                                                                                                                                                                        • only search current dir, not including subdir

                                                                                                                                                                                                                                                                                                                                        property prefix

                                                                                                                                                                                                                                                                                                                                        prefix?: string;
                                                                                                                                                                                                                                                                                                                                        • search object using prefix key

                                                                                                                                                                                                                                                                                                                                        interface ModifyData

                                                                                                                                                                                                                                                                                                                                        interface ModifyData {}

                                                                                                                                                                                                                                                                                                                                          property etag

                                                                                                                                                                                                                                                                                                                                          etag: string;
                                                                                                                                                                                                                                                                                                                                          • object etag contains ", e.g.: "5B3C1A2E053D763E1B002CC607C5A0FE"

                                                                                                                                                                                                                                                                                                                                          property lastModified

                                                                                                                                                                                                                                                                                                                                          lastModified: string;
                                                                                                                                                                                                                                                                                                                                          • object last modified GMT string

                                                                                                                                                                                                                                                                                                                                          interface MultipartUploadCopyResult

                                                                                                                                                                                                                                                                                                                                          interface MultipartUploadCopyResult {}

                                                                                                                                                                                                                                                                                                                                            property bucket

                                                                                                                                                                                                                                                                                                                                            bucket: string;

                                                                                                                                                                                                                                                                                                                                              property etag

                                                                                                                                                                                                                                                                                                                                              etag: string;

                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                                                                                                                                                  property res

                                                                                                                                                                                                                                                                                                                                                  res: NormalSuccessResponse;

                                                                                                                                                                                                                                                                                                                                                    interface MultipartUploadCopySourceData

                                                                                                                                                                                                                                                                                                                                                    interface MultipartUploadCopySourceData {}

                                                                                                                                                                                                                                                                                                                                                      property endOffset

                                                                                                                                                                                                                                                                                                                                                      endOffset: number;
                                                                                                                                                                                                                                                                                                                                                      • data copy end byte offset, e.g: 102400

                                                                                                                                                                                                                                                                                                                                                      property sourceBucketName

                                                                                                                                                                                                                                                                                                                                                      sourceBucketName: string;
                                                                                                                                                                                                                                                                                                                                                      • sourceData. the source bucket name

                                                                                                                                                                                                                                                                                                                                                      property sourceKey

                                                                                                                                                                                                                                                                                                                                                      sourceKey: string;
                                                                                                                                                                                                                                                                                                                                                      • the source object name

                                                                                                                                                                                                                                                                                                                                                      property startOffset

                                                                                                                                                                                                                                                                                                                                                      startOffset: number;
                                                                                                                                                                                                                                                                                                                                                      • data copy start byte offset, e.g: 0

                                                                                                                                                                                                                                                                                                                                                      interface MultipartUploadOptions

                                                                                                                                                                                                                                                                                                                                                      interface MultipartUploadOptions {}

                                                                                                                                                                                                                                                                                                                                                        property callback

                                                                                                                                                                                                                                                                                                                                                        callback?: ObjectCallback | undefined;

                                                                                                                                                                                                                                                                                                                                                          property checkpoint

                                                                                                                                                                                                                                                                                                                                                          checkpoint?: Checkpoint | undefined;
                                                                                                                                                                                                                                                                                                                                                          • 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.

                                                                                                                                                                                                                                                                                                                                                          property copyheaders

                                                                                                                                                                                                                                                                                                                                                          copyheaders?: object | undefined;
                                                                                                                                                                                                                                                                                                                                                          • {Object} only uploadPartCopy api used, detail

                                                                                                                                                                                                                                                                                                                                                          property headers

                                                                                                                                                                                                                                                                                                                                                          headers?: object | undefined;

                                                                                                                                                                                                                                                                                                                                                            property meta

                                                                                                                                                                                                                                                                                                                                                            meta?: UserMeta | undefined;

                                                                                                                                                                                                                                                                                                                                                              property mime

                                                                                                                                                                                                                                                                                                                                                              mime?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                property parallel

                                                                                                                                                                                                                                                                                                                                                                parallel?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                • the number of parts to be uploaded in parallel

                                                                                                                                                                                                                                                                                                                                                                property partSize

                                                                                                                                                                                                                                                                                                                                                                partSize?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                • the suggested size for each part

                                                                                                                                                                                                                                                                                                                                                                property progress

                                                                                                                                                                                                                                                                                                                                                                progress?: ((...args: any[]) => any) | undefined;
                                                                                                                                                                                                                                                                                                                                                                • the progress callback called after each successful upload of one part

                                                                                                                                                                                                                                                                                                                                                                property timeout

                                                                                                                                                                                                                                                                                                                                                                timeout?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                  interface MultipartUploadResult

                                                                                                                                                                                                                                                                                                                                                                  interface MultipartUploadResult {}

                                                                                                                                                                                                                                                                                                                                                                    property bucket

                                                                                                                                                                                                                                                                                                                                                                    bucket: string;

                                                                                                                                                                                                                                                                                                                                                                      property data

                                                                                                                                                                                                                                                                                                                                                                      data: object;

                                                                                                                                                                                                                                                                                                                                                                        property etag

                                                                                                                                                                                                                                                                                                                                                                        etag: string;

                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                                                                            property res

                                                                                                                                                                                                                                                                                                                                                                            res: NormalSuccessResponse;

                                                                                                                                                                                                                                                                                                                                                                              interface NormalSuccessResponse

                                                                                                                                                                                                                                                                                                                                                                              interface NormalSuccessResponse {}

                                                                                                                                                                                                                                                                                                                                                                                property headers

                                                                                                                                                                                                                                                                                                                                                                                headers: object;
                                                                                                                                                                                                                                                                                                                                                                                • todo the object in detail

                                                                                                                                                                                                                                                                                                                                                                                property rt

                                                                                                                                                                                                                                                                                                                                                                                rt: number;
                                                                                                                                                                                                                                                                                                                                                                                • request total use time (ms)

                                                                                                                                                                                                                                                                                                                                                                                property size

                                                                                                                                                                                                                                                                                                                                                                                size: number;
                                                                                                                                                                                                                                                                                                                                                                                • response size

                                                                                                                                                                                                                                                                                                                                                                                property status

                                                                                                                                                                                                                                                                                                                                                                                status: number;
                                                                                                                                                                                                                                                                                                                                                                                • response status

                                                                                                                                                                                                                                                                                                                                                                                interface ObjectCallback

                                                                                                                                                                                                                                                                                                                                                                                interface ObjectCallback {}

                                                                                                                                                                                                                                                                                                                                                                                  property body

                                                                                                                                                                                                                                                                                                                                                                                  body: string;
                                                                                                                                                                                                                                                                                                                                                                                  • The value of the request body when a callback is initiated, for example, key=$(key)&etag=$(etag)&my_var=$(x:my_var).

                                                                                                                                                                                                                                                                                                                                                                                  property contentType

                                                                                                                                                                                                                                                                                                                                                                                  contentType?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                  • The Content-Type of the callback requests initiatiated, It supports application/x-www-form-urlencoded and application/json, and the former is the default value.

                                                                                                                                                                                                                                                                                                                                                                                  property customValue

                                                                                                                                                                                                                                                                                                                                                                                  customValue?: object | undefined;

                                                                                                                                                                                                                                                                                                                                                                                    property headers

                                                                                                                                                                                                                                                                                                                                                                                    headers?: object | undefined;
                                                                                                                                                                                                                                                                                                                                                                                    • extra headers, detail see RFC 2616

                                                                                                                                                                                                                                                                                                                                                                                    property host

                                                                                                                                                                                                                                                                                                                                                                                    host?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                    • The host header value for initiating callback requests.

                                                                                                                                                                                                                                                                                                                                                                                    property url

                                                                                                                                                                                                                                                                                                                                                                                    url: string;
                                                                                                                                                                                                                                                                                                                                                                                    • After a file is uploaded successfully, the OSS sends a callback request to this URL.

                                                                                                                                                                                                                                                                                                                                                                                    interface ObjectMeta

                                                                                                                                                                                                                                                                                                                                                                                    interface ObjectMeta {}

                                                                                                                                                                                                                                                                                                                                                                                      property etag

                                                                                                                                                                                                                                                                                                                                                                                      etag: string;
                                                                                                                                                                                                                                                                                                                                                                                      • object etag contains ", e.g.: "5B3C1A2E053D763E1B002CC607C5A0FE"

                                                                                                                                                                                                                                                                                                                                                                                      property lastModified

                                                                                                                                                                                                                                                                                                                                                                                      lastModified: string;
                                                                                                                                                                                                                                                                                                                                                                                      • object last modified GMT date, e.g.: 2015-02-19T08:39:44.000Z

                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                                                                      • object name on oss

                                                                                                                                                                                                                                                                                                                                                                                      property owner

                                                                                                                                                                                                                                                                                                                                                                                      owner?: OwnerType;

                                                                                                                                                                                                                                                                                                                                                                                        property size

                                                                                                                                                                                                                                                                                                                                                                                        size: number;
                                                                                                                                                                                                                                                                                                                                                                                        • object size, e.g.: 344606

                                                                                                                                                                                                                                                                                                                                                                                        property storageClass

                                                                                                                                                                                                                                                                                                                                                                                        storageClass: StorageType;

                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                          type: string;
                                                                                                                                                                                                                                                                                                                                                                                          • object type, e.g.: Normal

                                                                                                                                                                                                                                                                                                                                                                                          property url

                                                                                                                                                                                                                                                                                                                                                                                          url: string;
                                                                                                                                                                                                                                                                                                                                                                                          • object url

                                                                                                                                                                                                                                                                                                                                                                                          interface ObjectPart

                                                                                                                                                                                                                                                                                                                                                                                          interface ObjectPart {}

                                                                                                                                                                                                                                                                                                                                                                                            property ETag

                                                                                                                                                                                                                                                                                                                                                                                            ETag: string;

                                                                                                                                                                                                                                                                                                                                                                                              property LastModified

                                                                                                                                                                                                                                                                                                                                                                                              LastModified: any;
                                                                                                                                                                                                                                                                                                                                                                                              • {Date} Time when a part is uploaded.

                                                                                                                                                                                                                                                                                                                                                                                              property PartNumber

                                                                                                                                                                                                                                                                                                                                                                                              PartNumber: number;

                                                                                                                                                                                                                                                                                                                                                                                                property size

                                                                                                                                                                                                                                                                                                                                                                                                size: number;

                                                                                                                                                                                                                                                                                                                                                                                                  interface Options

                                                                                                                                                                                                                                                                                                                                                                                                  interface Options {}

                                                                                                                                                                                                                                                                                                                                                                                                    property accessKeyId

                                                                                                                                                                                                                                                                                                                                                                                                    accessKeyId: string;
                                                                                                                                                                                                                                                                                                                                                                                                    • access secret you create

                                                                                                                                                                                                                                                                                                                                                                                                    property accessKeySecret

                                                                                                                                                                                                                                                                                                                                                                                                    accessKeySecret: string;
                                                                                                                                                                                                                                                                                                                                                                                                    • access secret you create

                                                                                                                                                                                                                                                                                                                                                                                                    property bucket

                                                                                                                                                                                                                                                                                                                                                                                                    bucket?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                    • the default bucket you want to access If you don't have any bucket, please use putBucket() create one first.

                                                                                                                                                                                                                                                                                                                                                                                                    property cname

                                                                                                                                                                                                                                                                                                                                                                                                    cname?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                    • use custom domain name

                                                                                                                                                                                                                                                                                                                                                                                                    property endpoint

                                                                                                                                                                                                                                                                                                                                                                                                    endpoint?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                    • oss region domain. It takes priority over region.

                                                                                                                                                                                                                                                                                                                                                                                                    property internal

                                                                                                                                                                                                                                                                                                                                                                                                    internal?: boolean | 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.

                                                                                                                                                                                                                                                                                                                                                                                                    property refreshSTSToken

                                                                                                                                                                                                                                                                                                                                                                                                    refreshSTSToken?: () => Promise<{
                                                                                                                                                                                                                                                                                                                                                                                                    accessKeyId: string;
                                                                                                                                                                                                                                                                                                                                                                                                    accessKeySecret: string;
                                                                                                                                                                                                                                                                                                                                                                                                    stsToken: string;
                                                                                                                                                                                                                                                                                                                                                                                                    }>;
                                                                                                                                                                                                                                                                                                                                                                                                    • used by auto set stsToken、accessKeyId、accessKeySecret when sts info expires. return value must be object contains stsToken、accessKeyId、accessKeySecret

                                                                                                                                                                                                                                                                                                                                                                                                    property refreshSTSTokenInterval

                                                                                                                                                                                                                                                                                                                                                                                                    refreshSTSTokenInterval?: number;
                                                                                                                                                                                                                                                                                                                                                                                                    • use time (ms) of refresh STSToken interval it should be less than sts info expire interval, default is 300000ms(5min) when sts info expires.

                                                                                                                                                                                                                                                                                                                                                                                                    property region

                                                                                                                                                                                                                                                                                                                                                                                                    region?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                    • the bucket data region location, please see Data Regions, default is oss-cn-hangzhou.

                                                                                                                                                                                                                                                                                                                                                                                                    property secure

                                                                                                                                                                                                                                                                                                                                                                                                    secure?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                    • instruct OSS client to use HTTPS (secure: true) or HTTP (secure: false) protocol.

                                                                                                                                                                                                                                                                                                                                                                                                    property stsToken

                                                                                                                                                                                                                                                                                                                                                                                                    stsToken?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                    • used by temporary authorization

                                                                                                                                                                                                                                                                                                                                                                                                    property timeout

                                                                                                                                                                                                                                                                                                                                                                                                    timeout?: string | number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                    • instance level timeout for all operations, default is 60s

                                                                                                                                                                                                                                                                                                                                                                                                    interface OwnerType

                                                                                                                                                                                                                                                                                                                                                                                                    interface OwnerType {}

                                                                                                                                                                                                                                                                                                                                                                                                      property displayName

                                                                                                                                                                                                                                                                                                                                                                                                      displayName: string;

                                                                                                                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                                                                                                                        id: string;

                                                                                                                                                                                                                                                                                                                                                                                                          interface PostObjectParams

                                                                                                                                                                                                                                                                                                                                                                                                          interface PostObjectParams {}

                                                                                                                                                                                                                                                                                                                                                                                                            property OSSAccessKeyId

                                                                                                                                                                                                                                                                                                                                                                                                            OSSAccessKeyId: string;

                                                                                                                                                                                                                                                                                                                                                                                                              property policy

                                                                                                                                                                                                                                                                                                                                                                                                              policy: string;

                                                                                                                                                                                                                                                                                                                                                                                                                property Signature

                                                                                                                                                                                                                                                                                                                                                                                                                Signature: string;

                                                                                                                                                                                                                                                                                                                                                                                                                  interface PutBucketOptions

                                                                                                                                                                                                                                                                                                                                                                                                                  interface PutBucketOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                    property acl

                                                                                                                                                                                                                                                                                                                                                                                                                    acl: ACLType;

                                                                                                                                                                                                                                                                                                                                                                                                                      property dataRedundancyType

                                                                                                                                                                                                                                                                                                                                                                                                                      dataRedundancyType: RedundancyType;

                                                                                                                                                                                                                                                                                                                                                                                                                        property storageClass

                                                                                                                                                                                                                                                                                                                                                                                                                        storageClass: StorageType;

                                                                                                                                                                                                                                                                                                                                                                                                                          property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                          timeout: number;

                                                                                                                                                                                                                                                                                                                                                                                                                            interface PutBucketWebsiteConfig

                                                                                                                                                                                                                                                                                                                                                                                                                            interface PutBucketWebsiteConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                              property error

                                                                                                                                                                                                                                                                                                                                                                                                                              error?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                              • error page, e.g.: 'error.html'

                                                                                                                                                                                                                                                                                                                                                                                                                              property index

                                                                                                                                                                                                                                                                                                                                                                                                                              index: string;
                                                                                                                                                                                                                                                                                                                                                                                                                              • default page, e.g.: index.html

                                                                                                                                                                                                                                                                                                                                                                                                                              interface PutChannelConf

                                                                                                                                                                                                                                                                                                                                                                                                                              interface PutChannelConf {}

                                                                                                                                                                                                                                                                                                                                                                                                                                property Description

                                                                                                                                                                                                                                                                                                                                                                                                                                Description?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property Status

                                                                                                                                                                                                                                                                                                                                                                                                                                  Status?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property Target

                                                                                                                                                                                                                                                                                                                                                                                                                                    Target?:
                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                    Type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                    FragDuration: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                    FragCount: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                    PlaylistName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PutChannelResult

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PutChannelResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                        property playUrls

                                                                                                                                                                                                                                                                                                                                                                                                                                        playUrls: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                          property publishUrls

                                                                                                                                                                                                                                                                                                                                                                                                                                          publishUrls: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                            property res

                                                                                                                                                                                                                                                                                                                                                                                                                                            res: NormalSuccessResponse;

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PutObjectOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PutObjectOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                property callback

                                                                                                                                                                                                                                                                                                                                                                                                                                                callback?: ObjectCallback | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property headers

                                                                                                                                                                                                                                                                                                                                                                                                                                                  headers?: object | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property meta

                                                                                                                                                                                                                                                                                                                                                                                                                                                    meta?: UserMeta | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • user meta, will send with x-oss-meta- prefix string e.g.: { uid: 123, pid: 110 }

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property mime

                                                                                                                                                                                                                                                                                                                                                                                                                                                    mime?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • custom mime, will send with Content-Type entity header

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeout?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • the operation timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PutObjectResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface PutObjectResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                      data: object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property res

                                                                                                                                                                                                                                                                                                                                                                                                                                                          res: NormalSuccessResponse;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property url

                                                                                                                                                                                                                                                                                                                                                                                                                                                            url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PutStreamOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PutStreamOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property callback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: ObjectCallback;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property contentLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  contentLength?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • the stream length, chunked encoding will be used if absent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property headers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  headers?: object | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property meta

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    meta: UserMeta;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property mime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mime: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • custom mime, will send with Content-Type entity header

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      timeout: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • the operation timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface RequestOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface RequestOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ResponseHeaderType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ResponseHeaderType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property 'cache-control'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'cache-control'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property 'content-disposition'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              'content-disposition'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property 'content-type'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'content-type'?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SignatureUrlOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SignatureUrlOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property 'Content-Type'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'Content-Type'?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • set the request content type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property callback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    callback?: ObjectCallback | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property expires

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      expires?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • after expires seconds, the url will become invalid, default is 1800

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method?: HTTPMethods | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • the HTTP method, default is 'GET'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property process

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      process?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property response

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        response?: ResponseHeaderType | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • set the response headers for download

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface STSOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface STSOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property accessKeyId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          accessKeyId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Access key id.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property accessKeySecret

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          accessKeySecret: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Access key secret.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface StyleData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface StyleData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Content: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • style content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property CreateTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CreateTime: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • style create time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property LastModifyTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            LastModifyTime: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • style last modify time

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • style name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Upload

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Upload {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property initiated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              initiated: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property uploadId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  uploadId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface UploadPartResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface UploadPartResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property etag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      etag: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property res

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          res: NormalSuccessResponse;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UserMeta

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UserMeta extends Record<string, string | number> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • x-oss-meta-* in https://help.aliyun.com/document_detail/31978.html for Aliyun user

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • x-oss-meta-* in https://www.alibabacloud.com/help/en/doc-detail/31978.html for AlibabaCloud user

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property pid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pid: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property uid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              uid: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ACLType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ACLType = 'public-read-write' | 'public-read' | 'private';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HTTPMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type HTTPMethods = 'GET' | 'POST' | 'DELETE' | 'PUT';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RedundancyType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RedundancyType = 'LRS' | 'ZRS';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RuleStatusType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RuleStatusType = 'Enabled' | 'Disabled';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type StorageType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type StorageType = 'Standard' | 'IA' | 'Archive';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/ali-oss.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/ali-oss)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <a href="https://www.jsdocs.io/package/@types/ali-oss"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>