@types/ali-oss

  • Version 6.16.7
  • Published
  • 42.4 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 asyncSignatureUrl

      asyncSignatureUrl: (
      name: string,
      options?: SignatureUrlOptions
      ) => Promise<string>;

        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 asyncSignatureUrl

                                      asyncSignatureUrl: (
                                      name: string,
                                      options?: SignatureUrlOptions
                                      ) => Promise<string>;
                                      • Basically the same as signatureUrl, if refreshSTSToken is configured asyncSignatureUrl will refresh stsToken

                                      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 asyncSignatureUrl

                                          asyncSignatureUrl: (
                                          name: string,
                                          options?: OSS.SignatureUrlOptions
                                          ) => Promise<string>;
                                          • Basically the same as signatureUrl, if refreshSTSToken is configured asyncSignatureUrl will refresh stsToken

                                          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>;
                                          (
                                          name: string,
                                          sourceName: string,
                                          sourceBucket?: 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 listV2

                                          listV2: (
                                          query: OSS.ListV2ObjectsQuery | null,
                                          options: OSS.RequestOptions
                                          ) => Promise<OSS.ListObjectResult>;
                                          • List Objects in the bucket.(V2)

                                          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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • set the callback for the operation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • image process params, will send with x-oss-process e.g.: {process: 'image/resize,w_200'}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property response

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property subResource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      subResource?: object | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • additional signature parameters in url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property trafficLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      trafficLimit?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • traffic limit, range: 819200~838860800

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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>