jkjoy
/
hexo
mirror of https://github.com/jkjoy/sunpeiwen.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
hexo/node_modules/cos-nodejs-sdk-v5/index.d.ts

2586 lines
132 KiB
TypeScript
Raw Normal View History

20231003 update
2023-10-03 11:14:36 +08:00
/**
* 腾讯云 COS Node.js SDK 类型声明
*/
import { Stream } from 'stream';
/**
* 定义 COS 命名空间，方便导出用到的变量类型给外部引用
*/
declare namespace COS {
/** 存储桶的名称，命名规则为 BucketName-APPID，例如 examplebucket-1250000000 */
type Bucket = string;
/** 存储桶所在地域 @see https://cloud.tencent.com/document/product/436/6224 */
type Region = string;
/** 请求的对象键，最前面不带 /，例如 images/1.jpg */
type Key = string;
/** 请求路径，最前面带 /，例如 /images/1.jpg */
type Pathname = string;
/** 对象的版本 ID；当未启用版本控制时，该节点的值为空字符串；当启用版本控制时，启用版本控制之前的对象，其版本 ID 为 null；当暂停版本控制时，新上传的对象其版本 ID 为 null，且同一个对象最多只存在一个版本 ID 为 null 的对象版本 */
type VersionId = string;
/** 前缀匹配，用来规定返回的文件前缀地址 */
type Prefix = string;
/** 分块上传的任务 ID */
type UploadId = string;
/** 标识本次分块上传的编号，范围在1 - 10000 */
type PartNumber = number;
/** 创建的存储桶访问地址，不带 https:// 前缀，例如 examplebucket-1250000000.cos.ap-guangzhou.myqcloud.com/images/1.jpg */
type Location = string;
/** 对象的实体标签（Entity Tag），是对象被创建时标识对象内容的信息标签，可用于检查对象的内容是否发生变化，例如"8e0b617ca298a564c3331da28dcb50df"。此头部并不一定返回对象的 MD5 值，而是根据对象上传和加密方式而有所不同 */
type ETag = string;
/** COS API 使用的时间字符串，为 ISO8601 格式，例如2019-05-24T10:56:40Z */
type IsoDateTime = string;
/** 请求里的 Url Query 参数 */
type Query = Record<string, any>;
/** 请求里的 Header 参数 */
type Headers = Record<string, any>;
/** 请求里的 URL 中对象存储 API 接口名，如 acl、tagging 等 */
type Action = string;
/** 一个字符的分隔符，常用 / 字符，用于对对象键进行分组。所有对象键中从 prefix 或从头（如未指定 prefix）到首个 delimiter 之间相同的部分将作为 CommonPrefixes 下的一个 Prefix 节点。被分组的对象键不再出现在后续对象列表中 */
type Delimiter = '/' | string;
/** 规定返回值的编码方式，可选值：url，代表返回的对象键为 URL 编码（百分号编码）后的值，例如“腾讯云”将被编码为%E8%85%BE%E8%AE%AF%E4%BA%91 */
type EncodingType = 'url' | string;
/** 上传的文件内容 */
type UploadBody = Buffer | String | Stream;
/** 对象存储类型。枚举值 STANDARD | STANDARD_IA | ARCHIVE | DEEP_ARCHIVE | INTELLIGENT_TIERING | MAZ_STANDARD | MAZ_STANDARD_IA | MAZ_INTELLIGENT_TIERING @see https://cloud.tencent.com/document/product/436/33417 */
type StorageClass =
| 'STANDARD'
| 'STANDARD_IA'
| 'ARCHIVE'
| 'DEEP_ARCHIVE'
| 'INTELLIGENT_TIERING'
| 'MAZ_STANDARD'
| 'MAZ_STANDARD_IA'
| 'MAZ_INTELLIGENT_TIERING';
/** 请求方法 */
type Method = 'GET' | 'DELETE' | 'POST' | 'PUT' | 'OPTIONS' | 'get' | 'delete' | 'post' | 'put' | 'options';
/** 权限信息，枚举值：READ | WRITE | READ_ACP | WRITE_ACP | FULL_CONTROL 腾讯云对象存储 COS 在资源 ACL 上支持的操作实际上是一系列的操作集合，对于存储桶和对象 ACL 来说分别代表不同的含义。 */
type Permission = 'READ' | 'WRITE' | 'READ_ACP' | 'WRITE_ACP' | 'FULL_CONTROL';
/** 存储桶的预设 ACL @see https://cloud.tencent.com/document/product/436/30752#.E9.A2.84.E8.AE.BE.E7.9A.84-acl */
type BucketACL = 'private' | 'public-read' | 'public-read-write' | 'authenticated-read';
/** 对象的预设 ACL @see https://cloud.tencent.com/document/product/436/30752#.E9.A2.84.E8.AE.BE.E7.9A.84-acl */
type ObjectACL =
| 'default'
| 'private'
| 'public-read'
| 'authenticated-read'
| 'bucket-owner-read'
| 'bucket-owner-full-control';
/** 二进制值的字符串，'true' | 'false' */
type BooleanString = 'true' | 'false';
/** 所有者的信息 */
type Owner = {
/** 存储桶持有者的完整 ID，格式为 qcs::cam::uin/[OwnerUin]:uin/[OwnerUin]，如 qcs::cam::uin/100000000001:uin/100000000001 */
ID: string;
};
/** 所有者的信息 */
type GroupOwner = {
/** 预设用户组，格式为 http://cam.qcloud.com/groups/global/AllUsers (匿名用户组) 或 http://cam.qcloud.com/groups/global/AuthenticatedUsers (认证用户组) 。参见 {@link https://cloud.tencent.com/document/product/436/30752#.E8.BA.AB.E4.BB.BD-grantee| ACL 概述} */
URI: string;
};
/** 上传发起者的信息 */
type Initiator = Owner;
/** 单个授权信息 */
type Grant = string;
/** 被授权者信息与权限信息 */
interface Grants {
/** 所有者的信息 */
Grantee: Owner | GroupOwner;
/** 权限信息，枚举值：READ | WRITE | READ_ACP | WRITE_ACP | FULL_CONTROL 腾讯云对象存储 COS 在资源 ACL 上支持的操作实际上是一系列的操作集合，对于存储桶和对象 ACL 来说分别代表不同的含义。 */
Permission: Permission;
}
/** 存储桶/对象标签信息 */
interface Tag {
/** 标签的 Key，长度不超过128字节, 支持英文字母、数字、空格、加号、减号、下划线、等号、点号、冒号、斜线 */
Key: Key;
/** 标签的 Value，长度不超过256字节, 支持英文字母、数字、空格、加号、减号、下划线、等号、点号、冒号、斜线 */
Value: string;
}
/** 用来说明本次分块上传中每个块的信息 */
interface Part {
/** 标识本次分块上传的编号，范围在1 - 10000 */
PartNumber: PartNumber;
/** 使用 Upload Part 请求上传分块成功后返回的 ETag 响应头部的值 */
ETag: ETag;
}
/** 当前需要用凭证的请求，需要的最小权限 */
type Scope = {
/** 需要的权限 */
action: string;
/** 操作的存储桶的名称，命名规则为 BucketName-APPID，例如 examplebucket-1250000000 */
bucket: Bucket;
/** 存储桶所在地域 @see https://cloud.tencent.com/document/product/436/6224 */
region: Region;
/** 前缀匹配，用来规定返回的文件前缀地址，支持 * 结尾 */
prefix: Prefix;
}[];
/** onProgress 回调的进度信息 */
interface ProgressInfo {
/** 已上传/下载的字节数，单位 B（字节） */
loaded: number;
/** 要上传/下载的文件的大小，单位 B（字节） */
total: number;
/** 速度，单位 B/s */
speed: number;
/** 进度百分比，范围是 0-1，保留两位小数 */
percent: number;
}
/** 上传/下载的进度回调方法 */
type onProgress = (params: ProgressInfo) => any;
// 实例参数
interface COSOptions {
/** 固定密钥的 SecretId，可从{@link https://console.cloud.tencent.com/cam/capi|API密钥管理}获取 */
SecretId?: string;
/** 固定密钥的 SecretKey，可从{@link https://console.cloud.tencent.com/cam/capi|API密钥管理}获取 */
SecretKey?: string;
/** 如果传入 SecretId、SecretKey 是临时密钥，需要再传入一个临时密钥的 sessionToken */
SecurityToken?: string;
/** 同 SecurityToken，推荐用 SecurityToken */
XCosSecurityToken?: string;
/** 分块上传及分块复制时，出错重试次数，默认值3（加第一次，请求共4次） */
ChunkRetryTimes?: number;
/** 同一个实例下上传的文件并发数，默认值3 */
FileParallelLimit?: number;
/** 同一个上传文件的分块并发数，默认值3 */
ChunkParallelLimit?: number;
/** 分块上传时，每片的字节数大小，默认值1048576（1MB） */
ChunkSize?: number;
/** 使用 uploadFiles 批量上传时，文件大小大于该数值将使用按分块上传，否则将调用简单上传，单位 Byte，默认值1048576（1MB） */
SliceSize?: number;
/** 进行分块复制操作中复制分块上传的并发数，默认值20 */
CopyChunkParallelLimit?: number;
/** 使用 sliceCopyFile 分块复制文件时，每片的大小字节数，默认值10485760（10MB） */
CopyChunkSize?: number;
/** 使用 sliceCopyFile 分块复制文件时，文件大小大于该数值将使用分块复制 ，否则将调用简单复制，默认值10485760（10MB） */
CopySliceSize?: number;
/** 最大分片数，默认 1000，最大 10000，分片上传超大文件时，会根据文件大小和该最大分片数计算合适的的分片大小 */
MaxPartNumber?: number;
/** 上传进度的回调方法 onProgress 的回调频率，单位 ms ，默认值1000 */
ProgressInterval?: number;
/** 上传队列最长大小，超出的任务如果状态不是 waiting、checking、uploading 会被清理，默认10000 */
UploadQueueSize?: number;
/** 调用操作存储桶和对象的 API 时自定义请求域名。可以使用模板，如"{Bucket}.cos.{Region}.myqcloud.com"，即在调用 API 时会使用参数中传入的 Bucket 和 Region 进行替换。 */
Domain?: string;
/** getService方法可以使用的自定义域名 */
ServiceDomain?: string;
/** 强制使用后缀式模式发请求。后缀式模式中 Bucket 会放在域名后的 pathname 里，并且 Bucket 会加入签名 pathname 计算，默认 false */
Protocol?: string;
/** 设置代理，格式如 http://127.0.0.1:8888 */
Proxy?: string;
/** 透传给request */
Tunnel?: boolean;
/** 开启兼容模式，默认 false 不开启，兼容模式下不校验 Region 是否格式有误，在用于私有化 COS 时使用 */
CompatibilityMode?: boolean;
/** 强制使用后缀式模式发请求。后缀式模式中 Bucket 会放在域名后的 pathname 里，并且 Bucket 会加入签名 pathname 计算，默认 false */
ForcePathStyle?: boolean;
/** 是否原样保留 Key 字段的 / 前缀，默认 false 不保留，这时如果 Key 是 / 开头，强制去掉第一个 / */
UseRawKey?: boolean;
/** 请求超时时间，单位 ms(毫秒)，透传给 request 或 ajax 或小程序请求库 */
Timeout?: number;
/** 客户端时间是否不准确，默认 false，在第一次请求 COS API 返回时会判断是否偏差大于 30s，如果是会把该值设置为 true，开发者也可以预先判断并设置该参数 */
CorrectClockSkew?: boolean;
/** 校正时间的偏移值，单位 ms(毫秒)，计算签名时会用设备当前时间戳加上该偏移值，在设备时间有误时可用于校正签名用的时间参数，在第一次请求 COS API 返回时会判断是否偏差大于 30s，如果是会把该值设置为 true，开发者也可以预先判断并设置该参数。 */
SystemClockOffset?: number;
/** 上传文件时校验 Content-MD5，默认 false。如果开启，上传文件时会对文件内容计算 MD5，大文件耗时较长 */
UploadCheckContentMd5?: boolean;
/** 上传文件时计算文件内容 md5 并设置为文件 x-cos-meta-md5 元数据 Header 字段 */
UploadAddMetaMd5?: boolean;
/** 分片上传缓存的 UploadId 列表大小限制，nodejs-sdk 默认 500 个，js-sdk、小程序 SDK 默认 50 */
UploadIdCacheLimit?: number;
/** 分片上传缓存的 UploadId 列表时，保存的本地缓存文件目录路径，nodejs-sdk 默认 500 个，js-sdk 默认 50 */
ConfCwd?: string;
/** 301/302 回源跟随配置。 */
FollowRedirect?: boolean;
/** 是否使用全球加速域名。开启该配置后仅以下接口支持操作：putObject、getObject、headObject、optionsObject、multipartInit、multipartListPart、multipartUpload、multipartAbort、multipartComplete、multipartList、sliceUploadFile、uploadFiles */
UseAccelerate?: boolean;
/** 是否开启长链接，默认开启 */
KeepAlive?: boolean;
Ip?: string;
/** 默认将host加入签名计算，关闭后可能导致越权风险，建议保持为true */
ForceSignHost?: boolean;
/** 获取签名的回调方法，如果没有 SecretId、SecretKey 时，必选 */
getAuthorization?: (
options: GetAuthorizationOptions,
/** callback 获取完签名或临时密钥后，回传给 SDK 的方法 */
callback: (
/** params 回传给 SDK 的签名或获取临时密钥 */
params: GetAuthorizationCallbackParams,
) => void,
) => void;
/** 支持动态Credentials */
Credentials?: {
secretId?: string;
secretKey?: string;
};
}
type StringOrBuffer = Buffer | String;
interface Util {
md5: (str: StringOrBuffer, encoding?: string) => string;
xml2json: (bodyStr: string) => any;
json2xml: (json: any) => string;
encodeBase64: (str: string, safe?: boolean) => string;
}
interface StaticGetAuthorizationOptions {
/** 计算签名用的密钥 SecretId，必选 */
SecretId: string;
/** 计算签名用的密钥 SecretKey，必选 */
SecretKey: string;
/** 请求的存储桶，如果传入了 Bucket、Region，签名会默认加上 Host 字段，可选 */
Bucket?: Bucket;
/** 请求的地域，如果传入了 Bucket、Region，签名会默认加上 Host 字段，可选 */
Region?: Region;
/** 请求方法，可选 */
Method?: Method;
/** 请求路径，最前面带 /，例如 /images/1.jpg，可选 */
Pathname?: Pathname;
/** 请求的对象键，最前面不带 /，例如 images/1.jpg，可选 */
Key?: Key;
/** 要参与签名计算的 Url Query 参数，可选 */
Query?: Query;
/** 要参与签名计算的 Header 参数，可选 */
Headers?: Headers;
/** 签名几秒后失效，默认为900秒，如果传入了 KeyTime，以 KeyTime 为准，可选 */
Expires?: number;
/** 签名有效时间戳区间，如果传入了该参数，会赋值给在签名里的 q-key-time 和 q-sign-time 字段，格式如：1611915436;1611916336 */
KeyTime?: string;
/** 校正时间的偏移值，单位 ms(毫秒)，计算签名时会用设备当前时间戳加上该偏移值，在设备时间有误时可用于校正签名用的时间参数。 */
SystemClockOffset?: number;
}
/** 计算签名或获取临时密钥可能需要的参数列表 */
interface GetAuthorizationOptions {
/** 存储桶的名称，格式为<bucketname-appid>，例如examplebucket-1250000000 */
Bucket: Bucket;
/** 存储桶所在地域 @see https://cloud.tencent.com/document/product/436/6224 */
Region: Region;
/** 请求方法 */
Method: Method;
/** 请求路径，最前面带 /，例如 /images/1.jpg，Pathname 和 Key 二选一 */
Pathname: Pathname;
/** 请求的对象键，最前面不带 /，例如 images/1.jpg，如果是存储桶接口，传入空字符串，Key 和 Pathname 二选一，推荐使用 Pathname 参数 */
Key: Key;
/** 请求里的 Url Query 参数，可选 */
Query: Query;
/** 请求里的 Header 参数，可选 */
Headers: Headers;
/** 当前需要用凭证的请求，需要的最小权限 */
Scope: Scope;
/** 校正时间的偏移值，单位 ms(毫秒)，计算签名时会用设备当前时间戳加上该偏移值，在设备时间有误时可用于校正签名用的时间参数。 */
SystemClockOffset: number;
}
/** 请求凭证，包含临时密钥信息 */
interface Credentials {
/** 临时密钥 tmpSecretId */
TmpSecretId: string;
/** 临时密钥 tmpSecretKey */
TmpSecretKey: string;
/** 临时密钥 sessonToken */
SecurityToken?: string;
/** 同 SecurityToken，推荐用 SecurityToken */
XCosSecurityToken?: string;
/** 获取临时密钥时，服务端的时间，该时间用于计算签名，可以避免设备时间有偏差导致请求错误 */
StartTime: number;
/** 获取临时密钥的过期时间戳 */
ExpiredTime: number;
/** 该临时密钥是否仅用于相同 Scope 权限范围的请求 */
ScopeLimit?: boolean;
/** 签名 */
Authorization?: string;
}
/** 用于发请求的签名字符串，会放在请求 Header 里的 Authorization 字段 */
type Authorization = string;
/** SDK 用于请求的凭证，可以是签名，也可以是临时密钥信息 */
type GetAuthorizationCallbackParams = Authorization | Credentials;
/** 一般接口的返回结果 */
interface GeneralResult {
/** 请求返回的 HTTP 状态码 */
statusCode?: number;
/** 请求返回的 header 字段 */
headers?: Headers;
/** 请求的唯一标识 */
RequestId?: string;
}
/** SDK 的错误格式，其中服务端返回错误码可查看 @see https://cloud.tencent.com/document/product/436/7730 */
interface CosSdkError extends GeneralResult {
/** 错误码 */
code: string;
/** 错误信息 */
message: string;
/** 兼容老的错误信息字段，不建议使用，可能是参数错误、客户端出错、或服务端返回的错误 */
error: string | Error | { Code: string; Message: string };
}
/** 回调的错误格式，其中服务端返回错误码可查看 @see https://cloud.tencent.com/document/product/436/7730 */
type CosError = null | CosSdkError;
/** 存储桶操作接口的公共参数 */
interface BucketParams {
/** 存储桶的名称，格式为<bucketname-appid>，例如examplebucket-1250000000 */
Bucket: Bucket;
/** 存储桶所在地域 @see https://cloud.tencent.com/document/product/436/6224 */
Region: Region;
/** 请求时带上的 Header 字段 */
Headers?: Headers;
}
/** 对象操作接口的公共参数 */
interface ObjectParams {
/** 存储桶的名称，格式为<bucketname-appid>，例如examplebucket-1250000000 */
Bucket: Bucket;
/** 存储桶所在地域，如果有传入只返回该地域的存储桶列表 */
Region: Region;
/** 请求的对象键，最前面不带 / */
Key: Key;
/** 发请求时带上的 Header 字段 */
Headers?: Headers;
}
// 所有接口的入参和出参
// getService
interface GetServiceParams {
/** 存储桶所在地域，如果传入只返回该地域的存储桶 */
Region?: Region;
/** 发请求时带上的 Header 字段 */
Headers?: Headers;
}
/** getService 接口返回值 */
interface GetServiceResult extends GeneralResult {
Buckets: {
/** 存储桶的名称，格式为<bucketname-appid>，例如examplebucket-1250000000 */
Name: Bucket;
/** 存储桶所在地域 */
Location: Region;
/** 存储桶创建时间 */
CreationDate: IsoDateTime;
}[];
/** 所有者的信息 */
Owner: Owner;
}
// putBucket
/** putBucket 接口参数 */
interface PutBucketParams extends BucketParams {
/** 允许用户自定义存储桶权限，有效值：private | public-read | public-read-write，可选 */
ACL?: BucketACL;
/** 赋予被授权者读取对象的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantRead?: Grant;
/** 赋予被授权者写取对象的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantWrite?: Grant;
/** 赋予被授权者读取对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantReadAcp?: Grant;
/** 赋予被授权者写入对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantWriteAcp?: Grant;
/** 赋予被授权者操作对象的所有权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantFullControl?: Grant;
/** 要创建存储桶的AZ类型，创建多AZ存储桶，传入 'MAZ' */
BucketAZConfig?: 'MAZ' | string;
/** 如果创建索引多活存储桶，传入 'OFS' */
BucketArchConfig?: 'OFS' | string;
}
/** putBucket 接口返回值 */
interface PutBucketResult extends GeneralResult {
/** 创建的存储桶访问地址，不带 https:// 前缀，例如 examplebucket-1250000000.cos.ap-guangzhou.myqcloud.com/ */
Location: Location;
}
// headBucket
/** headBucket 接口参数 */
interface HeadBucketParams extends BucketParams {}
/** headBucket 接口返回值 */
interface HeadBucketResult extends GeneralResult {}
// getBucket
/** getBucket 接口参数 */
interface GetBucketParams extends BucketParams {
/** 前缀匹配，用来规定返回的文件前缀地址，可选 */
Prefix?: Prefix;
/** 一个字符的分隔符，常用 / 字符，用于对对象键进行分组。所有对象键中从 prefix 或从头（如未指定 prefix）到首个 delimiter 之间相同的部分将作为 CommonPrefixes 下的一个 Prefix 节点。被分组的对象键不再出现在后续对象列表中，可选 */
Delimiter?: Delimiter;
/** 默认以UTF-8二进制顺序列出条目，所有列出条目从marker开始，可选 */
Marker?: Key;
/** 单次返回最大的条目数量，默认值为1000，最大为1000，注意：该参数会限制每一次 List 操作返回的最大条目数，COS 在每次 List 操作中将返回不超过 max-keys 所设定数值的条目（即 CommonPrefixes 和 Contents 的总和），如果单次响应中未列出所有对象，COS 会返回 NextMarker 节点，其值作为您下次 List 请求的 marker 参数，以便您列出后续对象，可选 */
MaxKeys?: number;
/** 规定返回值的编码方式，可选值：url，代表返回的对象键为 URL 编码（百分号编码）后的值，例如“腾讯云”将被编码为%E8%85%BE%E8%AE%AF%E4%BA%91 */
EncodingType?: EncodingType;
}
/** 对象信息 */
interface CosObject {
/** 对象键 */
Key: Key;
/** 当前版本的最后修改时间，为 ISO8601 格式，例如2019-05-24T10:56:40Z */
LastModified: IsoDateTime;
/** 对象的实体标签（Entity Tag），是对象被创建时标识对象内容的信息标签，可用于检查对象的内容是否发生变化，例如“8e0b617ca298a564c3331da28dcb50df”，此头部并不一定返回对象的 MD5 值，而是根据对象上传和加密方式而有所不同 */
ETag: ETag;
/** 对象大小，单位为 Byte */
Size: string;
/** 对象存储类型。枚举值 STANDARD | STANDARD_IA | ARCHIVE | DEEP_ARCHIVE | INTELLIGENT_TIERING | MAZ_STANDARD | MAZ_STANDARD_IA | MAZ_INTELLIGENT_TIERING @see https://cloud.tencent.com/document/product/436/33417 */
StorageClass: StorageClass;
/** 当对象存储类型为智能分层存储时，指示对象当前所处的存储层，枚举值：FREQUENT（标准层），INFREQUENT（低频层）。仅当 StorageClass 为 INTELLIGENT_TIERING（智能分层）时才会返回该节点 */
StorageTier?: string;
/** 对象持有者信息 */
Owner: Owner;
}
/** getBucket 接口返回值 */
interface GetBucketResult extends GeneralResult {
/** 对象条目 */
Contents: CosObject[];
/** 从 prefix 或从头（如未指定 prefix）到首个 delimiter 之间相同的部分，定义为 Common Prefix。仅当请求中指定了 delimiter 参数才有可能返回该节点 */
CommonPrefixes: {
/** 前缀匹配，用来规定返回的文件前缀地址 */
Prefix: Prefix;
}[];
/** 响应条目是否被截断，布尔值，例如 true 或 false，可用于判断是否还需要继续列出文件 */
IsTruncated: BooleanString;
/** 仅当响应条目有截断（IsTruncated 为 true）才会返回该节点，该节点的值为当前响应条目中的最后一个对象键，当需要继续请求后续条目时，将该节点的值作为下一次请求的 marker 参数传入 */
NextMarker?: string;
}
// listObjectVersions
/** listObjectVersions 接口参数 */
interface ListObjectVersionsParams extends BucketParams {
/** 前缀匹配，用来规定返回的文件前缀地址，可选 */
Prefix?: Prefix;
/** 一个字符的分隔符，常用 / 字符，用于对对象键进行分组。所有对象键中从 prefix 或从头（如未指定 prefix）到首个 delimiter 之间相同的部分将作为 CommonPrefixes 下的一个 Prefix 节点。被分组的对象键不再出现在后续对象列表中，可选 */
Delimiter?: Delimiter;
/** 默认以UTF-8二进制顺序列出条目，所有列出条目从marker开始，可选 */
Marker?: string;
/** 单次返回最大的条目数量，默认值为1000，最大为1000，注意：该参数会限制每一次 List 操作返回的最大条目数，COS 在每次 List 操作中将返回不超过 max-keys 所设定数值的条目（即 CommonPrefixes 和 Contents 的总和），如果单次响应中未列出所有对象，COS 会返回 NextMarker 节点，其值作为您下次 List 请求的 marker 参数，以便您列出后续对象，可选 */
MaxKeys?: string;
/** 起始版本 ID 标记，从该标记之后（不含）返回对象版本条目，对应请求中的 url 参数 version-id-marker */
VersionIdMarker?: string;
/** 规定返回值的编码方式，可选值：url，代表返回的对象键为 URL 编码（百分号编码）后的值，例如“腾讯云”将被编码为%E8%85%BE%E8%AE%AF%E4%BA%91 */
EncodingType?: EncodingType;
}
/** 对象删除标记条目 */
interface DeleteMarker {
/** 对象键 */
Key: Key;
/** 对象的版本 ID；当未启用版本控制时，该节点的值为空字符串；当启用版本控制时，启用版本控制之前的对象，其版本 ID 为 null；当暂停版本控制时，新上传的对象其版本 ID 为 null，且同一个对象最多只存在一个版本 ID 为 null 的对象版本 */
VersionId: VersionId;
/** 当前版本是否为该对象的最新版本 */
IsLatest: string;
/** 当前版本的最后修改时间，为 ISO8601 格式，例如2019-05-24T10:56:40Z */
LastModified: IsoDateTime;
Owner: Owner;
}
interface ObjectVersion {
/** 对象键 */
Key: Key;
/** 对象的删除标记的版本 ID */
VersionId: VersionId;
/** 当前版本是否为该对象的最新版本 */
IsLatest: BooleanString;
/** 当前版本的最后修改时间，为 ISO8601 格式，例如2019-05-24T10:56:40Z */
LastModified: IsoDateTime;
/** 对象的实体标签（Entity Tag），是对象被创建时标识对象内容的信息标签，可用于检查对象的内容是否发生变化，例如"8e0b617ca298a564c3331da28dcb50df"。此头部并不一定返回对象的 MD5 值，而是根据对象上传和加密方式而有所不同 */
ETag: ETag;
/** 对象大小，单位为 Byte */
Size: string;
/** 对象大小，单位为 Byte */
Owner: Owner;
/** 对象存储类型。枚举值 STANDARD | STANDARD_IA | ARCHIVE | DEEP_ARCHIVE | INTELLIGENT_TIERING | MAZ_STANDARD | MAZ_STANDARD_IA | MAZ_INTELLIGENT_TIERING @see https://cloud.tencent.com/document/product/436/33417 */
StorageClass: StorageClass;
/** 当对象存储类型为智能分层存储时，指示对象当前所处的存储层，枚举值：FREQUENT（标准层），INFREQUENT（低频层）。仅当 StorageClass 为 INTELLIGENT_TIERING（智能分层）时才会返回该节点 */
StorageTier?: string;
}
/** listObjectVersions 接口返回值 */
interface ListObjectVersionsResult extends GeneralResult {
/** 从 prefix 或从头（如未指定 prefix）到首个 delimiter 之间相同的部分，定义为 Common Prefix。仅当请求中指定了 delimiter 参数才有可能返回该节点 */
CommonPrefixes: {
/** 前缀匹配，用来规定返回的文件前缀地址 */
Prefix: Prefix;
}[];
/** 对象版本条目 */
Versions: ObjectVersion[];
/** 对象删除标记条目 */
DeleteMarkers: DeleteMarker[];
/** 响应条目是否被截断，布尔值，例如 true 或 false，可用于判断是否还需要继续列出文件 */
IsTruncated: BooleanString;
/** 仅当响应条目有截断（IsTruncated 为 true）才会返回该节点，该节点的值为当前响应条目中的最后一个对象键，当需要继续请求后续条目时，将该节点的值作为下一次请求的 marker 参数传入 */
NextMarker?: string;
/** 仅当响应条目有截断（IsTruncated 为 true）才会返回该节点，该节点的值为当前响应条目中的最后一个对象的版本 ID，当需要继续请求后续条目时，将该节点的值作为下一次请求的 version-id-marker 参数传入。该节点的值可能为空，此时下一次请求的 version-id-marker 参数也需要指定为空。 */
NextVersionIdMarker?: string;
}
// deleteBucket
/** deleteBucket 接口参数 */
interface DeleteBucketParams extends BucketParams {}
/** deleteBucket 接口返回值 */
interface DeleteBucketResult extends GeneralResult {}
// putBucketAcl
/** putBucketAcl 接口参数 */
interface PutBucketAclParams extends BucketParams {
/** 允许用户自定义存储桶权限，有效值：private | public-read | public-read-write，可选 */
ACL?: BucketACL;
/** 赋予被授权者读取对象的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantRead?: Grant;
/** 赋予被授权者写取对象的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantWrite?: Grant;
/** 赋予被授权者读取对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantReadAcp?: Grant;
/** 赋予被授权者写入对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantWriteAcp?: Grant;
/** 赋予被授权者操作对象的所有权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantFullControl?: Grant;
/** 放在 XML Body 的授权参数 */
AccessControlPolicy?: {
/** 所有者的信息 */
Owner: Owner;
/** 被授权者信息与权限信息 */
Grants: Grants[];
};
}
/** putBucketAcl 接口返回值 */
interface PutBucketAclResult extends GeneralResult {}
// getBucketAcl
/** getBucketAcl 接口参数 */
interface GetBucketAclParams extends BucketParams {}
/** getBucketAcl 接口返回值 */
interface GetBucketAclResult extends GeneralResult {
/** 允许用户自定义存储桶权限，有效值：private | public-read | public-read-write */
ACL: BucketACL;
/** 赋予被授权者读取对象的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者 */
GrantRead: Grant;
/** 赋予被授权者写取对象的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者 */
GrantWrite: Grant;
/** 赋予被授权者读取对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者 */
GrantReadAcp: Grant;
/** 赋予被授权者写入对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者 */
GrantWriteAcp: Grant;
/** 赋予被授权者操作对象的所有权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者 */
GrantFullControl: Grant;
/** 存储桶持有者信息 */
Owner: Owner;
/** 被授权者信息与权限信息 */
Grants: Grants[];
}
// putBucketCors
type CORSRule = {
/** 允许的访问来源，单条 CORSRule 可以配置多个 AllowedOrigin。
配置支持 *，表示全部域名都允许，但不推荐。
支持单个具体域名，例如 http://www.example.com。
支持 * 通配符，通配符可出现在任何位置，包括协议、域名和端口，可匹配0个或多个字符，但是只能有一个 *。请谨慎使用通配符，因为可能意外匹配到非预期的来源
注意不要遗漏协议名 http 或 https，若端口不是默认的80(http)或443(https)，还需要带上端口，例如 https://example.com:8443。 */
AllowedOrigin: string[];
/** 允许的 HTTP 操作方法（Method），对应 CORS 请求响应中的 Access-Control-Allow-Methods 头部，单条 CORSRule 可以配置多个 AllowedMethod。枚举值：PUT、GET、POST、DELETE、HEAD。 */
AllowedMethod: string[];
/** 在发送预检（OPTIONS）请求时，浏览器会告知服务端接下来的正式请求将使用的自定义 HTTP 请求头部，此配置用于指定允许浏览器发送 CORS 请求时携带的自定义 HTTP 请求头部，不区分英文大小写，单条 CORSRule 可以配置多个 AllowedHeader。
可以配置*，代表允许所有头部，为了避免遗漏，推荐配置为*。
如果不配置为*，那么在预检（OPTIONS）请求中 Access-Control-Request-Headers 头部出现的每个 Header，都必须在 AllowedHeader 中有对应项。 */
AllowedHeader?: string[];
/** 允许浏览器获取的 CORS 请求响应中的头部，不区分大小写，单条 CORSRule 可以配置多个 ExposeHeader。
默认情况下浏览器只能访问简单响应头部：Cache-Control、Content-Type、Expires、Last-Modified，如果需要访问其他响应头部，需要添加 ExposeHeader 配置。
不支持配置为 *，必须明确配置具体的 Header。
根据浏览器的实际需求确定，默认推荐填写 ETag，可参考各 API 文档的响应头部分及 公共响应头部 文档。@see https://cloud.tencent.com/document/product/436/7729 */
ExposeHeader?: string[];
/** 跨域资源共享配置的有效时间，单位为秒，在有效时间内，浏览器无须为同一请求再次发起预检（OPTIONS）请求，对应 CORS 请求响应中的 Access-Control-Max-Age 头部，单条 CORSRule 只能配置一个 MaxAgeSeconds。 */
MaxAgeSeconds?: number;
};
/** putBucketCors 接口参数 */
interface PutBucketCorsParams extends BucketParams {
/** 存储桶跨域资源共享（CORS）访问控制规则 */
CORSRules: CORSRule[];
/** 是否允许同一个 url 有多份缓存，如果设置为 true 浏览器在 img 标签加载和 ajax 加载同一个对象 url 将会使用不同缓存 */
ResponseVary?: BooleanString;
}
/** putBucketCors 接口返回值 */
interface PutBucketCorsResult extends GeneralResult {}
// getBucketCors
/** getBucketCors 接口参数 */
interface GetBucketCorsParams extends BucketParams {}
/** getBucketCors 接口返回值 */
interface GetBucketCorsResult extends GeneralResult {
/** 存储桶跨域资源共享（CORS）访问控制规则 */
CORSRules: Record<string, any>;
/** 是否允许同一个 url 有多份缓存，如果设置为 true 浏览器在 img 标签加载和 ajax 加载同一个对象 url 将会使用不同缓存 */
ResponseVary?: BooleanString;
}
// deleteBucketCors
/** deleteBucketCors 接口参数 */
interface DeleteBucketCorsParams extends BucketParams {}
/** deleteBucketCors 接口返回值 */
interface DeleteBucketCorsResult extends GeneralResult {}
// getBucketLocation
interface GetBucketLocationResult {
/** 存储桶所在地域 */
LocationConstraint: Region;
}
/** getBucketLocation 接口参数 */
interface GetBucketLocationParams extends BucketParams {}
// putBucketPolicy
/** putBucketPolicy 接口参数 */
interface PutBucketPolicyParams extends BucketParams {
/** 存储桶的权限策略 @see https://cloud.tencent.com/document/product/436/31923 */
Policy: Record<string, any>;
}
/** putBucketPolicy 接口返回值 */
interface PutBucketPolicyResult extends GeneralResult {}
// getBucketPolicy
/** getBucketPolicy 接口参数 */
interface GetBucketPolicyParams extends BucketParams {}
/** getBucketPolicy 接口返回值 */
interface GetBucketPolicyResult extends GeneralResult {
/** 存储桶的权限策略 @see https://cloud.tencent.com/document/product/436/31923 */
Policy: Record<string, any>;
}
// deleteBucketPolicy
/** deleteBucketPolicy 接口参数 */
interface DeleteBucketPolicyParams extends BucketParams {}
/** deleteBucketPolicy 接口返回值 */
interface DeleteBucketPolicyResult extends GeneralResult {}
// putBucketTagging
/** putBucketTagging 接口参数 */
interface PutBucketTaggingParams extends BucketParams {
/** 标签集合，最多支持10个标签 */
Tags: Tag[];
}
/** putBucketTagging 接口返回值 */
interface PutBucketTaggingResult extends GeneralResult {}
// getBucketTagging
/** getBucketTagging 接口参数 */
interface GetBucketTaggingParams extends BucketParams {}
/** getBucketTagging 接口返回值 */
interface GetBucketTaggingResult extends GeneralResult {
/** 标签集合，最多支持10个标签 */
Tags: Tag[];
}
// deleteBucketTagging
/** deleteBucketTagging 接口参数 */
interface DeleteBucketTaggingParams extends BucketParams {}
/** deleteBucketTagging 接口返回值 */
interface DeleteBucketTaggingResult extends GeneralResult {}
// putBucketLifecycle
/** 生命周期配置规则 */
type LifecycleRule = {
/** 用于唯一地标识规则，长度不能超过255个字符，可选 */
ID: string;
/** 指明规则是否启用，枚举值：Enabled，Disabled，必选 */
Status: 'Enabled' | 'Disabled';
/** Filter 用于描述规则影响的 Object 集合，必选 */
Filter?: Record<string, any>;
/** 规则转换属性，对象何时转换为 Standard_IA 或 Archive 等存储类型 */
Transition?: Record<string, any>;
/** 规则过期属性 */
Expiration?: Record<string, any>;
/** 设置允许分片上传保持运行的最长时间 */
AbortIncompleteMultipartUpload?: Record<string, any>;
/** 指明非当前版本对象何时过期 */
NoncurrentVersionExpiration?: Record<string, any>;
/** 指明非当前版本对象何时转换为 STANDARD_IA 或 ARCHIVE 等存储类型 */
NoncurrentVersionTransition?: Record<string, any>;
};
/** putBucketLifecycle 接口参数 */
interface PutBucketLifecycleParams extends BucketParams {
/** 生命周期配置规则列表 */
Rules: LifecycleRule[];
}
/** putBucketLifecycle 接口返回值 */
interface PutBucketLifecycleResult extends GeneralResult {}
// getBucketLifecycle
/** getBucketLifecycle 接口参数 */
interface GetBucketLifecycleParams extends BucketParams {}
/** getBucketLifecycle 接口返回值 */
interface GetBucketLifecycleResult extends GeneralResult {
/** 生命周期配置规则列表 */
Rules: LifecycleRule[];
}
// deleteBucketLifecycle
/** deleteBucketLifecycle 接口参数 */
interface DeleteBucketLifecycleParams extends BucketParams {}
/** deleteBucketLifecycle 接口返回值 */
interface DeleteBucketLifecycleResult extends GeneralResult {}
// putBucketVersioning
/** 存储桶版本控制开关信息 */
interface VersioningConfiguration {
/** 说明版本是否开启，枚举值：Suspended、Enabled */
Status: 'Enabled' | 'Suspended';
}
/** putBucketVersioning 接口参数 */
interface PutBucketVersioningParams extends BucketParams {
/** 存储桶版本控制开关信息 */
VersioningConfiguration: VersioningConfiguration;
}
/** putBucketVersioning 接口返回值 */
interface PutBucketVersioningResult extends GeneralResult {}
// getBucketVersioning
/** getBucketVersioning 接口参数 */
interface GetBucketVersioningParams extends BucketParams {}
/** getBucketVersioning 接口返回值 */
interface GetBucketVersioningResult extends GeneralResult {
/** 存储桶版本控制开关信息 */
VersioningConfiguration: VersioningConfiguration;
}
// putBucketReplication
interface ReplicationRule {
/** 用来标注具体 Rule 的名称 */
ID?: string;
/** 标识 Rule 是否生效，枚举值：Enabled, Disabled */
Status: 'Enabled' | 'Disabled';
/** 前缀匹配，用来规定返回的文件前缀地址 */
Prefix: Prefix;
/** 目标存储桶信息 */
Destination: {
/** 资源标识符：qcs::cos:<region>::<bucketname-appid> */
Bucket: string;
/** 存储类型，枚举值：STANDARD，INTELLIGENT_TIERING，STANDARD_IA 等。默认值：原存储类型 */
StorageClass?: StorageClass;
};
}
/** 说明所有复制配置信息 */
interface ReplicationConfiguration {
/** 发起者身份标示：qcs::cam::uin/&lt;OwnerUin>:uin/&lt;SubUin> */
Role: string;
/** 具体配置信息，最多支持1000个，所有策略只能指向一个目标存储桶 */
Rules: ReplicationRule[];
}
/** putBucketReplication 接口参数 */
interface PutBucketReplicationParams extends BucketParams {
/** 说明所有复制配置信息 */
ReplicationConfiguration: ReplicationConfiguration;
}
/** putBucketReplication 接口返回值 */
interface PutBucketReplicationResult extends GeneralResult {}
// getBucketReplication
/** getBucketReplication 接口参数 */
interface GetBucketReplicationParams extends BucketParams {}
/** getBucketReplication 接口返回值 */
interface GetBucketReplicationResult extends GeneralResult {
/** 说明所有复制配置信息 */
ReplicationConfiguration: ReplicationConfiguration;
}
// deleteBucketReplication
/** deleteBucketReplication 接口参数 */
interface DeleteBucketReplicationParams extends BucketParams {}
/** deleteBucketReplication 接口返回值 */
interface DeleteBucketReplicationResult extends GeneralResult {}
// putBucketWebsite
/** 存储桶配置静态网站配置信息 */
interface WebsiteConfiguration {
/** 索引文档配置 */
IndexDocument: {
/** 指定索引文档的对象键后缀。例如指定为index.html，那么当访问到存储桶的根目录时，会自动返回 index.html 的内容，或者当访问到article/目录时，会自动返回 article/index.html的内容 */
Suffix: string;
};
/** 重定向所有请求配置 */
RedirectAllRequestsTo?: {
/** 指定重定向所有请求的目标协议，只能设置为 https */
Protocol: 'https' | string;
};
/** 用于配置是否忽略扩展名 */
AutoAddressing?: {
/** 用于配置是否忽略 HTML 拓展名，可选值为 Enabled 或 Disabled，默认为 Disabled */
Status: 'Disabled' | 'Enabled';
};
/** 错误文档配置 */
ErrorDocument?: {
/** 指定通用错误文档的对象键，当发生错误且未命中重定向规则中的错误码重定向时，将返回该对象键的内容 */
Key: Key;
/** 用于配置命中错误文档的 HTTP 状态码，可选值为 Enabled 或 Disabled，默认为 Enabled */
OriginalHttpStatus?: 'Enabled' | 'Disabled';
};
/** 重定向规则配置，最多设置100条 RoutingRule */
RoutingRules?: {
/** 重定向规则的条件配置 */
Condition: {
/** 指定重定向规则的错误码匹配条件，只支持配置4XX返回码，例如403或404，HttpErrorCodeReturnedEquals 与 KeyPrefixEquals 必选其一 */
HttpErrorCodeReturnedEquals?: string | number;
/** 指定重定向规则的对象键前缀匹配条件，HttpErrorCodeReturnedEquals 与 KeyPrefixEquals 必选其一 */
KeyPrefixEquals?: 'Enabled' | 'Disabled';
};
/** 重定向规则的具体重定向目标配置 */
Redirect: {
/** 指定重定向规则的目标协议，只能设置为 https */
Protocol?: 'https' | string;
/** 指定重定向规则的具体重定向目标的对象键，替换方式为替换整个原始请求的对象键，ReplaceKeyWith 与 ReplaceKeyPrefixWith 必选其一 */
ReplaceKeyWith?: string;
/** 指定重定向规则的具体重定向目标的对象键，替换方式为替换原始请求中所匹配到的前缀部分，仅可在 Condition 为 KeyPrefixEquals 时设置，ReplaceKeyWith 与 ReplaceKeyPrefixWith 必选其一 */
ReplaceKeyPrefixWith?: string;
};
}[];
}
/** putBucketWebsite 接口参数 */
interface PutBucketWebsiteParams extends BucketParams {
/** 存储桶配置静态网站配置信息 */
WebsiteConfiguration: WebsiteConfiguration;
}
/** putBucketWebsite 接口返回值 */
interface PutBucketWebsiteResult extends GeneralResult {}
// getBucketWebsite
/** getBucketWebsite 接口参数 */
interface GetBucketWebsiteParams extends BucketParams {}
/** getBucketWebsite 接口返回值 */
interface GetBucketWebsiteResult extends GeneralResult {
/** 存储桶配置静态网站配置信息 */
WebsiteConfiguration: WebsiteConfiguration;
}
// deleteBucketWebsite
/** deleteBucketWebsite 接口参数 */
interface DeleteBucketWebsiteParams extends BucketParams {}
/** deleteBucketWebsite 接口返回值 */
interface DeleteBucketWebsiteResult extends GeneralResult {}
// putBucketReferer
/** 防盗链配置信息 */
interface RefererConfiguration {
/** 是否开启防盗链，枚举值：Enabled、Disabled */
Status: 'Enabled' | 'Disabled';
/** 防盗链类型，枚举值：Black-List、White-List */
RefererType: 'Black-List' | 'White-List';
/** 生效域名列表， 支持多个域名且为前缀匹配， 支持带端口的域名和 IP， 支持通配符*，做二级域名或多级域名的通配 */
DomainList: {
/** 生效域名，例如www.qq.com/example，192.168.1.2:8080， *.qq.com */
Domains: string[];
};
/** 是否允许空 Referer 访问，枚举值：Allow、Deny，默认值为 Deny */
EmptyReferConfiguration?: 'Allow' | 'Deny';
}
/** putBucketReferer 接口参数 */
interface PutBucketRefererParams extends BucketParams {
/** 防盗链配置信息 */
RefererConfiguration: RefererConfiguration;
}
/** putBucketReferer 接口返回值 */
interface PutBucketRefererResult extends GeneralResult {}
// getBucketReferer
/** getBucketReferer 接口参数 */
interface GetBucketRefererParams extends BucketParams {}
/** getBucketReferer 接口返回值 */
interface GetBucketRefererResult extends GeneralResult {
/** 防盗链配置信息 */
RefererConfiguration: RefererConfiguration;
}
// putBucketDomain
/** 绑定的域名条目 */
interface DomainRule {
/** 是否启用。枚举值：ENABLED：启用，DISABLED：禁用，必选 */
Status: 'DISABLED' | 'ENABLED';
/** 完整域名，必选 */
Name: string;
/** 源站类型。枚举值：REST：默认源站，WEBSITE：静态源站源站，ACCELERATE：全球加速源站，必选 */
Type: 'REST' | 'WEBSITE' | 'ACCELERATE';
/** 如果指定域名已经作为其他存储桶的自定义域名，那么可以指定该元素强制将该域名作为当前存储桶的自定义域名。当前只支持 CNAME，代表您需要先将该域名的 CNAME 指向当前存储桶的源站域名（根据 Type 元素的不同对应为默认源站、静态网站源站或全球加速源站）后才能通过该接口设置自定义域名。可选 */
ForcedReplacement?: string;
}
/** putBucketDomain 接口参数 */
interface PutBucketDomainParams extends BucketParams {
/** 绑定的域名条目 */
DomainRule: DomainRule[];
}
/** putBucketDomain 接口返回值 */
interface PutBucketDomainResult extends GeneralResult {}
// getBucketDomain
/** getBucketDomain 接口参数 */
interface GetBucketDomainParams extends BucketParams {}
/** getBucketDomain 接口返回值 */
interface GetBucketDomainResult extends GeneralResult {
/** 绑定的域名条目 */
DomainRule: DomainRule[];
}
// deleteBucketDomain
/** deleteBucketDomain 接口参数 */
interface DeleteBucketDomainParams extends BucketParams {}
/** deleteBucketDomain 接口返回值 */
interface DeleteBucketDomainResult extends GeneralResult {}
// putBucketOrigin
/** Origin 回源规则配置 */
interface OriginRule {
/** 通过优先级区分规则执行先后，必选 */
RulePriority: 1;
/** 回源类型，支持同步回源（Mirror）和异步回源（Proxy）两种模式。 枚举值：Mirror、Proxy。必选 */
OriginType: 'Mirror' | 'Proxy';
/** 回源配置，配置用户使用的 HTTP 传输协议等信息。必选 */
OriginCondition: {
/** 触发回源的 HTTP 状态码，默认为404。必选 */
HTTPStatusCode: number;
/** 触发回源的文件前缀，默认为空，任意文件均可触发。可选 */
Prefix: Prefix;
};
/** 回源地址相关信息，必选 */
OriginParameter: {
/** 回源使用的协议，枚举值为 HTTP（使用 HTTP 协议），HTTPS（使用 HTTPS 协议）、FOLLOW（跟随用户使用的协议），默认值为 FOLLOW。必选 */
Protocol: 'HTTP' | 'HTTPS' | 'FOLLOW';
/** Proxy 模式下是否需要透传 HTTP 请求串，枚举值：true、false，默认为 true。可选 */
FollowQueryString?: BooleanString;
/** Proxy 模式下是否需要 Http 头部传输配置。可选 */
HttpHeader?: {
/** Proxy 模式下是否传输请求头部，枚举值：true、false，默认为 false。可选 */
FollowHttpHeader?: BooleanString;
/** 设置 Proxy 模式传输的请求头部。可选 */
NewHttpHeader?: {
/** 回源到源站时添加新的自定义头部，默认为空。可选 */
Header?: {
/** 用户设置的头部名称，默认为空。形式如 x-cos、oss、amz-ContentType、CacheControl、ContentDisposition、ContentEncoding、HttpExpiresDate、UserMetaData。可选 */
Key?: string;
/** 用户设置的头部值，默认为空。可选 */
Value?: string;
}[];
};
};
/** Proxy 模式下源站 3XX 响应策略，枚举值：true、false，选择 true 时跟随源站 3xx 重定向请求获取到资源，并将资源保存到 COS 上；选择 false 时透传 3XX 响应，不获取资源），默认为 true。可选 */
FollowRedirection: BooleanString;
/** Proxy 模式下的返回码参数，枚举值：301、302，默认为 302。可选 */
HttpRedirectCode: ('301' | '302')[];
};
/** 回源配置，配置用户使用的 HTTP 传输协议等信息。必选 */
OriginInfo: {
/** 源站信息。必选 */
HostInfo: {
/** 源站域名或者源站 IP。必选 */
HostName: string;
};
/** 回源文件信息。必选 */
FileInfo: {
/** 回源文件前缀配置信息。可选 */
PrefixConfiguration: {
/** 回源文件的文件前缀，默认为空。可选 */
Prefix: Prefix;
};
/** 回源文件后缀配置信息。可选 */
SuffixConfiguration: {
/** 回源文件的文件后缀，默认为空。可选 */
Suffix: string;
};
};
};
}
/** putBucketOrigin 接口参数 */
interface PutBucketOriginParams extends BucketParams {
/** Origin 回源规则配置 */
OriginRule: OriginRule[];
}
/** putBucketOrigin 接口返回值 */
interface PutBucketOriginResult extends GeneralResult {}
// getBucketOrigin
/** getBucketOrigin 接口参数 */
interface GetBucketOriginParams extends BucketParams {}
/** getBucketOrigin 接口返回值 */
interface GetBucketOriginResult extends GeneralResult {
/** Origin 回源规则配置 */
OriginRule: OriginRule[];
}
// deleteBucketOrigin
/** deleteBucketOrigin 接口参数 */
interface DeleteBucketOriginParams extends BucketParams {}
/** deleteBucketOrigin 接口返回值 */
interface DeleteBucketOriginResult extends GeneralResult {}
// putBucketLogging
interface BucketLoggingStatus {
/** 存储桶 logging 设置的具体信息，主要是目标存储桶 */
LoggingEnabled?: {
/** 存放日志的目标存储桶，可以是同一个存储桶（但不推荐），或同一账户下、同一地域的存储桶 */
TargetBucket: Bucket;
/** 日志存放在目标存储桶的指定路径 */
TargetPrefix: Prefix;
};
}
/** putBucketLogging 接口参数 */
interface PutBucketLoggingParams extends BucketParams {
/** 说明日志记录配置的状态，如果无子节点信息则意为关闭日志记录 */
BucketLoggingStatus: BucketLoggingStatus;
}
/** putBucketLogging 接口返回值 */
interface PutBucketLoggingResult extends GeneralResult {}
// getBucketLogging
/** getBucketLogging 接口参数 */
interface GetBucketLoggingParams extends BucketParams {}
/** getBucketLogging 接口返回值 */
interface GetBucketLoggingResult extends GeneralResult {
/** 说明日志记录配置的状态，如果无子节点信息则意为关闭日志记录 */
BucketLoggingStatus: BucketLoggingStatus;
}
// putBucketInventory
/** putBucketInventory 接口参数 */
interface InventoryConfiguration {
/** 清单的名称，与请求参数中的 id 对应，可选 */
Id: string;
/** 清单是否启用的标识：如果设置为 true，清单功能将生效，如果设置为 false，将不生成任何清单，必选 */
IsEnabled: BooleanString;
/** 是否在清单中包含对象版本：如果设置为 All，清单中将会包含所有对象版本，并在清单中增加 VersionId，IsLatest，DeleteMarker 这几个字段，如果设置为 Current，则清单中不包含对象版本信息，必选 */
IncludedObjectVersions: 'All' | 'Current';
/** 筛选待分析对象。清单功能将分析符合 Filter 中设置的前缀的对象，可选 */
Filter?: {
/** 筛选待分析对象。清单功能将分析符合 Filter 中设置的前缀的对象，可选 */
Prefix?: Prefix;
};
/** 设置清单结果中应包含的分析项目，可选 */
OptionalFields?: string[];
/** 配置清单任务周期，必选 */
Schedule: {
/** 清单任务周期，可选项为按日或者按周，枚举值：Daily、Weekly，必选 */
Frequency: 'Daily' | 'Weekly';
};
/** 描述存放清单结果的信息，必选 */
Destination: {
/** 清单结果导出后存放的存储桶信息，必选 */
COSBucketDestination: {
/** 清单分析结果的存储桶名，如：qcs::cos:ap-guangzhou::bucket-logging-1250000000，必选 */
Bucket: string;
/** 清单分析结果的文件形式，可选项为 CSV 格式，必选 */
Format: 'CSV';
/** 存储桶的所有者 ID，例如100000000001，可选 */
AccountId?: string;
/** 清单分析结果的前缀，可选 */
Prefix?: Prefix;
/** 为清单结果提供服务端加密的选项，可选 */
Encryption?: {
/** COS 托管密钥的加密方式，无需填充，可选 */
SSECOS?: '';
};
};
};
}
interface PutBucketInventoryParams extends BucketParams {
/** 清单的名称，与请求参数中的 id 对应 */
Id: string;
/** 包含清单任务的详细信息 */
InventoryConfiguration: InventoryConfiguration;
}
/** putBucketInventory 接口返回值 */
interface PutBucketInventoryResult extends GeneralResult {}
// getBucketInventory
/** getBucketInventory 接口参数 */
interface GetBucketInventoryParams extends BucketParams {
/** 清单的名称，与请求参数中的 id 对应 */
Id: string;
}
/** getBucketInventory 接口返回值 */
interface GetBucketInventoryResult extends GeneralResult {
/** 包含清单任务的详细信息 */
InventoryConfiguration: InventoryConfiguration;
}
// listBucketInventory
/** listBucketInventory 接口参数 */
interface ListBucketInventoryParams extends BucketParams {}
/** listBucketInventory 接口返回值 */
interface ListBucketInventoryResult extends GeneralResult {
/** 包含清单任务的详细信息 */
InventoryConfigurations: Record<string, any>;
/** 当 COS 响应体中 IsTruncated 为 true，且 NextContinuationToken 节点中存在参数值时，您可以将这个参数作为 continuation-token 参数值，以获取下一页的清单任务信息。缺省值：None */
ContinuationToken: string;
/** 是否已列出所有清单任务信息的标识。如果已经展示完则为 false，否则为 true */
IsTruncated: BooleanString;
/** 下一页清单列表的标识。如果该参数中有值，则可将该值作为 continuation-token 参数并发起 GET 请求以获取下一页清单任务信息 */
NextContinuationToken?: string;
}
// deleteBucketInventory
/** deleteBucketInventory 接口参数 */
interface DeleteBucketInventoryParams extends BucketParams {
Id: string;
}
/** deleteBucketInventory 接口返回值 */
interface DeleteBucketInventoryResult extends GeneralResult {}
// putBucketAccelerate
/** 全球加速的具体信息 */
interface AccelerateConfiguration {
/** 说明全球加速功能是否开启，枚举值：Suspended、Enabled */
Status: 'Enabled' | 'Suspended';
}
/** putBucketAccelerate 接口参数 */
interface PutBucketAccelerateParams extends BucketParams {
/** 全球加速的具体信息 */
AccelerateConfiguration: AccelerateConfiguration;
}
/** putBucketAccelerate 接口返回值 */
interface PutBucketAccelerateResult extends GeneralResult {}
// getBucketAccelerate
/** getBucketAccelerate 接口参数 */
interface GetBucketAccelerateParams extends BucketParams {}
/** getBucketAccelerate 接口返回值 */
interface GetBucketAccelerateResult extends GeneralResult {
/** 全球加速的具体信息 */
InventoryConfiguration: AccelerateConfiguration;
}
// putBucketEncryption
/** 默认的服务端加密配置规则 */
interface EncryptionRule {
/** 服务端加密的默认配置信息 */
ApplySideEncryptionConfiguration: {
/** 要使用的服务端加密算法，枚举值：AES256 */
SSEAlgorithm: 'AES256';
};
}
/** 包含默认加密的配置参数 */
interface ServerSideEncryptionConfiguration {
/** 默认的服务端加密配置规则 */
Rule: EncryptionRule[];
}
/** putBucketEncryption 接口参数 */
interface PutBucketEncryptionParams extends BucketParams {
/** 包含默认加密的配置参数 */
ServerSideEncryptionConfiguration: ServerSideEncryptionConfiguration;
}
/** putBucketEncryption 接口返回值 */
interface PutBucketEncryptionResult extends GeneralResult {}
// getBucketAccelerate
/** getBucketEncryption 接口参数 */
interface GetBucketEncryptionParams extends BucketParams {}
/** getBucketEncryption 接口返回值 */
interface GetBucketEncryptionResult extends GeneralResult {
/** 默认加密的配置参数 */
ServerSideEncryptionConfiguration: ServerSideEncryptionConfiguration;
}
// deleteBucketEncryption
/** deleteBucketEncryption 接口参数 */
interface DeleteBucketEncryptionParams extends BucketParams {}
/** deleteBucketEncryption 接口返回值 */
interface DeleteBucketEncryptionResult extends GeneralResult {}
// headObject
/** headObject 接口参数 */
interface HeadObjectParams extends ObjectParams {}
/** headObject 接口返回值 */
interface HeadObjectResult extends GeneralResult {
/** 对象的实体标签（Entity Tag），是对象被创建时标识对象内容的信息标签，可用于检查对象的内容是否发生变化，例如"8e0b617ca298a564c3331da28dcb50df"。此头部并不一定返回对象的 MD5 值，而是根据对象上传和加密方式而有所不同 */
ETag: ETag;
/** 对象的版本 ID */
VersionId?: string;
}
// getObject
// getObjectStream
/** getObject 接口参数 */
interface GetObjectParams extends ObjectParams {
// nodejs getObject 不支持传参BodyType
// BodyType?: 'text' | 'blob' | 'arraybuffer',
/** 写入流，可以传本地文件写入流 */
Output?: Stream;
/** 请求里的 Url Query 参数，传入该值中的 key/value 将会被 URLEncode */
Query?: Query;
/** 请求里的 Url Query 参数。传入该值将直接拼接在 Url 上，不会对其进行 URLEncode */
QueryString?: string;
/** 当对象在指定时间后被修改，则返回对象，否则返回 HTTP 状态码为304（Not Modified） */
IfModifiedSince?: string;
/** 当对象在指定时间后未被修改，则返回对象，否则返回 HTTP 状态码为412（Precondition Failed） */
IfUnmodifiedSince?: string;
/** 当对象的 ETag 与指定的值一致，则返回对象，否则返回 HTTP 状态码为412（Precondition Failed） */
IfMatch?: string;
/** 当对象的 ETag 与指定的值不一致，则返回对象，否则返回 HTTP 状态码为304（Not Modified） */
IfNoneMatch?: string;
/** 针对本次下载进行流量控制的限速值，必须为数字，单位默认为 bit/s。限速值设置范围为819200 - 838860800，即100KB/s - 100MB/s，如果超出该范围将返回400错误 */
TrafficLimit?: number;
/** 设置响应中的 Cache-Control 头部的值 */
ResponseCacheControl?: string;
/** 设置响应中的 Content-Disposition 头部的值 */
ResponseContentDisposition?: string;
/** 设置响应中的 Content-Encoding 头部的值 */
ResponseContentEncoding?: string;
/** 设置响应中的 Content-Language 头部的值 */
ResponseContentLanguage?: string;
/** 设置响应中的 Content-Type 头部的值 */
ResponseExpires?: string;
/** 设置响应中的 Expires 头部的值 */
ResponseContentType?: string;
/** RFC 2616 中定义的字节范围，范围值必须使用 bytes=first-last 格式，first 和 last 都是基于0开始的偏移量。例如 bytes=0-9 表示下载对象的开头10个字节的数据 ，如果不指定，则表示下载整个对象 */
Range?: string;
/** 当启用版本控制时，指定要下载的版本 ID，如不指定则下载对象的最新版本 */
VersionId?: string;
/** 下载的进度回调方法 */
onProgress?: onProgress;
}
/** getObject 接口返回值 */
interface GetObjectResult extends GeneralResult {
/** 对象内容 */
Body: Buffer;
/** 对象的实体标签（Entity Tag），是对象被创建时标识对象内容的信息标签，可用于检查对象的内容是否发生变化，例如"8e0b617ca298a564c3331da28dcb50df"。此头部并不一定返回对象的 MD5 值，而是根据对象上传和加密方式而有所不同 */
ETag: ETag;
/** 对象的版本 ID */
VersionId?: string;
}
// putObject
/** putObject 接口参数 */
interface PutObjectParams extends ObjectParams {
/** 要上传对象内容 */
Body: UploadBody;
/** 上传的文件大小，单位 Byte 字节，如果不传且 Body 是流，会走服务端流式上传 */
ContentLength?: number;
/** 请求里的 Url Query 参数 */
Query?: string;
/** RFC 2616 中定义的缓存指令，将作为对象元数据保存 */
CacheControl?: string;
/** RFC 2616 中定义的文件名称，将作为对象元数据保存 */
ContentDisposition?: string;
/** RFC 2616 中定义的编码格式，将作为对象元数据保存 */
ContentEncoding?: string;
/** RFC 2616 中定义的 HTTP 请求内容类型（MIME），此头部用于描述待上传对象的内容类型，将作为对象元数据保存。例如text/html或image/jpeg */
ContentType?: string;
/** RFC 2616 中定义的缓存失效时间，将作为对象元数据保存 */
Expires?: string;
/** RFC 2616 中定义的缓存失效时间，将作为对象元数据保存 */
Expect?: string;
/** 允许用户自定义存储桶权限，有效值：private | public-read | public-read-write，可选 */
ACL?: ObjectACL;
/** 赋予被授权者读取对象的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantRead?: Grant;
/** 赋予被授权者读取对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantReadAcp?: Grant;
/** 赋予被授权者写入对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantWriteAcp?: Grant;
/** 赋予被授权者操作对象的所有权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantFullControl?: Grant;
/** 对象存储类型。例如 STANDARD | STANDARD_IA | ARCHIVE | DEEP_ARCHIVE | INTELLIGENT_TIERING | MAZ_STANDARD | MAZ_STANDARD_IA | MAZ_INTELLIGENT_TIERING。默认值：STANDARD */
StorageClass?: StorageClass;
/** 包括用户自定义元数据头部后缀和用户自定义元数据信息，将作为对象元数据保存，大小限制为2KB，注意：用户自定义元数据信息支持下划线（_），但用户自定义元数据头部后缀不支持下划线，仅支持减号（-） */
'x-cos-meta-*'?: string;
/** 任务开始上传的回调方法 */
onTaskReady?: (TaskId: COS.TaskId) => void;
onTaskStart?: (TaskInfo: COS.Task) => void;
/** 上传的进度回调方法 */
onProgress?: onProgress;
}
/** putObject 接口返回值 */
interface PutObjectResult extends GeneralResult {
/** 对象的实体标签（Entity Tag），是对象被创建时标识对象内容的信息标签，可用于检查对象的内容是否发生变化，例如"8e0b617ca298a564c3331da28dcb50df"。此头部并不一定返回对象的 MD5 值，而是根据对象上传和加密方式而有所不同 */
ETag: ETag;
/** 创建的存储桶访问地址，不带 https:// 前缀，例如 examplebucket-1250000000.cos.ap-guangzhou.myqcloud.com/images/1.jpg */
Location: string;
/** 对象的版本 ID */
VersionId?: VersionId;
}
/** appendObject 接口参数 */
interface AppendObjectParams extends PutObjectParams {
/** 追加操作的起始点 */
Position: number;
}
// deleteObject
/** deleteObject 接口参数 */
interface DeleteObjectParams extends ObjectParams {}
/** deleteObject 接口返回值 */
interface DeleteObjectResult extends GeneralResult {}
// deleteMultipleObject
/** deleteMultipleObject 接口参数 */
interface DeleteMultipleObjectParams extends BucketParams {
/** 要删除的对象列表 */
Objects: {
/** 要删除的对象键 */
Key: Key;
/** 要删除的对象版本 ID */
VersionId?: string;
}[];
/** 是否启动 Quiet 模式 */
Quiet?: boolean;
}
/** deleteMultipleObject 接口返回值 */
interface DeleteMultipleObjectResult extends GeneralResult {
Deleted: {
/** 删除成功的对象的对象键 */
Key: Key;
/** 删除成功的版本 ID，仅当请求中指定了要删除对象的版本 ID 时才返回该元素 */
VersionId?: VersionId;
/** 仅当对该对象的删除创建了一个删除标记，或删除的是该对象的一个删除标记时才返回该元素，布尔值，固定为 true */
DeleteMarker?: BooleanString;
/** 仅当对该对象的删除创建了一个删除标记，或删除的是该对象的一个删除标记时才返回该元素，值为创建或删除的删除标记的版本 ID */
DeleteMarkerVersionId?: VersionId;
}[];
Error: {
/** 删除失败的对象的对象键 */
Key: Key;
/** 删除失败的版本 ID，仅当请求中指定了要删除对象的版本 ID 时才返回该元素 */
VersionId?: string;
/** 删除失败的错误码，用来定位唯一的错误条件和确定错误场景 */
Code?: string;
/** 删除失败的具体错误信息 */
Message?: string;
}[];
}
// getObjectAcl
/** getObjectAcl 接口参数 */
interface GetObjectAclParams extends ObjectParams {
VersionId?: VersionId;
}
/** getObjectAcl 接口返回值 */
interface GetObjectAclResult extends GeneralResult {
/** 允许用户自定义存储桶权限，有效值：private | public-read | public-read-write */
ACL: ObjectACL;
/** 赋予被授权者读取对象的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者 */
GrantRead: Grant;
/** 赋予被授权者读取对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者 */
GrantReadAcp: Grant;
/** 赋予被授权者写入对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者 */
GrantWriteAcp: Grant;
/** 赋予被授权者操作对象的所有权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者 */
GrantFullControl: Grant;
/** 存储桶持有者信息 */
Owner: Owner;
/** 被授权者信息与权限信息 */
Grants: Grants[];
}
// putObjectAcl
/** putObjectAcl 接口参数 */
interface PutObjectAclParams extends ObjectParams {
/** 允许用户自定义存储桶权限，有效值：private | public-read | public-read-write，可选 */
ACL?: ObjectACL;
/** 赋予被授权者读取对象的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantRead?: Grant;
/** 赋予被授权者读取对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantReadAcp?: Grant;
/** 赋予被授权者写入对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantWriteAcp?: Grant;
/** 赋予被授权者操作对象的所有权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantFullControl?: Grant;
}
/** putObjectAcl 接口返回值 */
interface PutObjectAclResult extends GeneralResult {}
// optionsObject
/** optionsObject 接口参数 */
interface OptionsObjectParams extends ObjectParams {
/** 发起 CORS 请求所在的页面域名（Origin） */
Origin: string;
/** 发起 CORS 请求所用的方法（Method） */
AccessControlRequestMethod: Method;
/** 发起 CORS 请求时使用的 HTTP 请求头部，不区分英文大小写，可使用英文逗号(,)分隔多个头部 */
AccessControlRequestHeaders: string;
}
/** optionsObject 接口返回值 */
interface OptionsObjectResult extends GeneralResult {
/** 允许发起 CORS 的域名，可能的值有以下两种：
*：代表允许所有域名
请求头 Origin 中指定的域名：代表允许指定域名 */
AccessControlAllowOrigin: string;
/** 允许发起 CORS 请求所使用的方法（Method），可使用英文逗号(,)分隔多个方法 */
AccessControlAllowMethods: string;
/** 允许发起 CORS 请求带的 HTTP 头部，不区分英文大小写，可使用英文逗号(,)分隔多个头部 */
AccessControlAllowHeaders: string;
/** 允许浏览器获取的 CORS 请求中的 HTTP 响应头部，不区分英文大小写，可使用英文逗号(,)分隔多个头部 */
AccessControlExposeHeaders: string;
/** CORS 配置的有效时间，单位为秒，在有效时间内，浏览器无须为同一请求再次发起预检请求 */
AccessControlMaxAge: string;
}
// restoreObject
interface RestoreRequest {
/** 指定恢复出的临时副本的有效时长，单位为“天” */
Days: number | string;
/** 恢复工作参数 */
CASJobParameters: {
/** 恢复时，Tier 可以指定为支持的恢复模式。
对于恢复归档存储类型数据，有三种恢复模式，分别为：
Expedited：极速模式，恢复任务在1 - 5分钟内可完成。
Standard：标准模式，恢复任务在3 - 5小时内完成
Bulk：批量模式，恢复任务在5 - 12小时内完成。
对于恢复深度归档存储类型数据，有两种恢复模式，分别为：
Standard：标准模式，恢复时间为12 - 24小时。
Bulk：批量模式，恢复时间为24 - 48小时。 */
Tier: 'Expedited' | 'Standard' | 'Bulk';
};
}
/** restoreObject 接口参数 */
interface RestoreObjectParams extends ObjectParams {
/** 包含 POST Object restore 操作的所有请求信息 */
RestoreRequest: RestoreRequest;
/** 当启用版本控制时，指定要恢复的版本 ID，如不指定则恢复对象的最新版本 */
VersionId?: VersionId;
}
/** restoreObject 接口返回值 */
interface RestoreObjectResult extends GeneralResult {}
// selectObjectContent
// selectObjectContentStream
/** selectObjectContent 接口参数 */
interface SelectObjectContentParams extends ObjectParams {
/** 接口的版本信息，当前最新版本是 2 */
SelectType: number;
/** 检索参数，当前版本支持检索 JSON、CSV 文件内容 */
SelectRequest: Record<string, any>;
/** 当启用版本控制时，指定要检索的版本 ID，如不指定则检索对象的最新版本 */
VersionId?: VersionId;
}
/** selectObjectContent 接口返回值 */
interface SelectObjectContentResult extends GeneralResult {
/** 查询过程统计信息 */
Stats: {
/** 如果文件是压缩文件，该数值代表文件解压前的字节大小；如果文件不是压缩文件，该数值即文件的字节大小 */
BytesScanned: number;
/** 如果文件是压缩文件，该数值代表文件解压后的字节大小；如果文件不是压缩文件，该数值即文件的字节大小 */
BytesProcessed: number;
/** COS Select 在本次查询中返回的检索结果字节大小 */
BytesReturned: number;
};
/** 查询的结果内容 */
Payload?: Buffer;
}
// putObjectCopy
/** putObjectCopy 接口参数 */
interface PutObjectCopyParams extends ObjectParams {
/** 源对象的 URL，其中对象键需经过 URLEncode，可以通过 versionId 参数指定源对象的版本，例如： sourcebucket-1250000001.cos.ap-shanghai.myqcloud.com/example-%E8%85%BE%E8%AE%AF%E4%BA%91.jpg 或 sourcebucket-1250000001.cos.ap-shanghai.myqcloud.com/example-%E8%85%BE%E8%AE%AF%E4%BA%91.jpg?versionId=MTg0NDUxNzYzMDc0NDMzNDExOTc */
CopySource: string;
/** 是否复制源对象的元数据信息，枚举值：Copy，Replaced，默认为 Copy。如果标记为 Copy，则复制源对象的元数据信息；如果标记为 Replaced，则按本次请求的请求头中的元数据信息作为目标对象的元数据信息；当目标对象和源对象为同一对象时，即用户试图修改元数据时，则标记必须为 Replaced */
MetadataDirective?: 'Copy' | 'Replaced';
/** 允许用户自定义存储桶权限，有效值：private | public-read | public-read-write，可选 */
ACL?: ObjectACL;
/** 赋予被授权者读取对象的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantRead?: Grant;
/** 赋予被授权者读取对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantReadAcp?: Grant;
/** 赋予被授权者写入对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantWriteAcp?: Grant;
/** 赋予被授权者操作对象的所有权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantFullControl?: Grant;
/** 当对象在指定时间后被修改，则执行复制操作，否则返回 HTTP 状态码为412（Precondition Failed） */
CopySourceIfModifiedSince?: string;
/** 当对象在指定时间后未被修改，则执行复制操作，否则返回 HTTP 状态码为412（Precondition Failed） */
CopySourceIfUnmodifiedSince?: string;
/** 当对象的 ETag 与指定的值一致，则执行复制操作，否则返回 HTTP 状态码为412（Precondition Failed） */
CopySourceIfMatch?: string;
/** 当对象的 ETag 与指定的值不一致，则执行复制操作，否则返回 HTTP 状态码为412（Precondition Failed） */
CopySourceIfNoneMatch?: string;
/** 对象存储类型。例如 STANDARD | STANDARD_IA | ARCHIVE | DEEP_ARCHIVE | INTELLIGENT_TIERING | MAZ_STANDARD | MAZ_STANDARD_IA | MAZ_INTELLIGENT_TIERING。默认值：STANDARD */
StorageClass?: StorageClass;
/** RFC 2616 中定义的缓存指令，将作为目标对象元数据保存 */
CacheControl?: string;
/** RFC 2616 中定义的文件名称，将作为目标对象元数据保存 */
ContentDisposition?: string;
/** RFC 2616 中定义的编码格式，将作为目标对象元数据保存 */
ContentEncoding?: string;
/** RFC 2616 中定义的 HTTP 请求内容类型（MIME），此头部用于描述目标对象的内容类型，将作为目标对象元数据保存。例如 text/html 或 image/jpeg。 */
ContentType?: string;
/** RFC 2616 中定义的缓存失效时间，将作为目标对象元数据保存 */
Expires?: string;
/** 包括用户自定义元数据头部后缀和用户自定义元数据信息，将作为目标对象元数据保存，大小限制为2KB。注意：用户自定义元数据信息支持下划线（_），但用户自定义元数据头部后缀不支持下划线，仅支持减号（-） */
'x-cos-meta-*'?: string;
}
/** putObjectCopy 接口返回值 */
interface PutObjectCopyResult extends GeneralResult {
ETag: string;
CRC64: string;
LastModified: string;
VersionId: string;
Location: Location;
}
// putObjectTagging
/** putObjectTagging 接口参数 */
interface PutObjectTaggingParams extends ObjectParams {
/** 标签集合，最多支持10个标签 */
Tags: Tag[];
/** 对象的版本 ID；当未启用版本控制时，该节点的值为空字符串；当启用版本控制时，启用版本控制之前的对象，其版本 ID 为 null；当暂停版本控制时，新上传的对象其版本 ID 为 null，且同一个对象最多只存在一个版本 ID 为 null 的对象版本 */
VersionId?: VersionId;
}
/** putObjectTagging 接口返回值 */
interface PutObjectTaggingResult extends GeneralResult {}
// getObjectTagging
/** getObjectTagging 接口参数 */
interface GetObjectTaggingParams extends ObjectParams {}
/** getObjectTagging 接口返回值 */
interface GetObjectTaggingResult extends GeneralResult {
/** 标签集合，最多支持10个标签 */
Tags: Tag[];
}
// deleteObjectTagging
/** deleteObjectTagging 接口参数 */
interface DeleteObjectTaggingParams extends ObjectParams {}
/** deleteObjectTagging 接口返回值 */
interface DeleteObjectTaggingResult extends GeneralResult {}
// multipartInit
/** multipartInit 接口参数 */
interface MultipartInitParams extends ObjectParams {
/** RFC 2616 中定义的缓存指令，将作为对象元数据保存 */
CacheControl?: string;
/** RFC 2616 中定义的文件名称，将作为对象元数据保存 */
ContentDisposition?: string;
/** RFC 2616 中定义的编码格式，将作为对象元数据保存 */
ContentEncoding?: string;
/** RFC 2616 中定义的 HTTP 请求内容类型（MIME），此头部用于描述待上传对象的内容类型，将作为对象元数据保存。例如text/html或 image/jpeg */
ContentType?: string;
/** RFC 2616 中定义的缓存失效时间，将作为对象元数据保存 */
Expires?: string;
/** 允许用户自定义存储桶权限，有效值：private | public-read | public-read-write，可选 */
ACL?: ObjectACL;
/** 赋予被授权者读取对象的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantRead?: Grant;
/** 赋予被授权者读取对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantReadAcp?: Grant;
/** 赋予被授权者写入对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantWriteAcp?: Grant;
/** 赋予被授权者操作对象的所有权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantFullControl?: Grant;
/** 请求里的 Url Query 参数 */
Query?: Query;
/** 对象存储类型。例如 STANDARD | STANDARD_IA | ARCHIVE | DEEP_ARCHIVE | INTELLIGENT_TIERING | MAZ_STANDARD | MAZ_STANDARD_IA | MAZ_INTELLIGENT_TIERING。默认值：STANDARD */
StorageClass?: StorageClass;
/** 包括用户自定义元数据头部后缀和用户自定义元数据信息，将作为对象元数据保存，大小限制为2KB。注意：用户自定义元数据信息支持下划线（_），但用户自定义元数据头部后缀不支持下划线，仅支持减号（-） */
'x-cos-meta-*'?: string;
}
/** multipartInit 接口返回值 */
interface MultipartInitResult extends GeneralResult {
UploadId: string;
}
// multipartUpload
/** multipartUpload 接口参数 */
interface MultipartUploadParams extends ObjectParams {
/** 分块上传的任务 ID */
UploadId: UploadId;
/** 标识本次分块上传的编号，范围在1 - 10000 */
PartNumber: PartNumber;
/** 要上传分片内容 */
Body: UploadBody;
/** 要上传分片内容大小 */
ContentLength?: number;
/** 服务端加密算法 */
ServerSideEncryption?: string;
}
/** multipartUpload 接口返回值 */
interface MultipartUploadResult extends GeneralResult {
/** 返回对象的 MD5 算法校验值，ETag 的值可以用于检查分块的内容是否发生变化 */
ETag: ETag;
}
// uploadPartCopy
/** uploadPartCopy 接口参数 */
interface UploadPartCopyParams extends ObjectParams {
/** 源对象 URL 路径，可以通过 versionid 子资源指定历史版本 */
CopySource: string;
/** 分块上传的任务 ID */
UploadId: UploadId;
/** 标识本次分块上传的编号，范围在1 - 10000 */
PartNumber: PartNumber;
/** 源对象的字节范围，范围值必须使用 bytes=first-last 格式，first 和 last 都是基于 0 开始的偏移量。例如 bytes=0-9 表示您希望拷贝源对象的开头10个字节的数据，如果不指定，则表示拷贝整个对象 */
CopySourceRange?: string;
/** 当 Object 在指定时间后被修改，则执行操作，否则返回412，可与 x-cos-copy-source-If-None-Match 一起使用，与其他条件联合使用返回冲突 */
CopySourceIfModifiedSince?: string;
/** 当 Object 在指定时间后未被修改，则执行操作，否则返回412，可与 x-cos-copy-source-If-Match 一起使用，与其他条件联合使用返回冲突 */
CopySourceIfUnmodifiedSince?: string;
/** 当 Object 的 Etag 和给定一致时，则执行操作，否则返回412，可与 x-cos-copy-source-If-Unmodified-Since 一起使用，与其他条件联合使用返回冲突 */
CopySourceIfMatch?: string;
/** 当 Object 的 Etag 和给定不一致时，则执行操作，否则返回412，可与 x-cos-copy-source-If-Modified-Since 一起使用，与其他条件联合使用返回冲突 */
CopySourceIfNoneMatch?: string;
}
/** uploadPartCopy 接口返回值 */
interface UploadPartCopyResult extends GeneralResult {
/** 返回对象的 MD5 算法校验值，ETag 的值可以用于检查分块的内容是否发生变化 */
ETag: ETag;
}
// multipartComplete
/** multipartComplete 接口参数 */
interface MultipartCompleteParams extends ObjectParams {
/** 分块上传的任务 ID */
UploadId: UploadId;
/** 用来说明本次分块上传中每个块的信息 */
Parts: Part[];
}
/** multipartComplete 接口返回值 */
interface MultipartCompleteResult extends GeneralResult {
/** 使用 Upload Part 请求上传分块成功后返回的 ETag 响应头部的值 */
ETag: ETag;
/** 创建的存储桶访问地址，不带 https:// 前缀，例如 examplebucket-1250000000.cos.ap-guangzhou.myqcloud.com/images/1.jpg */
Location: Location;
/** 对象的版本 ID；当未启用版本控制时，该节点的值为空字符串；当启用版本控制时，启用版本控制之前的对象，其版本 ID 为 null；当暂停版本控制时，新上传的对象其版本 ID 为 null，且同一个对象最多只存在一个版本 ID 为 null 的对象版本 */
VersionId?: VersionId;
}
// multipartList
/** multipartList 接口参数 */
interface MultipartListParams extends BucketParams {
/** 限定返回的 Object key 必须以 Prefix 作为前缀。注意使用 prefix 查询时，返回的 key 中仍会包含 Prefix。 */
Prefix: Prefix;
/** 一个字符的分隔符，常用 / 字符，用于对对象键进行分组。所有对象键中从 prefix 或从头（如未指定 prefix）到首个 delimiter 之间相同的部分将作为 CommonPrefixes 下的一个 Prefix 节点。被分组的对象键不再出现在后续对象列表中 */
Delimiter: Delimiter;
/** 设置最大返回的 multipart 数量，合法取值从1到1000，默认1000 */
MaxUploads?: number;
/** 与 upload-id-marker 一起使用：当 upload-id-marker 未被指定时，ObjectName 字母顺序大于 key-marker 的条目将被列出。当 upload-id-marker 被指定时，ObjectName 字母顺序大于 key-marker 的条目被列出，ObjectName 字母顺序等于 key-marker 同时 UploadId 大于 upload-id-marker 的条目将被列出。 */
KeyMarker?: Key;
/** 与 key-marker 一起使用：当 key-marker 未被指定时，upload-id-marker 将被忽略。当 key-marker 被指定时，ObjectName字母顺序大于 key-marker 的条目被列出，ObjectName 字母顺序等于 key-marker 同时 UploadId 大于 upload-id-marker 的条目将被列出。 */
UploadIdMarker?: UploadId;
/** 规定返回值的编码方式，可选值：url，代表返回的对象键为 URL 编码（百分号编码）后的值，例如“腾讯云”将被编码为%E8%85%BE%E8%AE%AF%E4%BA%91 */
EncodingType?: EncodingType;
}
/** multipartList 接口返回值 */
interface MultipartListResult extends GeneralResult {
/** 每个上传任务的信息 */
Upload: {
/** 对象键 */
Key: Key;
/** 分块上传的任务 ID */
UploadId: UploadId;
/** 上传任务发起者的信息 */
Initiator: Initiator;
/** 上传任务所有者的信息 */
Owner: Owner;
/** 对象存储类型。枚举值 STANDARD | STANDARD_IA | ARCHIVE | DEEP_ARCHIVE | INTELLIGENT_TIERING | MAZ_STANDARD | MAZ_STANDARD_IA | MAZ_INTELLIGENT_TIERING @see https://cloud.tencent.com/document/product/436/33417 */
StorageClass: StorageClass;
/** UploadId 的创建时间，为 ISO8601 格式，例如2019-05-24T10:56:40Z */
Initiated: IsoDateTime;
}[];
/** 仅当响应条目有截断（IsTruncated 为 true）才会返回该节点，该节点的值为当前响应条目中的最后一个对象键，当需要继续请求后续条目时，将该节点的值作为下一次请求的 marker 参数传入 */
IsTruncated: BooleanString;
/** 假如返回条目被截断，则返回的 NextKeyMarker 就是下一个条目的起点。 */
NextKeyMarker: Key;
/** 假如返回条目被截断，则返回的 UploadId 就是下一个条目的起点。 */
NextUploadIdMarker: UploadId;
}
// multipartListPart
/** multipartListPart 接口参数 */
interface MultipartListPartParams extends ObjectParams {
/** 请求的对象键，最前面不带 /，例如 images/1.jpg */
Key: Key;
/** 标识本次分块上传的 ID，使用 Initiate Multipart Upload 接口初始化分块上传时得到的 UploadId */
UploadId: UploadId;
/** 单次返回最大的条目数量，默认1000 */
MaxParts?: number;
/** 默认以 UTF-8 二进制顺序列出条目，所有列出条目从 marker 开始 */
PartNumberMarker?: string;
/** 规定返回值的编码方式，可选值：url，代表返回的对象键为 URL 编码（百分号编码）后的值，例如“腾讯云”将被编码为%E8%85%BE%E8%AE%AF%E4%BA%91 */
EncodingType?: EncodingType;
}
/** multipartListPart 接口返回值 */
interface MultipartListPartResult extends GeneralResult {
/** 用来说明本次分块上传中每个块的信息 */
Part: {
/** 块的编号 */
PartNumber: PartNumber;
/** 说明块最后被修改时间 */
LastModified: IsoDateTime;
/** 块的 MD5 算法校验值 */
ETag: ETag;
/** 说明块大小，单位是 Byte */
Size: number;
}[];
/** 上传任务所有者的信息 */
Owner: Owner;
/** 上传任务发起者的信息 */
Initiator: Initiator;
/** 假如返回条目被截断，则返回 NextMarker 就是下一个条目的起点 */
NextPartNumberMarker: number;
/** 对象存储类型。枚举值 STANDARD | STANDARD_IA | ARCHIVE | DEEP_ARCHIVE | INTELLIGENT_TIERING | MAZ_STANDARD | MAZ_STANDARD_IA | MAZ_INTELLIGENT_TIERING @see https://cloud.tencent.com/document/product/436/33417 */
StorageClass: StorageClass;
/** 仅当响应条目有截断（IsTruncated 为 true）才会返回该节点，该节点的值为当前响应条目中的最后一个对象键，当需要继续请求后续条目时，将该节点的值作为下一次请求的 marker 参数传入 */
IsTruncated: BooleanString;
}
// multipartAbort
/** multipartAbort 接口参数 */
interface MultipartAbortParams extends ObjectParams {
UploadId: string;
}
/** multipartAbort 接口返回值 */
interface MultipartAbortResult extends GeneralResult {}
// sliceUploadFile
/** sliceUploadFile 接口参数 */
interface SliceUploadFileParams extends ObjectParams {
/** 要上传的本地文件路径 */
FilePath: string;
/** 分块上传时，每片的字节数大小，默认值1048576（1MB） */
ChunkSize?: number;
/** 分块上传时，每片的字节数大小，默认值1048576（1MB） */
SliceSize?: number;
/** 请求里的 Url Query 参数 */
Query?: string;
/** RFC 2616 中定义的缓存指令，将作为对象元数据保存 */
CacheControl?: string;
/** RFC 2616 中定义的文件名称，将作为对象元数据保存 */
ContentDisposition?: string;
/** RFC 2616 中定义的编码格式，将作为对象元数据保存 */
ContentEncoding?: string;
/** RFC 2616 中定义的 HTTP 请求内容类型（MIME），此头部用于描述待上传对象的内容类型，将作为对象元数据保存。例如text/html或image/jpeg */
ContentType?: string;
/** RFC 2616 中定义的缓存失效时间，将作为对象元数据保存 */
Expires?: string;
/** RFC 2616 中定义的缓存失效时间，将作为对象元数据保存 */
Expect?: string;
/** 允许用户自定义存储桶权限，有效值：private | public-read | public-read-write，可选 */
ACL?: ObjectACL;
/** 赋予被授权者读取对象的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantRead?: Grant;
/** 赋予被授权者读取对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantReadAcp?: Grant;
/** 赋予被授权者写入对象的访问控制列表（ACL）的权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantWriteAcp?: Grant;
/** 赋予被授权者操作对象的所有权限，格式：id="[OwnerUin]"，可使用半角逗号（,）分隔多组被授权者，可选 */
GrantFullControl?: Grant;
/** 对象存储类型。枚举值 STANDARD | STANDARD_IA | ARCHIVE | DEEP_ARCHIVE | INTELLIGENT_TIERING | MAZ_STANDARD | MAZ_STANDARD_IA | MAZ_INTELLIGENT_TIERING @see https://cloud.tencent.com/document/product/436/33417 */
StorageClass?: StorageClass;
/** 包括用户自定义元数据头部后缀和用户自定义元数据信息，将作为对象元数据保存，大小限制为2KB，注意：用户自定义元数据信息支持下划线（_），但用户自定义元数据头部后缀不支持下划线，仅支持减号（-） */
'x-cos-meta-*'?: string;
/** 任务开始上传的回调方法 */
onTaskReady?: (TaskId: COS.TaskId) => void;
onTaskStart?: (TaskInfo: COS.Task) => void;
/** 上传的进度回调方法 */
onProgress?: onProgress;
/** 续传校验的进度回调方法 */
onHashProgress?: onProgress;
}
/** sliceUploadFile 接口返回值 */
interface SliceUploadFileResult extends GeneralResult {
/** 对象的实体标签（Entity Tag），是对象被创建时标识对象内容的信息标签，可用于检查对象的内容是否发生变化，例如"8e0b617ca298a564c3331da28dcb50df"。此头部并不一定返回对象的 MD5 值，而是根据对象上传和加密方式而有所不同 */
ETag: ETag;
/** 创建的存储桶访问地址，不带 https:// 前缀，例如 examplebucket-1250000000.cos.ap-guangzhou.myqcloud.com/images/1.jpg */
Location: string;
/** 对象的版本 ID */
VersionId?: VersionId;
}
// abortUploadTask
/** abortUploadTask 接口参数 */
interface AbortUploadTaskParams extends ObjectParams {
/** 清理上传任务的级别，枚举值 'task' | 'file' | 'bucket'，默认 task */
Level?: 'task' | 'file' | 'bucket';
/** 要清理的 UploadId，Level 为 task 时必选 */
UploadId?: UploadId;
}
/** abortUploadTask 接口返回值 */
interface AbortUploadTaskResult extends GeneralResult {}
// uploadFiles
type UploadFileItemParams = (PutObjectParams | SliceUploadFileParams) & {
/** 要上传的本地文件路径 */
FilePath: string;
/** 上传的进度回调方法 */
onProgress?: onProgress;
/** 上传完成回调方法 */
onFileFinish?: (err: Error, data?: Record<string, any>) => void;
};
/** 要上传的单个文件参数 */
interface UploadFileItemResult extends GeneralResult {
/** 对象的实体标签（Entity Tag），是对象被创建时标识对象内容的信息标签，可用于检查对象的内容是否发生变化，例如"8e0b617ca298a564c3331da28dcb50df"。此头部并不一定返回对象的 MD5 值，而是根据对象上传和加密方式而有所不同 */
ETag: ETag;
/** 创建的存储桶访问地址，不带 https:// 前缀，例如 examplebucket-1250000000.cos.ap-guangzhou.myqcloud.com/images/1.jpg */
Location: string;
/** 对象的版本 ID */
VersionId?: VersionId;
}
interface UploadFilesParams {
/** 要上传的文件参数列表 */
files: UploadFileItemParams[];
/** 使用 uploadFiles 批量上传时，文件大小大于该数值将使用按分块上传，否则将调用简单上传，单位 Byte，默认值1048576（1MB） */
SliceSize?: number;
/** 所有文件整体上传进度回调方法 */
onProgress?: onProgress;
/** 所有文件上传完成回调方法 */
onFileFinish?: (err: CosError, data?: Record<string, any>) => void;
}
/** uploadFiles 接口返回值 */
interface UploadFilesResult extends GeneralResult {
/** 文件列表上传结果 */
files: {
/** 单个文件上传参数 */
options: UploadFileItemParams;
/** 单个文件上传错误信息 */
error: Error;
/** 单个文件上传成功信息 */
data: UploadFileItemResult;
}[];
}
// uploadFile 高级上传
interface FileFinishInfo {
err: Error;
data: UploadFileItemResult;
options: UploadFileItemParams;
}
type onFileFinish = (err: Error, data: UploadFileItemResult, options: UploadFileItemParams) => void;
type UploadFileParams = (PutObjectParams | SliceUploadFileParams) & {
/** 要上传的本地文件路径 */
FilePath: string;
/** 使用 uploadFile 高级上传时，文件大小大于该数值将使用按分块上传，否则将调用简单上传，单位 Byte，默认值1048576（1MB） */
SliceSize?: number;
/** 上传的进度回调方法 */
onProgress?: onProgress;
/** 上传完成回调方法 */
onFileFinish?: onFileFinish;
};
/** uploadFiles 接口返回值 */
interface UploadFileResult extends GeneralResult {
/** 对象的实体标签（Entity Tag），是对象被创建时标识对象内容的信息标签，可用于检查对象的内容是否发生变化，例如"8e0b617ca298a564c3331da28dcb50df"。此头部并不一定返回对象的 MD5 值，而是根据对象上传和加密方式而有所不同 */
ETag: ETag;
/** 创建的存储桶访问地址，不带 https:// 前缀，例如 examplebucket-1250000000.cos.ap-guangzhou.myqcloud.com/images/1.jpg */
Location: string;
/** 对象的版本 ID */
VersionId?: VersionId;
}
// sliceCopyFile
/** sliceCopyFile 接口参数 */
interface SliceCopyFileParams extends ObjectParams {
/** 源对象的 URL，其中对象键需经过 URLEncode，可以通过 versionId 参数指定源对象的版本，例如： sourcebucket-1250000001.cos.ap-shanghai.myqcloud.com/example-%E8%85%BE%E8%AE%AF%E4%BA%91.jpg 或 sourcebucket-1250000001.cos.ap-shanghai.myqcloud.com/example-%E8%85%BE%E8%AE%AF%E4%BA%91.jpg?versionId=MTg0NDUxNzYzMDc0NDMzNDExOTc */
CopySource: string;
/** 使用 sliceCopyFile 分块复制文件时，文件大小大于该数值将使用分块复制 ，否则将调用简单复制，默认值10485760（10MB） */
CopySliceSize?: number;
/** 使用 sliceCopyFile 分块复制文件时，每片的大小字节数，默认值10485760（10MB） */
CopyChunkSize?: number;
/** 分片复制进度回调方法 */
onProgress: onProgress;
}
/** sliceCopyFile 接口返回值 */
interface SliceCopyFileResult extends GeneralResult {}
// getTaskList
type TaskId = string;
type Task = {
/** 上传任务 ID */
id: TaskId;
/** 存储桶的名称，格式为<bucketname-appid>，例如examplebucket-1250000000 */
Bucket: Bucket;
/** 存储桶所在地域 @see https://cloud.tencent.com/document/product/436/6224 */
Region: Region;
/** 请求的对象键，最前面不带 /，例如 images/1.jpg */
Key: Key;
/** 要上传的本地文件路径 */
FilePath: string;
/** 上传状态 */
state: 'waiting' | 'checking' | 'uploading' | 'error' | 'paused' | 'success' | 'canceled';
/** 上传错误信息 */
error: string | Error | { Code: string; Message: string };
/** 已上传内容大小，单位 B（字节） */
loaded: number;
/** 上传文件大小，单位 B（字节） */
size: number;
/** 上传速递，单位 B/s */
speed: number;
/** 上传进度，范围 0-1，保留两位小数 */
percent: number;
/** 续传校验进度，范围 0-1，保留两位小数 */
hashPercent: number;
};
/** 上传任务列表 */
type TaskList = Task[];
// request
/** request 接口参数 */
interface RequestParams {
Bucket?: Bucket;
Region?: Region;
/** 操作方法，如 get，post，delete， head 等 HTTP 方法 */
Method: string;
/** 请求的对象键，最前面不带 / */
Key?: Key;
/** 请求里的 Url Query 参数 */
Query?: Query;
/** 请求里的 Body 参数 */
Body?: UploadBody;
/** 请求的 API 动作接口(可理解为不带 = 的 Query 参数)，如 acl、tagging、image_process 等 */
Action?: Action;
/** 请求url */
Url?: string;
/** 返回值body是否不需要解析 */
RawBody?: boolean;
ContentType?: string;
/** 请求时带上的 Header 字段 */
Headers?: Headers;
}
/** Request 接口返回值 */
interface RequestResult extends GeneralResult {
Body?: Buffer;
Response?: any;
}
// getObjectUrl
/** getObjectUrl 接口参数 */
interface GetObjectUrlParams extends ObjectParams {
/** 获取的 Url 是否计算签名 */
Sign?: boolean;
/** 请求方法 */
Method?: Method;
/** 请求里的 Url Query 参数，传入该值中的 key/value 将会被 URLEncode */
Query?: Query;
/** 请求里的 Url Query 参数。传入该值将直接拼接在 Url 上，不会对其进行 URLEncode */
QueryString?: string;
/** 签名几秒后失效，默认为900秒 */
Expires?: number;
/** 是否使用全球加速 */
UseAccelerate?: boolean;
/** 调用操作存储桶和对象的 API 时自定义请求域名。可以使用模板，如"{Bucket}.cos.{Region}.myqcloud.com"，即在调用 API 时会使用参数中传入的 Bucket 和 Region 进行替换。 */
Domain?: string;
/** http协议，枚举值'http:','https:' */
Protocol?: string;
}
/** getObjectUrl 接口返回值 */
interface GetObjectUrlResult {
/** 返回对象 Url */
Url: string;
}
interface DownloadFileParams {
Bucket: Bucket;
Region: Region;
Key: Key;
FilePath: string;
ChunkSize?: number;
ParallelLimit?: number;
RetryTimes?: number;
TaskId?: string;
onTaskReady?: (TaskId: COS.TaskId) => void;
onProgress?: onProgress;
}
interface DownloadFileResult extends GeneralResult {
/** 对象的实体标签（Entity Tag），是对象被创建时标识对象内容的信息标签，可用于检查对象的内容是否发生变化，例如"8e0b617ca298a564c3331da28dcb50df"。此头部并不一定返回对象的 MD5 值，而是根据对象上传和加密方式而有所不同 */
ETag: ETag;
/** 对象的版本 ID */
VersionId?: string;
}
interface DownloadFileResult extends GeneralResult {
/** 对象的实体标签（Entity Tag），是对象被创建时标识对象内容的信息标签，可用于检查对象的内容是否发生变化，例如"8e0b617ca298a564c3331da28dcb50df"。此头部并不一定返回对象的 MD5 值，而是根据对象上传和加密方式而有所不同 */
ETag: ETag,
/** 对象的版本 ID */
VersionId?: string,
}
// getV4Auth
interface GetV4AuthParams {
/** 计算签名用的密钥 SecretId，如果不传会用实例本身的凭证，可选 */
SecretId?: string;
/** 计算签名用的密钥 SecretKey，如果不传会用实例本身的凭证，可选 */
SecretKey?: string;
/** 存储桶的名称，命名规则为 BucketName-APPID，例如 examplebucket-1250000000 */
Bucket?: Bucket;
/** 请求的对象键，最前面不带 /，例如 images/1.jpg */
Key?: Key;
/** 签名几秒后失效，默认为900秒 */
Expires?: number;
}
// getAuth
interface GetAuthParams {
/** 计算签名用的密钥 SecretId，如果不传会用实例本身的凭证，可选 */
SecretId?: string;
/** 计算签名用的密钥 SecretKey，如果不传会用实例本身的凭证，可选 */
SecretKey?: string;
/** 请求的存储桶，如果传入了 Bucket、Region，签名会默认加上 Host 字段，可选 */
Bucket?: Bucket;
/** 请求的地域，如果传入了 Bucket、Region，签名会默认加上 Host 字段，可选 */
Region?: Region;
/** 请求方法 */
Method?: Method;
/** 请求的对象键，最前面不带 /，例如 images/1.jpg */
Key?: Key;
/** 签名几秒后失效，默认为900秒 */
Expires?: number;
/** 请求里的 Url Query 参数 */
Query?: Query;
/** 请求里的 Header 参数 */
Headers?: Headers;
/** 默认将host加入签名计算，关闭后可能导致越权风险，建议保持为true */
ForceSignHost?: boolean;
}
}
/**
* COS 类，创建该类的实例可用于调用 COS API
* @see https://cloud.tencent.com/document/product/436/7751
*/
declare class COS {
// 构造方法
constructor(options: COS.COSOptions);
// 静态属性
/** 当前 SDK 版本号 */
static version: string;
// 静态方法
/** 计算签名 */
static getAuthorization: (options: COS.StaticGetAuthorizationOptions) => string;
/** 工具 */
static util: COS.Util;
// 实例方法
/** 获取用户的 bucket 列表 @see https://cloud.tencent.com/document/product/436/8291 */
getService(params: COS.GetServiceParams, callback: (err: COS.CosError, data: COS.GetServiceResult) => void): void;
getService(params: COS.GetServiceParams): Promise<COS.GetServiceResult>;
/** 创建 Bucket，并初始化访问权限 @see https://cloud.tencent.com/document/product/436/7738 */
putBucket(params: COS.PutBucketParams, callback: (err: COS.CosError, data: COS.PutBucketResult) => void): void;
putBucket(params: COS.PutBucketParams): Promise<COS.PutBucketResult>;
/** 查看是否存在该 Bucket，是否有权限访问 @see https://cloud.tencent.com/document/product/436/7735 */
headBucket(params: COS.HeadBucketParams, callback: (err: COS.CosError, data: COS.HeadBucketResult) => void): void;
headBucket(params: COS.HeadBucketParams): Promise<COS.HeadBucketResult>;
/** 获取 Bucket 下的 Object 列表 @see https://cloud.tencent.com/document/product/436/7734 */
getBucket(params: COS.GetBucketParams, callback: (err: COS.CosError, data: COS.GetBucketResult) => void): void;
getBucket(params: COS.GetBucketParams): Promise<COS.GetBucketResult>;
/** 获取 Bucket 下的 Object 版本列表 @see https://cloud.tencent.com/document/product/436/35521 */
listObjectVersions(
params: COS.ListObjectVersionsParams,
callback: (err: COS.CosError, data: COS.ListObjectVersionsResult) => void,
): void;
listObjectVersions(params: COS.ListObjectVersionsParams): Promise<COS.ListObjectVersionsResult>;
/** 删除 Bucket @see https://cloud.tencent.com/document/product/436/7732 */
deleteBucket(
params: COS.DeleteBucketParams,
callback: (err: COS.CosError, data: COS.DeleteBucketResult) => void,
): void;
deleteBucket(params: COS.DeleteBucketParams): Promise<COS.DeleteBucketResult>;
/** 设置 Bucket 的 权限列表 @see https://cloud.tencent.com/document/product/436/7737 */
putBucketAcl(
params: COS.PutBucketAclParams,
callback: (err: COS.CosError, data: COS.PutBucketAclResult) => void,
): void;
putBucketAcl(params: COS.PutBucketAclParams): Promise<COS.PutBucketAclResult>;
/** 获取 Bucket 的 权限列表 @see https://cloud.tencent.com/document/product/436/7733 */
getBucketAcl(
params: COS.GetBucketAclParams,
callback: (err: COS.CosError, data: COS.GetBucketAclResult) => void,
): void;
getBucketAcl(params: COS.GetBucketAclParams): Promise<COS.GetBucketAclResult>;
/** 设置 Bucket 的 跨域设置 @see https://cloud.tencent.com/document/product/436/8279 */
putBucketCors(
params: COS.PutBucketCorsParams,
callback: (err: COS.CosError, data: COS.PutBucketCorsResult) => void,
): void;
putBucketCors(params: COS.PutBucketCorsParams): Promise<COS.PutBucketCorsResult>;
/** 获取 Bucket 的 跨域设置 @see https://cloud.tencent.com/document/product/436/8274 */
getBucketCors(
params: COS.GetBucketCorsParams,
callback: (err: COS.CosError, data: COS.GetBucketCorsResult) => void,
): void;
getBucketCors(params: COS.GetBucketCorsParams): Promise<COS.GetBucketCorsResult>;
/** 删除 Bucket 的 跨域设置 @see https://cloud.tencent.com/document/product/436/8283 */
deleteBucketCors(
params: COS.DeleteBucketCorsParams,
callback: (err: COS.CosError, data: COS.DeleteBucketCorsResult) => void,
): void;
deleteBucketCors(params: COS.DeleteBucketCorsParams): Promise<COS.DeleteBucketCorsResult>;
/** 获取 Bucket 的 地域信息 */
getBucketLocation(
params: COS.GetBucketLocationParams,
callback: (err: COS.CosError, data: COS.GetBucketLocationResult) => void,
): void;
getBucketLocation(params: COS.GetBucketLocationParams): Promise<COS.GetBucketLocationResult>;
/** 获取 Bucket 的读取权限策略 @see https://cloud.tencent.com/document/product/436/8282 */
putBucketPolicy(
params: COS.PutBucketPolicyParams,
callback: (err: COS.CosError, data: COS.PutBucketPolicyResult) => void,
): void;
putBucketPolicy(params: COS.PutBucketPolicyParams): Promise<COS.PutBucketPolicyResult>;
/** 获取 Bucket 的读取权限策略 @see https://cloud.tencent.com/document/product/436/8276 */
getBucketPolicy(
params: COS.GetBucketPolicyParams,
callback: (err: COS.CosError, data: COS.GetBucketPolicyResult) => void,
): void;
getBucketPolicy(params: COS.GetBucketPolicyParams): Promise<COS.GetBucketPolicyResult>;
/** 删除 Bucket 的 跨域设置 @see https://cloud.tencent.com/document/product/436/8285 */
deleteBucketPolicy(
params: COS.DeleteBucketPolicyParams,
callback: (err: COS.CosError, data: COS.DeleteBucketPolicyResult) => void,
): void;
deleteBucketPolicy(params: COS.DeleteBucketPolicyParams): Promise<COS.DeleteBucketPolicyResult>;
/** 设置 Bucket 的标签 @see https://cloud.tencent.com/document/product/436/34838 */
putBucketTagging(
params: COS.PutBucketTaggingParams,
callback: (err: COS.CosError, data: COS.PutBucketTaggingResult) => void,
): void;
putBucketTagging(params: COS.PutBucketTaggingParams): Promise<COS.PutBucketTaggingResult>;
/** 获取 Bucket 的标签设置 @see https://cloud.tencent.com/document/product/436/34837 */
getBucketTagging(
params: COS.GetBucketTaggingParams,
callback: (err: COS.CosError, data: COS.GetBucketTaggingResult) => void,
): void;
getBucketTagging(params: COS.GetBucketTaggingParams): Promise<COS.GetBucketTaggingResult>;
/** 删除 Bucket 的 标签设置 @see https://cloud.tencent.com/document/product/436/34836 */
deleteBucketTagging(
params: COS.DeleteBucketTaggingParams,
callback: (err: COS.CosError, data: COS.DeleteBucketTaggingResult) => void,
): void;
deleteBucketTagging(params: COS.DeleteBucketTaggingParams): Promise<COS.DeleteBucketTaggingResult>;
/** 设置 Bucket 生命周期 @see https://cloud.tencent.com/document/product/436/8280 */
putBucketLifecycle(
params: COS.PutBucketLifecycleParams,
callback: (err: COS.CosError, data: COS.PutBucketLifecycleResult) => void,
): void;
putBucketLifecycle(params: COS.PutBucketLifecycleParams): Promise<COS.PutBucketLifecycleResult>;
/** 获取 Bucket 生命周期 @see https://cloud.tencent.com/document/product/436/8280 */
getBucketLifecycle(
params: COS.GetBucketLifecycleParams,
callback: (err: COS.CosError, data: COS.GetBucketLifecycleResult) => void,
): void;
getBucketLifecycle(params: COS.GetBucketLifecycleParams): Promise<COS.GetBucketLifecycleResult>;
/** 删除 Bucket 生命周期 @see https://cloud.tencent.com/document/product/436/8278 */
deleteBucketLifecycle(
params: COS.DeleteBucketLifecycleParams,
callback: (err: COS.CosError, data: COS.DeleteBucketLifecycleResult) => void,
): void;
deleteBucketLifecycle(params: COS.DeleteBucketLifecycleParams): Promise<COS.DeleteBucketLifecycleResult>;
/** 设置 Bucket 版本 @see https://cloud.tencent.com/document/product/436/19889 */
putBucketVersioning(
params: COS.PutBucketVersioningParams,
callback: (err: COS.CosError, data: COS.PutBucketVersioningResult) => void,
): void;
putBucketVersioning(params: COS.PutBucketVersioningParams): Promise<COS.PutBucketVersioningResult>;
/** 获取 Bucket 版本 @see https://cloud.tencent.com/document/product/436/19888 */
getBucketVersioning(
params: COS.GetBucketVersioningParams,
callback: (err: COS.CosError, data: COS.GetBucketVersioningResult) => void,
): void;
getBucketVersioning(params: COS.GetBucketVersioningParams): Promise<COS.GetBucketVersioningResult>;
/** 设置 Bucket 副本 @see https://cloud.tencent.com/document/product/436/19223 */
putBucketReplication(
params: COS.PutBucketReplicationParams,
callback: (err: COS.CosError, data: COS.PutBucketReplicationResult) => void,
): void;
putBucketReplication(params: COS.PutBucketReplicationParams): Promise<COS.PutBucketReplicationResult>;
/** 获取 Bucket 副本 @see https://cloud.tencent.com/document/product/436/19222 */
getBucketReplication(
params: COS.GetBucketReplicationParams,
callback: (err: COS.CosError, data: COS.GetBucketReplicationResult) => void,
): void;
getBucketReplication(params: COS.GetBucketReplicationParams): Promise<COS.GetBucketReplicationResult>;
/** 删除 Bucket 副本 @see https://cloud.tencent.com/document/product/436/19221 */
deleteBucketReplication(
params: COS.DeleteBucketReplicationParams,
callback: (err: COS.CosError, data: COS.DeleteBucketReplicationResult) => void,
): void;
deleteBucketReplication(params: COS.DeleteBucketReplicationParams): Promise<COS.DeleteBucketReplicationResult>;
/** 设置 Bucket 静态网站配置信息 @see https://cloud.tencent.com/document/product/436/31930 */
putBucketWebsite(
params: COS.PutBucketWebsiteParams,
callback: (err: COS.CosError, data: COS.PutBucketWebsiteResult) => void,
): void;
putBucketWebsite(params: COS.PutBucketWebsiteParams): Promise<COS.PutBucketWebsiteResult>;
/** 获取 Bucket 的静态网站配置信息 @see https://cloud.tencent.com/document/product/436/31929 */
getBucketWebsite(
params: COS.GetBucketWebsiteParams,
callback: (err: COS.CosError, data: COS.GetBucketWebsiteResult) => void,
): void;
getBucketWebsite(params: COS.GetBucketWebsiteParams): Promise<COS.GetBucketWebsiteResult>;
/** 删除 Bucket 的静态网站配置 @see https://cloud.tencent.com/document/product/436/31928 */
deleteBucketWebsite(
params: COS.DeleteBucketWebsiteParams,
callback: (err: COS.CosError, data: COS.DeleteBucketWebsiteResult) => void,
): void;
deleteBucketWebsite(params: COS.DeleteBucketWebsiteParams): Promise<COS.DeleteBucketWebsiteResult>;
/** 设置 Bucket 的防盗链白名单或者黑名单 @see https://cloud.tencent.com/document/product/436/32492 */
putBucketReferer(
params: COS.PutBucketRefererParams,
callback: (err: COS.CosError, data: COS.PutBucketRefererResult) => void,
): void;
putBucketReferer(params: COS.PutBucketRefererParams): Promise<COS.PutBucketRefererResult>;
/** 获取 Bucket 的防盗链白名单或者黑名单 @see https://cloud.tencent.com/document/product/436/32493 */
getBucketReferer(
params: COS.GetBucketRefererParams,
callback: (err: COS.CosError, data: COS.GetBucketRefererResult) => void,
): void;
getBucketReferer(params: COS.GetBucketRefererParams): Promise<COS.GetBucketRefererResult>;
/** 设置 Bucket 自定义域名 */
putBucketDomain(
params: COS.PutBucketDomainParams,
callback: (err: COS.CosError, data: COS.PutBucketDomainResult) => void,
): void;
putBucketDomain(params: COS.PutBucketDomainParams): Promise<COS.PutBucketDomainResult>;
/** 获取 Bucket 的自定义域名 */
getBucketDomain(
params: COS.GetBucketDomainParams,
callback: (err: COS.CosError, data: COS.GetBucketDomainResult) => void,
): void;
getBucketDomain(params: COS.GetBucketDomainParams): Promise<COS.GetBucketDomainResult>;
/** 删除 Bucket 自定义域名 */
deleteBucketDomain(
params: COS.DeleteBucketDomainParams,
callback: (err: COS.CosError, data: COS.DeleteBucketDomainResult) => void,
): void;
deleteBucketDomain(params: COS.DeleteBucketDomainParams): Promise<COS.DeleteBucketDomainResult>;
/** 设置 Bucket 的回源 */
putBucketOrigin(
params: COS.PutBucketOriginParams,
callback: (err: COS.CosError, data: COS.PutBucketOriginResult) => void,
): void;
putBucketOrigin(params: COS.PutBucketOriginParams): Promise<COS.PutBucketOriginResult>;
/** 获取 Bucket 的回源 */
getBucketOrigin(
params: COS.GetBucketOriginParams,
callback: (err: COS.CosError, data: COS.GetBucketOriginResult) => void,
): void;
getBucketOrigin(params: COS.GetBucketOriginParams): Promise<COS.GetBucketOriginResult>;
/** 删除 Bucket 的回源 */
deleteBucketOrigin(
params: COS.DeleteBucketOriginParams,
callback: (err: COS.CosError, data: COS.DeleteBucketOriginResult) => void,
): void;
deleteBucketOrigin(params: COS.DeleteBucketOriginParams): Promise<COS.DeleteBucketOriginResult>;
/** 设置 Bucket 的日志记录 @see https://cloud.tencent.com/document/product/436/17054 */
putBucketLogging(
params: COS.PutBucketLoggingParams,
callback: (err: COS.CosError, data: COS.PutBucketLoggingResult) => void,
): void;
putBucketLogging(params: COS.PutBucketLoggingParams): Promise<COS.PutBucketLoggingResult>;
/** 获取 Bucket 的日志记录 @see https://cloud.tencent.com/document/product/436/17053 */
getBucketLogging(
params: COS.GetBucketLoggingParams,
callback: (err: COS.CosError, data: COS.GetBucketLoggingResult) => void,
): void;
getBucketLogging(params: COS.GetBucketLoggingParams): Promise<COS.GetBucketLoggingResult>;
/** 创建/编辑 Bucket 的清单任务 @see https://cloud.tencent.com/document/product/436/33707 */
putBucketInventory(
params: COS.PutBucketInventoryParams,
callback: (err: COS.CosError, data: COS.PutBucketInventoryResult) => void,
): void;
putBucketInventory(params: COS.PutBucketInventoryParams): Promise<COS.PutBucketInventoryResult>;
/** 获取 Bucket 的清单任务信息 @see https://cloud.tencent.com/document/product/436/33705 */
getBucketInventory(
params: COS.GetBucketInventoryParams,
callback: (err: COS.CosError, data: COS.GetBucketInventoryResult) => void,
): void;
getBucketInventory(params: COS.GetBucketInventoryParams): Promise<COS.GetBucketInventoryResult>;
/** 获取 Bucket 的清单任务信息 @see https://cloud.tencent.com/document/product/436/33706 */
listBucketInventory(
params: COS.ListBucketInventoryParams,
callback: (err: COS.CosError, data: COS.ListBucketInventoryResult) => void,
): void;
listBucketInventory(params: COS.ListBucketInventoryParams): Promise<COS.ListBucketInventoryResult>;
/** 删除 Bucket 的清单任务 @see https://cloud.tencent.com/document/product/436/33704 */
deleteBucketInventory(
params: COS.DeleteBucketInventoryParams,
callback: (err: COS.CosError, data: COS.DeleteBucketInventoryResult) => void,
): void;
deleteBucketInventory(params: COS.DeleteBucketInventoryParams): Promise<COS.DeleteBucketInventoryResult>;
/** 启用或者暂停存储桶的全球加速功能 @see https://cloud.tencent.com/document/product/436/38869 */
putBucketAccelerate(
params: COS.PutBucketAccelerateParams,
callback: (err: COS.CosError, data: COS.PutBucketAccelerateResult) => void,
): void;
putBucketAccelerate(params: COS.PutBucketAccelerateParams): Promise<COS.PutBucketAccelerateResult>;
/** 查询存储桶的全球加速功能配置 @see https://cloud.tencent.com/document/product/436/38868 */
getBucketAccelerate(
params: COS.GetBucketAccelerateParams,
callback: (err: COS.CosError, data: COS.GetBucketAccelerateResult) => void,
): void;
getBucketAccelerate(params: COS.GetBucketAccelerateParams): Promise<COS.GetBucketAccelerateResult>;
/** 设置指定存储桶下的默认加密配置 @see https://cloud.tencent.com/document/product/436/40136 */
putBucketEncryption(
params: COS.PutBucketEncryptionParams,
callback: (err: COS.CosError, data: COS.PutBucketEncryptionResult) => void,
): void;
putBucketEncryption(params: COS.PutBucketEncryptionParams): Promise<COS.PutBucketEncryptionResult>;
/** 查询指定存储桶下的默认加密配置 @see https://cloud.tencent.com/document/product/436/40137 */
getBucketEncryption(
params: COS.GetBucketEncryptionParams,
callback: (err: COS.CosError, data: COS.GetBucketEncryptionResult) => void,
): void;
getBucketEncryption(params: COS.GetBucketEncryptionParams): Promise<COS.GetBucketEncryptionResult>;
/** 删除指定存储桶下的默认加密配置 @see https://cloud.tencent.com/document/product/436/40138 */
deleteBucketEncryption(
params: COS.DeleteBucketEncryptionParams,
callback: (err: COS.CosError, data: COS.DeleteBucketEncryptionResult) => void,
): void;
deleteBucketEncryption(params: COS.DeleteBucketEncryptionParams): Promise<COS.DeleteBucketEncryptionResult>;
/** 取回对应对象（Object）的元数据，Head的权限与Get的权限一致 @see https://cloud.tencent.com/document/product/436/7745 */
headObject(params: COS.HeadObjectParams, callback: (err: COS.CosError, data: COS.HeadObjectResult) => void): void;
headObject(params: COS.HeadObjectParams): Promise<COS.HeadObjectResult>;
/** 下载对象（Object） @see https://cloud.tencent.com/document/product/436/7753 */
getObject(params: COS.GetObjectParams, callback: (err: COS.CosError, data: COS.GetObjectResult) => void): void;
getObject(params: COS.GetObjectParams): Promise<COS.GetObjectResult>;
/** 下载对象（Object），返回 Stream 对象 @see https://cloud.tencent.com/document/product/436/7753 */
getObjectStream(
params: COS.GetObjectParams,
callback?: (err: COS.CosError, data: COS.GetObjectResult) => void,
): Stream;
/** 简单上传对象（Object）至指定存储桶 @see https://cloud.tencent.com/document/product/436/7749 */
putObject(params: COS.PutObjectParams, callback: (err: COS.CosError, data: COS.PutObjectResult) => void): void;
putObject(params: COS.PutObjectParams): Promise<COS.PutObjectResult>;
/** 删除一个指定的对象（Object） @see https://cloud.tencent.com/document/product/436/7743 */
deleteObject(
params: COS.DeleteObjectParams,
callback: (err: COS.CosError, data: COS.DeleteObjectResult) => void,
): void;
deleteObject(params: COS.DeleteObjectParams): Promise<COS.DeleteObjectResult>;
/** 批量删除指定存储桶中的多个对象（Object） @see https://cloud.tencent.com/document/product/436/8289 */
deleteMultipleObject(
params: COS.DeleteMultipleObjectParams,
callback: (err: COS.CosError, data: COS.DeleteMultipleObjectResult) => void,
): void;
deleteMultipleObject(params: COS.DeleteMultipleObjectParams): Promise<COS.DeleteMultipleObjectResult>;
/** 获取 Object 的权限列表 @see https://cloud.tencent.com/document/product/436/7744 */
getObjectAcl(
params: COS.GetObjectAclParams,
callback: (err: COS.CosError, data: COS.GetObjectAclResult) => void,
): void;
getObjectAcl(params: COS.GetObjectAclParams): Promise<COS.GetObjectAclResult>;
/** 设置 Object 的权限列表 @see https://cloud.tencent.com/document/product/436/7748 */
putObjectAcl(
params: COS.PutObjectAclParams,
callback: (err: COS.CosError, data: COS.PutObjectAclResult) => void,
): void;
putObjectAcl(params: COS.PutObjectAclParams): Promise<COS.PutObjectAclResult>;
/** 跨域资源共享（CORS）的预检（Preflight）请求 @see https://cloud.tencent.com/document/product/436/8288 */
optionsObject(
params: COS.OptionsObjectParams,
callback: (err: COS.CosError, data: COS.OptionsObjectResult) => void,
): void;
optionsObject(params: COS.OptionsObjectParams): Promise<COS.OptionsObjectResult>;
/** 恢复归档对象 @see https://cloud.tencent.com/document/product/436/12633 */
restoreObject(
params: COS.RestoreObjectParams,
callback: (err: COS.CosError, data: COS.RestoreObjectResult) => void,
): void;
restoreObject(params: COS.RestoreObjectParams): Promise<COS.RestoreObjectResult>;
/** 检索对象内容 @see https://cloud.tencent.com/document/product/436/37641 */
selectObjectContent(
params: COS.SelectObjectContentParams,
callback: (err: COS.CosError, data: COS.SelectObjectContentResult) => void,
): void;
selectObjectContent(params: COS.SelectObjectContentParams): Promise<COS.SelectObjectContentResult>;
/** 检索对象内容，返回 Stream 对象 @see https://cloud.tencent.com/document/product/436/37641 */
selectObjectContentStream(
params: COS.SelectObjectContentParams,
callback?: (err: COS.CosError, data: COS.SelectObjectContentResult) => void,
): Stream;
/** 复制对象 @see https://cloud.tencent.com/document/product/436/10881 */
putObjectCopy(
params: COS.PutObjectCopyParams,
callback: (err: COS.CosError, data: COS.PutObjectCopyResult) => void,
): void;
putObjectCopy(params: COS.PutObjectCopyParams): Promise<COS.PutObjectCopyResult>;
/** 设置对象标签 @see https://cloud.tencent.com/document/product/436/42997 */
putObjectTagging(
params: COS.PutObjectTaggingParams,
callback: (err: COS.CosError, data: COS.PutObjectTaggingResult) => void,
): void;
putObjectTagging(params: COS.PutObjectTaggingParams): Promise<COS.PutObjectTaggingResult>;
/** 查询对象标签 @see https://cloud.tencent.com/document/product/436/42998 */
getObjectTagging(
params: COS.GetObjectTaggingParams,
callback: (err: COS.CosError, data: COS.GetObjectTaggingResult) => void,
): void;
getObjectTagging(params: COS.GetObjectTaggingParams): Promise<COS.GetObjectTaggingResult>;
/** 删除对象标签 @see https://cloud.tencent.com/document/product/436/42999 */
deleteObjectTagging(
params: COS.DeleteObjectTaggingParams,
callback: (err: COS.CosError, data: COS.DeleteObjectTaggingResult) => void,
): void;
deleteObjectTagging(params: COS.DeleteObjectTaggingParams): Promise<COS.DeleteObjectTaggingResult>;
/** 初始化分块上传 @see https://cloud.tencent.com/document/product/436/7746 */
multipartInit(
params: COS.MultipartInitParams,
callback: (err: COS.CosError, data: COS.MultipartInitResult) => void,
): void;
multipartInit(params: COS.MultipartInitParams): Promise<COS.MultipartInitResult>;
/** 分块上传 @see https://cloud.tencent.com/document/product/436/7750 */
multipartUpload(
params: COS.MultipartUploadParams,
callback: (err: COS.CosError, data: COS.MultipartUploadResult) => void,
): void;
multipartUpload(params: COS.MultipartUploadParams): Promise<COS.MultipartUploadResult>;
/** 分块上传 @see https://cloud.tencent.com/document/product/436/8287 */
uploadPartCopy(
params: COS.UploadPartCopyParams,
callback: (err: COS.CosError, data: COS.UploadPartCopyResult) => void,
): void;
uploadPartCopy(params: COS.UploadPartCopyParams): Promise<COS.UploadPartCopyResult>;
/** 完成分块上传 @see https://cloud.tencent.com/document/product/436/7742 */
multipartComplete(
params: COS.MultipartCompleteParams,
callback: (err: COS.CosError, data: COS.MultipartCompleteResult) => void,
): void;
multipartComplete(params: COS.MultipartCompleteParams): Promise<COS.MultipartCompleteResult>;
/** 分块上传任务列表查询 @see https://cloud.tencent.com/document/product/436/7736 */
multipartList(
params: COS.MultipartListParams,
callback: (err: COS.CosError, data: COS.MultipartListResult) => void,
): void;
multipartList(params: COS.MultipartListParams): Promise<COS.MultipartListResult>;
/** 上传的分块列表查询 @see https://cloud.tencent.com/document/product/436/7747 */
multipartListPart(
params: COS.MultipartListPartParams,
callback: (err: COS.CosError, data: COS.MultipartListPartResult) => void,
): void;
multipartListPart(params: COS.MultipartListPartParams): Promise<COS.MultipartListPartResult>;
/** 抛弃分块上传 @see https://cloud.tencent.com/document/product/436/7740 */
multipartAbort(
params: COS.MultipartAbortParams,
callback: (err: COS.CosError, data: COS.MultipartAbortResult) => void,
): void;
multipartAbort(params: COS.MultipartAbortParams): Promise<COS.MultipartAbortResult>;
/** 分片上传文件，封装好分片上传的多个步骤的上传方法。 */
sliceUploadFile(
params: COS.SliceUploadFileParams,
callback: (err: COS.CosError, data: COS.SliceUploadFileResult) => void,
): void;
sliceUploadFile(params: COS.SliceUploadFileParams): Promise<COS.SliceUploadFileResult>;
/** 清理分片上传 UploadId，封装好的清理单个文件或存储桶所有文件未完成的 UploadId。 */
abortUploadTask(
params: COS.AbortUploadTaskParams,
callback: (err: COS.CosError, data: COS.AbortUploadTaskResult) => void,
): void;
abortUploadTask(params: COS.AbortUploadTaskParams): Promise<COS.AbortUploadTaskResult>;
/** 高级上传文件 */
uploadFile(params: COS.UploadFileParams, callback: (err: COS.CosError, data: COS.UploadFileResult) => void): void;
uploadFile(params: COS.UploadFileParams): Promise<COS.UploadFileResult>;
/** 批量上传文件 */
uploadFiles(params: COS.UploadFilesParams, callback: (err: COS.CosError, data: COS.UploadFilesResult) => void): void;
uploadFiles(params: COS.UploadFilesParams): Promise<COS.UploadFilesResult>;
/** 分片复制文件 */
sliceCopyFile(
params: COS.SliceCopyFileParams,
callback: (err: COS.CosError, data: COS.SliceCopyFileResult) => void,
): void;
sliceCopyFile(params: COS.SliceCopyFileParams): Promise<COS.SliceCopyFileResult>;
/** 获取上传任务列表 */
getTaskList(): COS.TaskList;
/** 暂停任务 */
pauseTask(taskId: COS.TaskId): void;
/** 重启任务 */
restartTask(taskId: COS.TaskId): void;
/** 取消任务 */
cancelTask(taskId: COS.TaskId): void;
/** 判断上传队列是否有未完成的任务 */
isUploadRunning(): boolean;
/** cos.request */
request(params: COS.RequestParams, callback: (err: COS.CosError, data: COS.RequestResult) => void): void;
request(params: COS.RequestParams): Promise<COS.RequestResult>;
/** 获取文件下载链接 @see https://cloud.tencent.com/document/product/436/35651 */
getObjectUrl(
params: COS.GetObjectUrlParams,
callback: (err: COS.CosError, data: COS.GetObjectUrlResult) => void,
): string;
/** 追加上传 @see https://cloud.tencent.com/document/product/436/7741 */
appendObject(params: COS.AppendObjectParams, callback: (err: COS.CosError, data: COS.GeneralResult) => void): void;
appendObject(params: COS.AppendObjectParams): Promise<COS.GeneralResult>;
/** 分块下载 @see https://cloud.tencent.com/document/product/436/64981#.E5.88.86.E5.9D.97.E4.B8.8B.E8.BD.BD.E5.AF.B9.E8.B1.A1 */
downloadFile(
params: COS.DownloadFileParams,
callback: (err: COS.CosError, data: COS.DownloadFileResult) => void,
): void;
downloadFile(params: COS.DownloadFileParams): Promise<COS.DownloadFileResult>;
/** 获取 COS JSON API (v4) 签名 @see https://cloud.tencent.com/document/product/436/6054 */
getV4Auth(params: COS.GetV4AuthParams): COS.Authorization;
/** 获取 COS XMl API (v5) 签名 @see https://cloud.tencent.com/document/product/436/7778 */
getAuth(params: COS.GetAuthParams): COS.Authorization;
on(action: string, callback: (params?: any) => void): void;
off(action: string, callback: (params?: any) => void): void;
emit(action: string, data?: any): void;
}
export = COS;