esa-cli 0.0.1-beta.1

package/dist/libs/apiService.js

@@ -0,0 +1,914 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as $OpenApi from '@alicloud/openapi-client';
+import FormData from 'form-data';
+import fetch from 'node-fetch';
+import { Environment } from './interface.js';
+import { getApiConfig } from '../utils/fileUtils/index.js';
+import chain from 'lodash';
+import t from '../i18n/index.js';
+export class ApiService {
+    constructor(cliConfig) {
+        var _a, _b;
+        let apiConfig = new $OpenApi.Config({
+            accessKeyId: (_a = cliConfig.auth) === null || _a === void 0 ? void 0 : _a.accessKeyId,
+            accessKeySecret: (_b = cliConfig.auth) === null || _b === void 0 ? void 0 : _b.accessKeySecret,
+            endpoint: cliConfig.endpoint
+        });
+        this.client = new $OpenApi.default.default(apiConfig);
+    }
+    static getInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ApiService.instance) {
+                const config = getApiConfig();
+                ApiService.instance = new ApiService(config);
+            }
+            return ApiService.instance;
+        });
+    }
+    updateConfig(newConfig) {
+        var _a, _b;
+        let apiConfig = new $OpenApi.Config({
+            accessKeyId: (_a = newConfig.auth) === null || _a === void 0 ? void 0 : _a.accessKeyId,
+            accessKeySecret: (_b = newConfig.auth) === null || _b === void 0 ? void 0 : _b.accessKeySecret,
+            endpoint: newConfig.endpoint
+        });
+        this.client = new $OpenApi.default.default(apiConfig);
+    }
+    /**
+     * Checks if the user is logged in.
+     * @returns A promise that resolves to an object with the following properties:
+     *   - success: A boolean indicating if the login check was successful.
+     *   - message: (Optional) A string providing additional information in case of failure.
+     */
+    checkLogin() {
+        return __awaiter(this, arguments, void 0, function* (isShowError = true) {
+            try {
+                let params = {
+                    action: 'GetErService',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest({
+                    query: {}
+                });
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const response = yield this.client.callApi(params, request, runtime);
+                if (response.statusCode === 200) {
+                    return { success: true };
+                }
+                else if (response.statusCode === 403) {
+                    return {
+                        success: false,
+                        message: t('login_permission_denied').d('Permission denied: Access key or secret is incorrect, or does not have the necessary permissions.')
+                    };
+                }
+                else {
+                    return {
+                        success: false,
+                        message: `${t('common_error_occurred').d('An error occurred')}: ${response.statusCode}`
+                    };
+                }
+            }
+            catch (error) {
+                isShowError && console.log(error);
+                return {
+                    success: false,
+                    message: t('login_failed').d('An error occurred while trying to log in.')
+                };
+            }
+        });
+    }
+    quickDeployRoutine(edgeRoutine) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // 上传代码到unstable版本
+                const stagingRes = yield this.getRoutineStagingCodeUploadInfo(edgeRoutine);
+                if (stagingRes) {
+                    // 生产版本
+                    const commitRes = yield this.commitRoutineStagingCode({
+                        Name: edgeRoutine.name,
+                        CodeDescription: edgeRoutine.description
+                    });
+                    // 发布到生产环境
+                    if (commitRes) {
+                        const deployRes = yield this.publishRoutineCodeVersion({
+                            Name: edgeRoutine.name,
+                            CodeVersion: commitRes.data.CodeVersion,
+                            Env: Environment.Production
+                        });
+                        return deployRes && Number(deployRes.code) === 200;
+                    }
+                }
+                return false;
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return false;
+        });
+    }
+    publishRoutineCodeVersion(requestParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                let params = {
+                    action: 'PublishRoutineCodeVersion',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const CanaryAreaList = (_a = requestParams.CanaryAreaList) !== null && _a !== void 0 ? _a : [];
+                const CanaryAreaListString = JSON.stringify(CanaryAreaList);
+                let request = new $OpenApi.OpenApiRequest({
+                    query: {
+                        Env: requestParams.Env,
+                        Name: requestParams.Name,
+                        CodeVersion: requestParams.CodeVersion,
+                        CanaryCodeVersion: requestParams.CanaryCodeVersion,
+                        CanaryAreaList: CanaryAreaListString
+                    }
+                });
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200 && res.body) {
+                    const ret = {
+                        code: res.statusCode,
+                        data: {
+                            CodeVersion: res.body.CodeVersion,
+                            RequestId: res.body.RequestId
+                        }
+                    };
+                    return ret;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+    getMatchSite(requestParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {
+                    action: 'GetMatchSite',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest({
+                    query: {
+                        RecordName: requestParams.RecordName
+                    }
+                });
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200 && res.body) {
+                    const ret = {
+                        code: res.statusCode,
+                        data: {
+                            SiteId: res.body.SiteId,
+                            SiteName: res.body.SiteName
+                        }
+                    };
+                    return ret;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+    listRoutineCanaryAreas() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {
+                    action: 'ListRoutineCanaryAreas',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest();
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200 && res.body) {
+                    const ret = {
+                        CanaryAreas: res.body.CanaryAreas
+                    };
+                    return ret;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+    getRoutineUserInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {
+                    action: 'GetRoutineUserInfo',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest();
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200 && res.body) {
+                    const ret = {
+                        Subdomains: res.body.RoutineName,
+                        Routines: res.body.Routines
+                    };
+                    return ret;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+    deleteRoutine(requestParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {
+                    action: 'DeleteRoutine',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest({
+                    query: {
+                        Name: requestParams.Name
+                    }
+                });
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200 && res.body) {
+                    const ret = {
+                        Status: res.body.Status
+                    };
+                    return ret;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+    deleteRoutineCodeVersion(requestParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {
+                    action: 'DeleteRoutineCodeVersion',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest({
+                    query: {
+                        Name: requestParams.Name,
+                        CodeVersion: requestParams.CodeVersion
+                    }
+                });
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200 && res.body) {
+                    const ret = {
+                        Status: res.body.Status
+                    };
+                    return ret;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+    createRoutineRelatedRoute(requestParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {
+                    action: 'CreateRoutineRelatedRoute',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest({
+                    query: {
+                        Route: requestParams.Route,
+                        SiteId: requestParams.SiteId,
+                        SiteName: requestParams.SiteName,
+                        Name: requestParams.Name
+                    }
+                });
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200 && res.body) {
+                    const ret = {
+                        code: res.statusCode,
+                        data: {
+                            RequestId: res.body.RequestId,
+                            Status: res.body.Status
+                        }
+                    };
+                    return ret;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+    deleteRoutineRelatedRoute(requestParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {
+                    action: 'DeleteRoutineRelatedRoute',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest({
+                    query: {
+                        Route: requestParams.Route,
+                        RouteId: requestParams.RouteId,
+                        SiteId: requestParams.SiteId,
+                        SiteName: requestParams.SiteName,
+                        Name: requestParams.Name
+                    }
+                });
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200 && res.body) {
+                    const ret = {
+                        code: res.statusCode,
+                        data: {
+                            RequestId: res.body.RequestId,
+                            Status: res.body.Status
+                        }
+                    };
+                    return ret;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+    listSites(requestParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {
+                    action: 'ListSites',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest({
+                    query: requestParams
+                });
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200) {
+                    const response = {
+                        code: res.statusCode,
+                        data: {
+                            TotalCount: res.body.TotalCount,
+                            RequestId: res.body.RequestId,
+                            PageSize: res.body.PageSize,
+                            PageNumber: res.body.PageNumber,
+                            Sites: res.body.Sites
+                        }
+                    };
+                    return response;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+    getRoutineStagingEnvIp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {
+                    action: 'GetRoutineStagingEnvIp',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest({});
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200) {
+                    const response = {
+                        code: res.statusCode,
+                        data: {
+                            IPV4: res.body.IPV4,
+                            RequestId: res.body.RequestId
+                        }
+                    };
+                    return response;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+    getRoutine(requestParams_1) {
+        return __awaiter(this, arguments, void 0, function* (requestParams, isShowError = true) {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            try {
+                let params = {
+                    action: 'getRoutine',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest({
+                    query: {
+                        Name: requestParams.Name
+                    }
+                });
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200 && res.body) {
+                    const routineResponse = {
+                        code: res.statusCode,
+                        data: {
+                            RequestId: (_a = res.body) === null || _a === void 0 ? void 0 : _a.RequestId,
+                            CodeVersions: ((_b = res.body) === null || _b === void 0 ? void 0 : _b.CodeVersions) || [],
+                            RelatedRecords: ((_c = res.body) === null || _c === void 0 ? void 0 : _c.RelatedRecords) || [],
+                            Envs: ((_d = res.body) === null || _d === void 0 ? void 0 : _d.Envs) || [],
+                            CreateTime: (_e = res.body) === null || _e === void 0 ? void 0 : _e.CreateTime,
+                            Description: (_f = res.body) === null || _f === void 0 ? void 0 : _f.Description,
+                            RelatedRoutes: ((_g = res.body) === null || _g === void 0 ? void 0 : _g.RelatedRoutes) || [],
+                            DefaultRelatedRecord: (_h = res.body) === null || _h === void 0 ? void 0 : _h.DefaultRelatedRecord
+                        }
+                    };
+                    return routineResponse;
+                }
+            }
+            catch (error) {
+                if (isShowError) {
+                    console.log(error);
+                }
+            }
+            return null;
+        });
+    }
+    createRoutine(edgeRoutine) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let params = {
+                action: 'CreateRoutine',
+                version: '2024-09-10',
+                protocol: 'https',
+                method: 'GET',
+                authType: 'AK',
+                bodyType: 'json',
+                reqBodyType: 'json',
+                style: 'RPC',
+                pathname: '/',
+                toMap: function () {
+                    return this;
+                }
+            };
+            let request = new $OpenApi.OpenApiRequest({
+                query: {
+                    Name: edgeRoutine.name,
+                    Description: edgeRoutine.description,
+                    SpecName: edgeRoutine.specName
+                }
+            });
+            let runtime = {
+                toMap: function () {
+                    return this;
+                }
+            };
+            try {
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200 && res.body) {
+                    const ret = {
+                        code: res.statusCode,
+                        data: {
+                            RequestId: res.body.RequestId,
+                            Status: res.body.Status
+                        }
+                    };
+                    return ret;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+    getRoutineStagingCodeUploadInfo(edgeRoutine) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {
+                    action: 'GetRoutineStagingCodeUploadInfo',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest({
+                    query: {
+                        Name: edgeRoutine.name
+                    }
+                });
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const uploadResult = yield this.client.callApi(params, request, runtime);
+                const ossConfig = chain(uploadResult).get('body.OssPostConfig');
+                if (uploadResult.statusCode !== 200 || !ossConfig) {
+                    return false;
+                }
+                const { OSSAccessKeyId, Signature, callback, Url, key, policy } = ossConfig;
+                const formData = new FormData();
+                formData.append('OSSAccessKeyId', OSSAccessKeyId);
+                formData.append('Signature', Signature);
+                formData.append('callback', callback);
+                formData.append('x:codeDescription', ossConfig['x:codeDescription']);
+                formData.append('policy', policy);
+                formData.append('key', key);
+                formData.append('file', edgeRoutine.code);
+                // TODO: 检查oss结果;
+                const ossRes = yield fetch(Url, {
+                    method: 'POST',
+                    body: formData,
+                    headers: formData.getHeaders()
+                });
+                if (ossRes && ossRes.status === 200) {
+                    return true;
+                }
+                return false;
+            }
+            catch (error) {
+                console.log(error);
+                return false;
+            }
+        });
+    }
+    commitRoutineStagingCode(requestParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {
+                    action: 'CommitRoutineStagingCode',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest({
+                    query: {
+                        Name: requestParams.Name,
+                        CodeDescription: requestParams.CodeDescription
+                    }
+                });
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200 && res.body) {
+                    const ret = {
+                        code: res.statusCode,
+                        data: {
+                            RequestId: res.body.RequestId,
+                            CodeVersion: res.body.CodeVersion
+                        }
+                    };
+                    return ret;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+    listRoutineSpecs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {
+                    action: 'ListRoutineSpecs',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest();
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200 && res.body) {
+                    const ret = {
+                        code: res.statusCode,
+                        data: {
+                            RequestId: res.body.RequestId,
+                            Specs: res.body.Specs
+                        }
+                    };
+                    return ret;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+    createRoutineRelatedRecord(requestParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {
+                    action: 'CreateRoutineRelatedRecord',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest({
+                    query: {
+                        RecordName: requestParams.RecordName,
+                        SiteId: requestParams.SiteId,
+                        SiteName: requestParams.SiteName,
+                        Name: requestParams.Name
+                    }
+                });
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200 && res.body) {
+                    const ret = {
+                        code: res.statusCode,
+                        data: {
+                            Status: res.body.Status,
+                            RequestId: res.body.RequestId
+                        }
+                    };
+                    return ret;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+    deleteRoutineRelatedRecord(requestParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {
+                    action: 'DeleteRoutineRelatedRecord',
+                    version: '2024-09-10',
+                    protocol: 'https',
+                    method: 'GET',
+                    authType: 'AK',
+                    bodyType: 'json',
+                    reqBodyType: 'json',
+                    style: 'RPC',
+                    pathname: '/',
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                let request = new $OpenApi.OpenApiRequest({
+                    query: {
+                        RecordName: requestParams.RecordName,
+                        SiteId: requestParams.SiteId,
+                        SiteName: requestParams.SiteName,
+                        Name: requestParams.Name,
+                        RecordId: requestParams.RecordId
+                    }
+                });
+                let runtime = {
+                    toMap: function () {
+                        return this;
+                    }
+                };
+                const res = yield this.client.callApi(params, request, runtime);
+                if (res.statusCode === 200 && res.body) {
+                    const ret = {
+                        code: res.statusCode,
+                        data: {
+                            Status: res.body.Status,
+                            RequestId: res.body.RequestId
+                        }
+                    };
+                    return ret;
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+            return null;
+        });
+    }
+}
+ApiService.instance = null;