tencentcloud-sdk-nodejs 4.1.119 → 4.1.121

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tencentcloud-sdk-nodejs",
-  "version": "4.1.119",
+  "version": "4.1.121",
   "description": "腾讯云 API NODEJS SDK",
   "main": "./tencentcloud/index.js",
   "module": "./es/index.js",
@@ -36,6 +36,7 @@
     "form-data": "^3.0.4",
     "get-stream": "^6.0.0",
     "https-proxy-agent": "^5.0.0",
+    "ini": "^5.0.0",
     "is-stream": "^2.0.0",
     "json-bigint": "^1.0.0",
     "node-fetch": "^2.2.0",
@@ -51,6 +52,7 @@
     "url": "https://github.com/tencentcloud/tencentcloud-sdk-nodejs"
   },
   "devDependencies": {
+    "@types/ini": "^4.1.1",
     "@types/json-bigint": "^1.0.1",
     "@types/node": "^18.0.0",
     "@types/node-fetch": "^2.5.7",

package/tencentcloud/common/credential.d.ts

@@ -0,0 +1,101 @@
+import { ClientConfig, Credential, CredentialResult, DynamicCredential } from "./interface";
+/**
+ * Basic credential with secret id and secret key
+ */
+export declare class BasicCredential implements Credential {
+    readonly secretId: string;
+    readonly secretKey: string;
+    readonly token?: string;
+    constructor(secretId: string, secretKey: string, token?: string);
+}
+/**
+ * Environment variable credential
+ * Get credential from environment variables:
+ * - TENCENTCLOUD_SECRET_ID
+ * - TENCENTCLOUD_SECRET_KEY
+ * - TENCENTCLOUD_SESSION_TOKEN (optional)
+ */
+export declare class EnvironmentVariableCredential implements DynamicCredential {
+    getCredential(): Promise<Credential>;
+}
+/**
+ * Profile credential
+ * Get credential from profile file ~/.tencentcloud/credentials or /etc/tencentcloud/credentials
+ * example credentials file:
+ * [default]
+ * secret_id = your-secret-id
+ * secret_key = your-secret-key
+ */
+export declare class ProfileCredential implements DynamicCredential {
+    getCredential(): Promise<Credential>;
+}
+interface AssumeRoleParams {
+    RoleArn: string;
+    RoleSessionName: string;
+    [key: string]: any;
+}
+/**
+ * Tencent Cloud Credential via STS service
+ * @see {@link https://cloud.tencent.com/document/api/1312/48197} for more information.
+ */
+export declare class STSCredential implements DynamicCredential {
+    private clientConfig;
+    private assumeRoleParams;
+    private endpoint;
+    private version;
+    private action;
+    private region;
+    credentialTask: Promise<CredentialResult> | null;
+    /**
+     * Constructs a new STSCredential instance
+     *
+     * @param {ClientConfig} clientConfig Request client Configuration object
+     * @param {AssumeRoleParams} assumeRoleParams Request parameters of the AssumeRole interface
+     * @see {@link https://cloud.tencent.com/document/api/1312/48197} for more AssumeRoleParams information.
+     */
+    constructor(clientConfig: ClientConfig, assumeRoleParams: AssumeRoleParams);
+    protected getCredentialWithStsAssumeRole(): Promise<CredentialResult>;
+    getCredential(): Promise<Credential>;
+}
+/**
+ * CVM Role credential using existing implementation
+ * Re-export the existing CvmRoleCredential for consistency
+ */
+export { default as CvmRoleCredential } from "./cvm_role_credential";
+/**
+ * TencentCloud OIDC Credential
+ * OIDC is an authentication protocol built on OAuth 2.0. Tencent Cloud CAM supports OIDC role-based SSO.
+ * @see {@link https://cloud.tencent.com/document/product/598/96013} for more information.
+ */
+export declare class OIDCRoleArnCredential implements DynamicCredential {
+    private endpoint;
+    private version;
+    private action;
+    private clientConfig;
+    private assumeRoleWithWebIdentityParams;
+    private defaultSessionName;
+    private isTke;
+    protected region: string;
+    protected expirationReservationTime: number;
+    protected credentialTask: Promise<CredentialResult> | null;
+    /**
+     * Constructs a new OIDCRoleArnCredential instance
+     *
+     * @param {ClientConfig} [clientConfig] Optional request client Configuration object
+     * @param {AssumeRoleParams} [assumeRoleParams] Optional request parameters of the AssumeRole interface
+     * @see {@link https://cloud.tencent.com/document/api/1312/48197} for more AssumeRoleWithWebIdentity information.
+     */
+    constructor();
+    constructor(clientConfig: ClientConfig, assumeRoleWithWebIdentityParams: AssumeRoleParams);
+    private initFromTke;
+    protected getCredentialWithStsAssumeRoleWithWebIdentity(): Promise<CredentialResult>;
+    getCredential(): Promise<Credential>;
+}
+/**
+ * Tencent Cloud DefaultCredentialProvider
+ */
+export declare class DefaultCredentialProvider implements DynamicCredential {
+    private readonly providers;
+    constructor();
+    getCredential(): Promise<Credential>;
+}

package/tencentcloud/common/credential.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultCredentialProvider = exports.OIDCRoleArnCredential = exports.CvmRoleCredential = exports.STSCredential = exports.ProfileCredential = exports.EnvironmentVariableCredential = exports.BasicCredential = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const os_1 = require("os");
+const ini_1 = require("ini");
+const common_client_1 = require("./common_client");
+const cvm_role_credential_1 = tslib_1.__importDefault(require("./cvm_role_credential"));
+const EXPIRE_BUFFER = 30 * 1000;
+/**
+ * Basic credential with secret id and secret key
+ */
+class BasicCredential {
+    constructor(secretId, secretKey, token) {
+        this.secretId = secretId;
+        this.secretKey = secretKey;
+        this.token = token;
+    }
+}
+exports.BasicCredential = BasicCredential;
+/**
+ * Environment variable credential
+ * Get credential from environment variables:
+ * - TENCENTCLOUD_SECRET_ID
+ * - TENCENTCLOUD_SECRET_KEY
+ * - TENCENTCLOUD_SESSION_TOKEN (optional)
+ */
+class EnvironmentVariableCredential {
+    async getCredential() {
+        const secretId = process.env.TENCENTCLOUD_SECRET_ID;
+        const secretKey = process.env.TENCENTCLOUD_SECRET_KEY;
+        const token = process.env.TENCENTCLOUD_SESSION_TOKEN;
+        return new BasicCredential(secretId, secretKey, token);
+    }
+}
+exports.EnvironmentVariableCredential = EnvironmentVariableCredential;
+/**
+ * Profile credential
+ * Get credential from profile file ~/.tencentcloud/credentials or /etc/tencentcloud/credentials
+ * example credentials file:
+ * [default]
+ * secret_id = your-secret-id
+ * secret_key = your-secret-key
+ */
+class ProfileCredential {
+    async getCredential() {
+        let filePath = '';
+        // Try user home directory first
+        const userHome = (0, os_1.homedir)();
+        const userCredentialsPath = path_1.default.join(userHome, ".tencentcloud", "credentials");
+        if (fs_1.default.existsSync(userCredentialsPath)) {
+            filePath = userCredentialsPath;
+        }
+        else {
+            // Try system directory as fallback
+            filePath = '/etc/tencentcloud/credentials';
+        }
+        if (filePath) {
+            try {
+                const content = fs_1.default.readFileSync(filePath, "utf8");
+                const { default: { secret_id, secret_key, token } } = (0, ini_1.parse)(content);
+                if (secret_id && secret_key) {
+                    return new BasicCredential(secret_id, secret_key, token);
+                }
+            }
+            catch (error) {
+                // Ignore errors when reading user credentials
+            }
+        }
+        return new BasicCredential('', '');
+    }
+}
+exports.ProfileCredential = ProfileCredential;
+/**
+ * Tencent Cloud Credential via STS service
+ * @see {@link https://cloud.tencent.com/document/api/1312/48197} for more information.
+ */
+class STSCredential {
+    /**
+     * Constructs a new STSCredential instance
+     *
+     * @param {ClientConfig} clientConfig Request client Configuration object
+     * @param {AssumeRoleParams} assumeRoleParams Request parameters of the AssumeRole interface
+     * @see {@link https://cloud.tencent.com/document/api/1312/48197} for more AssumeRoleParams information.
+     */
+    constructor(clientConfig, assumeRoleParams) {
+        this.clientConfig = clientConfig;
+        this.assumeRoleParams = assumeRoleParams;
+        this.endpoint = 'sts.tencentcloudapi.com';
+        this.version = '2018-08-13';
+        this.action = 'AssumeRole';
+        this.region = 'ap-guangzhou';
+    }
+    async getCredentialWithStsAssumeRole() {
+        const { endpoint, version, action, region, clientConfig, assumeRoleParams } = this;
+        try {
+            const client = new common_client_1.CommonClient(endpoint, version, {
+                region,
+                ...clientConfig
+            });
+            const result = await client.request(action, assumeRoleParams);
+            return {
+                TmpSecretId: result.Credentials.TmpSecretId,
+                TmpSecretKey: result.Credentials.TmpSecretKey,
+                Token: result.Credentials.Token,
+                ExpiredTime: result.ExpiredTime,
+                Expiration: result.Expiration,
+            };
+        }
+        catch (error) {
+            throw new Error(`Get STS AssumeRole failed: ${error.message}`);
+        }
+    }
+    async getCredential() {
+        if (!this.credentialTask) {
+            this.credentialTask = this.getCredentialWithStsAssumeRole();
+        }
+        const credential = await this.credentialTask;
+        // Check if the credential is expired
+        if (credential.ExpiredTime * 1000 - EXPIRE_BUFFER <= Date.now()) {
+            this.credentialTask = null;
+            return this.getCredential();
+        }
+        return {
+            secretId: credential.TmpSecretId,
+            secretKey: credential.TmpSecretKey,
+            token: credential.Token,
+        };
+    }
+}
+exports.STSCredential = STSCredential;
+/**
+ * CVM Role credential using existing implementation
+ * Re-export the existing CvmRoleCredential for consistency
+ */
+var cvm_role_credential_2 = require("./cvm_role_credential");
+Object.defineProperty(exports, "CvmRoleCredential", { enumerable: true, get: function () { return tslib_1.__importDefault(cvm_role_credential_2).default; } });
+/**
+ * TencentCloud OIDC Credential
+ * OIDC is an authentication protocol built on OAuth 2.0. Tencent Cloud CAM supports OIDC role-based SSO.
+ * @see {@link https://cloud.tencent.com/document/product/598/96013} for more information.
+ */
+class OIDCRoleArnCredential {
+    constructor(clientConfig, assumeRoleWithWebIdentityParams) {
+        this.endpoint = 'sts.tencentcloudapi.com';
+        this.version = '2018-08-13';
+        this.action = 'AssumeRoleWithWebIdentity';
+        this.defaultSessionName = 'tencentcloud-node-sdk-';
+        this.isTke = false;
+        this.expirationReservationTime = 600;
+        if (clientConfig && assumeRoleWithWebIdentityParams) {
+            this.clientConfig = clientConfig;
+            this.assumeRoleWithWebIdentityParams = assumeRoleWithWebIdentityParams;
+        }
+        else {
+            this.isTke = true;
+            this.clientConfig = {
+                credential: new BasicCredential('', ''),
+                ...clientConfig,
+            };
+        }
+    }
+    initFromTke() {
+        const region = process.env.TKE_REGION;
+        if (!region) {
+            throw new Error('env TKE_REGION not exist');
+        }
+        const providerId = process.env.TKE_PROVIDER_ID;
+        if (!providerId) {
+            throw new Error('env TKE_PROVIDER_ID not exist');
+        }
+        const tokenFile = process.env.TKE_WEB_IDENTITY_TOKEN_FILE;
+        if (!tokenFile) {
+            throw new Error('env TKE_WEB_IDENTITY_TOKEN_FILE not exist');
+        }
+        let wbIdentityToken;
+        try {
+            wbIdentityToken = fs_1.default.readFileSync(tokenFile).toString();
+        }
+        catch (error) {
+            throw new Error(`failed to read token file: ${error.message}`);
+        }
+        const roleArn = process.env.TKE_ROLE_ARN;
+        if (!roleArn) {
+            throw new Error('env TKE_ROLE_ARN not exist');
+        }
+        this.clientConfig.region = region;
+        this.assumeRoleWithWebIdentityParams = {
+            RoleArn: roleArn,
+            RoleSessionName: `${this.defaultSessionName}${Date.now() * 1000}`,
+            WebIdentityToken: wbIdentityToken,
+            ProviderId: providerId,
+        };
+    }
+    async getCredentialWithStsAssumeRoleWithWebIdentity() {
+        try {
+            if (this.isTke) {
+                this.initFromTke();
+            }
+            const { endpoint, version, action, region, clientConfig, assumeRoleWithWebIdentityParams } = this;
+            const client = new common_client_1.CommonClient(endpoint, version, {
+                region: region,
+                ...clientConfig,
+            });
+            const result = await client.request(action, assumeRoleWithWebIdentityParams);
+            return {
+                TmpSecretId: result.Credentials.TmpSecretId,
+                TmpSecretKey: result.Credentials.TmpSecretKey,
+                Token: result.Credentials.Token,
+                ExpiredTime: result.ExpiredTime,
+                Expiration: result.Expiration,
+            };
+        }
+        catch (error) {
+            throw new Error(`Get STS AssumeRoleWithWebIdentity failed: ${error.message}`);
+        }
+    }
+    async getCredential() {
+        if (!this.credentialTask) {
+            this.credentialTask = this.getCredentialWithStsAssumeRoleWithWebIdentity();
+        }
+        const credential = await this.credentialTask;
+        // Check if the credential is expired
+        if (credential.ExpiredTime * 1000 - this.expirationReservationTime <= Date.now()) {
+            this.credentialTask = null;
+            return this.getCredential();
+        }
+        return {
+            secretId: credential.TmpSecretId,
+            secretKey: credential.TmpSecretKey,
+            token: credential.Token,
+        };
+    }
+}
+exports.OIDCRoleArnCredential = OIDCRoleArnCredential;
+/**
+ * Tencent Cloud DefaultCredentialProvider
+ */
+class DefaultCredentialProvider {
+    constructor() {
+        this.providers = [
+            new EnvironmentVariableCredential(),
+            new ProfileCredential(),
+            new cvm_role_credential_1.default(),
+            new OIDCRoleArnCredential()
+        ];
+    }
+    async getCredential() {
+        for (const provider of this.providers) {
+            try {
+                const credential = await provider.getCredential();
+                if (credential.secretId && credential.secretKey) {
+                    return credential;
+                }
+            }
+            catch (error) {
+                // Continue to next provider if current one fails
+                console.error(error);
+                continue;
+            }
+        }
+        return new BasicCredential('', '');
+    }
+}
+exports.DefaultCredentialProvider = DefaultCredentialProvider;

package/tencentcloud/common/cvm_role_credential.d.ts

@@ -1,10 +1,5 @@
-import { Credential, DynamicCredential } from "./interface";
-interface CvmRoleCredentialResult {
-    TmpSecretId: string;
-    TmpSecretKey: string;
-    ExpiredTime: 1671330188;
-    Expiration: string;
-    Token: string;
+import { Credential, DynamicCredential, CredentialResult } from "./interface";
+interface CvmRoleCredentialResult extends CredentialResult {
     Code: string;
 }
 /**

package/tencentcloud/common/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./abstract_client";
 export * from "./common_client";
 export * from "./interface";
+export * from './credential';

package/tencentcloud/common/index.js

@@ -4,3 +4,4 @@ const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./abstract_client"), exports);
 tslib_1.__exportStar(require("./common_client"), exports);
 tslib_1.__exportStar(require("./interface"), exports);
+tslib_1.__exportStar(require("./credential"), exports);

package/tencentcloud/common/interface.d.ts

@@ -113,3 +113,10 @@ export interface Credential {
 export interface DynamicCredential {
     getCredential(): Promise<Credential>;
 }
+export interface CredentialResult {
+    TmpSecretId: string;
+    TmpSecretKey: string;
+    ExpiredTime: number;
+    Expiration: string;
+    Token: string;
+}

package/tencentcloud/common/sdk_version.d.ts

@@ -1 +1 @@
-export declare const sdkVersion = "4.1.119";
+export declare const sdkVersion = "4.1.121";

package/tencentcloud/common/sdk_version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sdkVersion = void 0;
-exports.sdkVersion = "4.1.119";
+exports.sdkVersion = "4.1.121";

package/tencentcloud/services/ai3d/v20250513/ai3d_client.d.ts

@@ -14,12 +14,12 @@ export declare class Client extends AbstractClient {
     QueryHunyuanTo3DJob(req: QueryHunyuanTo3DJobRequest, cb?: (error: string, rep: QueryHunyuanTo3DJobResponse) => void): Promise<QueryHunyuanTo3DJobResponse>;
     /**
      * 混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
-默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+默认提供3个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
      */
     SubmitHunyuanTo3DProJob(req: SubmitHunyuanTo3DProJobRequest, cb?: (error: string, rep: SubmitHunyuanTo3DProJobResponse) => void): Promise<SubmitHunyuanTo3DProJobResponse>;
     /**
      * 混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
-默认提供3个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
      */
     QueryHunyuanTo3DRapidJob(req: QueryHunyuanTo3DRapidJobRequest, cb?: (error: string, rep: QueryHunyuanTo3DRapidJobResponse) => void): Promise<QueryHunyuanTo3DRapidJobResponse>;
     /**
@@ -29,12 +29,12 @@ export declare class Client extends AbstractClient {
     SubmitHunyuanTo3DJob(req: SubmitHunyuanTo3DJobRequest, cb?: (error: string, rep: SubmitHunyuanTo3DJobResponse) => void): Promise<SubmitHunyuanTo3DJobResponse>;
     /**
      * 混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
-默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+默认提供3个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
      */
     QueryHunyuanTo3DProJob(req: QueryHunyuanTo3DProJobRequest, cb?: (error: string, rep: QueryHunyuanTo3DProJobResponse) => void): Promise<QueryHunyuanTo3DProJobResponse>;
     /**
      * 混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
-默认提供3个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
      */
     SubmitHunyuanTo3DRapidJob(req: SubmitHunyuanTo3DRapidJobRequest, cb?: (error: string, rep: SubmitHunyuanTo3DRapidJobResponse) => void): Promise<SubmitHunyuanTo3DRapidJobResponse>;
 }

package/tencentcloud/services/ai3d/v20250513/ai3d_client.js

@@ -36,14 +36,14 @@ class Client extends abstract_client_1.AbstractClient {
     }
     /**
      * 混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
-默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+默认提供3个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
      */
     async SubmitHunyuanTo3DProJob(req, cb) {
         return this.request("SubmitHunyuanTo3DProJob", req, cb);
     }
     /**
      * 混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
-默认提供3个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
      */
     async QueryHunyuanTo3DRapidJob(req, cb) {
         return this.request("QueryHunyuanTo3DRapidJob", req, cb);
@@ -57,14 +57,14 @@ class Client extends abstract_client_1.AbstractClient {
     }
     /**
      * 混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
-默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+默认提供3个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
      */
     async QueryHunyuanTo3DProJob(req, cb) {
         return this.request("QueryHunyuanTo3DProJob", req, cb);
     }
     /**
      * 混元生3D接口，基于混元大模型，根据输入的文本描述/图片智能生成3D。
-默认提供3个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
+默认提供1个并发，代表最多能同时处理1个已提交的任务，上一个任务处理完毕后，才能开始处理下一个任务。
      */
     async SubmitHunyuanTo3DRapidJob(req, cb) {
         return this.request("SubmitHunyuanTo3DRapidJob", req, cb);

package/tencentcloud/services/apm/v20210622/apm_client.d.ts

@@ -1,6 +1,6 @@
 import { AbstractClient } from "../../../common/abstract_client";
 import { ClientConfig } from "../../../common/interface";
-import { ModifyApmInstanceRequest, CreateApmInstanceRequest, ModifyGeneralApmApplicationConfigRequest, DescribeServiceOverviewResponse, TerminateApmInstanceRequest, DescribeApmInstancesResponse, DescribeTagValuesResponse, DescribeServiceOverviewRequest, DescribeApmAgentResponse, DescribeTagValuesRequest, DescribeGeneralSpanListResponse, CreateProfileTaskResponse, DescribeGeneralSpanListRequest, DescribeMetricRecordsResponse, DescribeGeneralOTSpanListResponse, DescribeGeneralOTSpanListRequest, DescribeApmAgentRequest, DescribeMetricRecordsRequest, DescribeGeneralApmApplicationConfigResponse, DescribeGeneralMetricDataRequest, CreateApmInstanceResponse, CreateProfileTaskRequest, DescribeGeneralApmApplicationConfigRequest, ModifyApmInstanceResponse, DescribeApmInstancesRequest, DescribeGeneralMetricDataResponse, ModifyGeneralApmApplicationConfigResponse, TerminateApmInstanceResponse } from "./apm_models";
+import { ModifyApmInstanceRequest, CreateApmInstanceRequest, ModifyGeneralApmApplicationConfigRequest, DescribeApmServiceMetricRequest, DescribeServiceOverviewResponse, TerminateApmInstanceRequest, DescribeApmInstancesResponse, DescribeTagValuesResponse, DescribeServiceOverviewRequest, DescribeApmAgentResponse, DescribeTagValuesRequest, DescribeGeneralSpanListResponse, CreateProfileTaskResponse, DescribeGeneralSpanListRequest, DescribeApmServiceMetricResponse, DescribeMetricRecordsResponse, DescribeGeneralOTSpanListResponse, DescribeGeneralOTSpanListRequest, DescribeApmAgentRequest, DescribeMetricRecordsRequest, DescribeGeneralApmApplicationConfigResponse, DescribeGeneralMetricDataRequest, CreateApmInstanceResponse, CreateProfileTaskRequest, DescribeGeneralApmApplicationConfigRequest, ModifyApmInstanceResponse, DescribeApmInstancesRequest, DescribeGeneralMetricDataResponse, ModifyGeneralApmApplicationConfigResponse, TerminateApmInstanceResponse } from "./apm_models";
 /**
  * apm client
  * @class
@@ -60,6 +60,10 @@ export declare class Client extends AbstractClient {
      * 业务购买 APM 业务系统，调用该接口创建
      */
     CreateApmInstance(req: CreateApmInstanceRequest, cb?: (error: string, rep: CreateApmInstanceResponse) => void): Promise<CreateApmInstanceResponse>;
+    /**
+     * 获取 APM 应用指标列表
+     */
+    DescribeApmServiceMetric(req: DescribeApmServiceMetricRequest, cb?: (error: string, rep: DescribeApmServiceMetricResponse) => void): Promise<DescribeApmServiceMetricResponse>;
     /**
      * 应用概览数据拉取
      */

package/tencentcloud/services/apm/v20210622/apm_client.js

@@ -106,6 +106,12 @@ class Client extends abstract_client_1.AbstractClient {
     async CreateApmInstance(req, cb) {
         return this.request("CreateApmInstance", req, cb);
     }
+    /**
+     * 获取 APM 应用指标列表
+     */
+    async DescribeApmServiceMetric(req, cb) {
+        return this.request("DescribeApmServiceMetric", req, cb);
+    }
     /**
      * 应用概览数据拉取
      */