hexo/node_modules/cos-nodejs-sdk-v5/index.d.ts

2586 lines
129 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/**
* 腾讯云 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;
/** 分块上传时每片的字节数大小默认值10485761MB */
ChunkSize?: number;
/** 使用 uploadFiles 批量上传时,文件大小大于该数值将使用按分块上传,否则将调用简单上传,单位 Byte默认值10485761MB */
SliceSize?: number;
/** 进行分块复制操作中复制分块上传的并发数默认值20 */
CopyChunkParallelLimit?: number;
/** 使用 sliceCopyFile 分块复制文件时每片的大小字节数默认值1048576010MB */
CopyChunkSize?: number;
/** 使用 sliceCopyFile 分块复制文件时,文件大小大于该数值将使用分块复制 否则将调用简单复制默认值1048576010MB */
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.jpgPathname 和 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;
/** 指明规则是否启用枚举值EnabledDisabled必选 */
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;
/** 存储类型枚举值STANDARDINTELLIGENT_TIERINGSTANDARD_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或404HttpErrorCodeReturnedEquals 与 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/example192.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清单中将会包含所有对象版本并在清单中增加 VersionIdIsLatestDeleteMarker 这几个字段,如果设置为 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 状态码为304Not Modified */
IfModifiedSince?: string;
/** 当对象在指定时间后未被修改,则返回对象,否则返回 HTTP 状态码为412Precondition Failed */
IfUnmodifiedSince?: string;
/** 当对象的 ETag 与指定的值一致,则返回对象,否则返回 HTTP 状态码为412Precondition Failed */
IfMatch?: string;
/** 当对象的 ETag 与指定的值不一致,则返回对象,否则返回 HTTP 状态码为304Not 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;
/** 是否复制源对象的元数据信息枚举值CopyReplaced默认为 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 状态码为412Precondition Failed */
CopySourceIfModifiedSince?: string;
/** 当对象在指定时间后未被修改,则执行复制操作,否则返回 HTTP 状态码为412Precondition Failed */
CopySourceIfUnmodifiedSince?: string;
/** 当对象的 ETag 与指定的值一致,则执行复制操作,否则返回 HTTP 状态码为412Precondition Failed */
CopySourceIfMatch?: string;
/** 当对象的 ETag 与指定的值不一致,则执行复制操作,否则返回 HTTP 状态码为412Precondition 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;
/** 分块上传时每片的字节数大小默认值10485761MB */
ChunkSize?: number;
/** 分块上传时每片的字节数大小默认值10485761MB */
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';
/** 要清理的 UploadIdLevel 为 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默认值10485761MB */
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默认值10485761MB */
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 分块复制文件时,文件大小大于该数值将使用分块复制 否则将调用简单复制默认值1048576010MB */
CopySliceSize?: number;
/** 使用 sliceCopyFile 分块复制文件时每片的大小字节数默认值1048576010MB */
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;
/** 操作方法,如 getpostdelete 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;