@byted-apaas/server-sdk-node 1.1.23 → 1.1.24

package/context/resources/impl/resources.js

@@ -0,0 +1,161 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._Resources = exports._OpenSDKResources = exports._KunlunFile = exports._KunlunOpenSDKFile = void 0;
+const stream_1 = require("stream");
+const Request = require("../../../request/interface");
+const common_1 = require("../../../application/impl/common");
+const common = require("@byted-apaas/server-common-node");
+const stream_to_buffer_1 = require("@jorgeferrero/stream-to-buffer");
+const exceptions = common.exceptions;
+const fs = require('fs');
+class _KunlunOpenSDKFile {
+    constructor(appCtx) {
+        this.appCtx = appCtx;
+    }
+    async Upload(fileName, source) {
+        // 1. check parameters type
+        if (typeof fileName !== 'string') {
+            throw new exceptions.InvalidParamError('upload method parameter fileName must be string. ');
+        }
+        if (typeof source !== 'string' && !(source instanceof stream_1.Stream) && !(source instanceof Buffer)) {
+            throw new exceptions.InvalidParamError('upload method parameter source must be string or stream or buffer. ');
+        }
+        // 2. divide by source type
+        if (typeof source === 'string') {
+            // upload from path
+            if (!fs.existsSync(source)) {
+                throw new exceptions.InvalidParamError(`no such file '${source}'`);
+            }
+            source = fs.createReadStream(source);
+        }
+        if (source instanceof stream_1.Stream) {
+            // upload from stream
+            source = await (0, stream_to_buffer_1.streamToBuffer)(source);
+        }
+        if (source instanceof Buffer) {
+            return await (0, common_1.runCtxForOpenSDK)(this.appCtx, async () => {
+                return await Request.GetInstance().openSDKUploadFile(fileName, source);
+            });
+        }
+        return null;
+    }
+    ;
+    async UploadAvatar(fileName, source) {
+        // 1. check parameters type
+        if (typeof fileName !== 'string') {
+            throw new exceptions.InvalidParamError('upload method parameter fileName must be string. ');
+        }
+        if (typeof source !== 'string' && !(source instanceof stream_1.Stream) && !(source instanceof Buffer)) {
+            throw new exceptions.InvalidParamError('upload method parameter source must be string or stream or buffer. ');
+        }
+        // 2. divide by source type
+        if (typeof source === 'string') {
+            // upload from path
+            if (!fs.existsSync(source)) {
+                throw new exceptions.InvalidParamError(`no such file '${source}'`);
+            }
+            source = fs.createReadStream(source);
+        }
+        if (source instanceof stream_1.Stream) {
+            // upload from stream
+            source = await (0, stream_to_buffer_1.streamToBuffer)(source);
+        }
+        if (source instanceof Buffer) {
+            // upload from buffer
+            return await (0, common_1.runCtxForOpenSDK)(this.appCtx, async () => {
+                return await Request.GetInstance().openSDKUploadAvatar(fileName, source);
+            });
+        }
+        return null;
+    }
+    ;
+    async Download(fileID) {
+        // 1. check parameters type
+        if (typeof fileID !== 'string') {
+            throw new exceptions.InvalidParamError('download method parameter fileID must be string. ');
+        }
+        return await (0, common_1.runCtxForOpenSDK)(this.appCtx, async () => {
+            return await Request.GetInstance().downloadFileByID(fileID);
+        });
+    }
+    ;
+    async DownloadAvatar(imageID) {
+        // 1. check parameters type
+        if (typeof imageID !== 'string') {
+            throw new exceptions.InvalidParamError('download method parameter imageID must be string. ');
+        }
+        return await (0, common_1.runCtxForOpenSDK)(this.appCtx, async () => {
+            return await Request.GetInstance().openSDKDownloadAvatar(imageID);
+        });
+    }
+    ;
+}
+exports._KunlunOpenSDKFile = _KunlunOpenSDKFile;
+class _KunlunFile {
+    async download(fileTokenOrInfo, filePath) {
+        if (typeof (fileTokenOrInfo) === 'string') {
+            return await Request.GetInstance().downloadFileByToken(fileTokenOrInfo, filePath);
+        }
+        else if (typeof (fileTokenOrInfo) === 'object') {
+            if (!fileTokenOrInfo.id) {
+                throw new exceptions.InvalidParamError(`The value of fileInfo.id is empty`);
+            }
+            if (typeof (fileTokenOrInfo.id) !== 'string') {
+                throw new exceptions.InvalidParamError(`The type of fileInfo.id should be string, but ${typeof (fileTokenOrInfo)}`);
+            }
+            let tokenListStr = await Request.GetInstance().mGetFileToken([fileTokenOrInfo.id]);
+            let id2token;
+            try {
+                id2token = JSON.parse(tokenListStr);
+            }
+            catch (err) {
+                throw new exceptions.InternalError(`parse mGetFileToken resp failed: ${err.message}`);
+            }
+            if (!id2token[fileTokenOrInfo.id]) {
+                throw new exceptions.InternalError(`id (${fileTokenOrInfo.id})'s token is empty`);
+            }
+            return await Request.GetInstance().downloadFileByToken(id2token[fileTokenOrInfo.id], filePath);
+        }
+        else {
+            throw new exceptions.InvalidParamError(`The type of first param should be string or object, but ${typeof (fileTokenOrInfo)}`);
+        }
+    }
+    async upload(data, expire, fileName, ...ret) {
+        if (ret.length > 0) {
+            throw new exceptions.InvalidParamError(`params is too many, as ${ret.length + 2}`);
+        }
+        if (!data) {
+            throw new exceptions.InvalidParamError(`params is null`);
+        }
+        // 1. data is filePath, read it from disk, convert it to Steam.
+        if (typeof (data) === 'string') {
+            if (!fs.existsSync(data)) {
+                throw new exceptions.InvalidParamError(`no such file '${data}'`);
+            }
+            data = fs.createReadStream(data);
+        }
+        // 2. data must be Stream at here.
+        return await Request.GetHttpInstance().uploadFile(data, expire, fileName);
+    }
+}
+exports._KunlunFile = _KunlunFile;
+/**
+ * OpenSDK 静态资源操作类
+ */
+class _OpenSDKResources {
+    constructor(appCtx) {
+        this.file = new _KunlunOpenSDKFile(appCtx);
+    }
+}
+exports._OpenSDKResources = _OpenSDKResources;
+/**
+ * 静态资源操作类
+ */
+class _Resources {
+    constructor() {
+        this.file = new _KunlunFile();
+    }
+}
+exports._Resources = _Resources;

package/context/tasks/tasks.d.ts

@@ -0,0 +1,33 @@
+export declare class _Options {
+    /**
+     * 并发数量，默认值为 5，最大可设置值为 10
+     */
+    concurrency?: number;
+    /**
+     * 单个子任务的最大数据量，默认值为 5，最大可设置值为 100
+     */
+    maxSliceNumber?: number;
+    /**
+     * 触发进度回调函数的步长，以百分比为单位，每当发生大于等于步长的进度变化时，便触发进度回调函数。默认为每当有进度变化时，便触发进度回调函数（进度变化精度为 1%）
+     */
+    progressCallbackStep?: number;
+}
+export declare class Tasks<cf> {
+    private f;
+    constructor(_f?: Function);
+    /**
+     * 创建异步任务
+     * @param apiName 函数的 apiName
+     * @param params 参数
+     */
+    createAsyncTask(apiName: cf, params: object): Promise<void>;
+    /**
+     * 创建分布式任务
+     * @param dataset 待处理数据组成的数组
+     * @param handlerFunc 用于处理数据集的全局函数的 API name
+     * @param progressCallbackFunc 任务进度发生变化时回调的全局函数的 API name，可通过传入 '' / null / undefined 跳过此步骤
+     * @param completedCallbackFunc 任务完成时回调的全局函数的 API name，可通过传入 '' / null / undefined 跳过此步骤
+     * @param options 高级配置参数，可选
+     */
+    createDistributedTask(dataset: any[], handlerFunc: cf, progressCallbackFunc: cf | '' | null | undefined, completedCallbackFunc: cf | '' | null | undefined, options?: _Options): Promise<number>;
+}

package/context/tasks/tasks.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tasks = exports._Options = void 0;
+const common = require("@byted-apaas/server-common-node");
+const Request = require("../../request/interface");
+const utils = common.utils;
+const exceptions = common.exceptions;
+class _Options {
+}
+exports._Options = _Options;
+// export async function asyncTaskV1(apiName: string, params: any, oldFuncName: string, isSync: boolean) {
+//     return await invokeFuncSync(apiName, params, oldFuncName, false);
+// }
+class Tasks {
+    constructor(_f) {
+        this.f = _f;
+    }
+    /**
+     * 创建异步任务
+     * @param apiName 函数的 apiName
+     * @param params 参数
+     */
+    async createAsyncTask(apiName, params) {
+        if (apiName && params) {
+            // low_code 1.0
+            if (utils.isOnlineDev()) {
+                // 1.debug模式
+                if (utils.isDebug()) {
+                    return await this.f(apiName).invoke(params);
+                }
+                // 2.运行时
+                let newApiName = utils.handleFuncName(null, apiName);
+                if (!newApiName) {
+                    throw new exceptions.InvalidParamError(`The function (${apiName}) does not exist, please confirm ${apiName} exists and has been deployed.`);
+                }
+                let idOrName = {};
+                if (newApiName === (apiName)) {
+                    idOrName = {
+                        APIName: newApiName,
+                        isInvokeByAPIName: true,
+                    };
+                }
+                else if (utils.isMicroservice()) {
+                    idOrName = {
+                        APIName: apiName,
+                        isInvokeByAPIName: true,
+                    };
+                }
+                else {
+                    idOrName = {
+                        APIId: newApiName,
+                        isInvokeByAPIName: false,
+                    };
+                }
+                return {
+                    task_id: await Request.GetInstance().createAsyncTaskV1(idOrName, params),
+                };
+            }
+            // low_code 2.0
+            // 如果是本地调试模式，则直接异步执行
+            if (utils.isLocalDebug()) {
+                this.f(apiName).invoke(params);
+                return { task_id: 1234567890123456 };
+            }
+            return {
+                task_id: await Request.GetInstance().createAsyncTaskV2(apiName, params),
+            };
+        }
+        else {
+            throw new exceptions.InvalidParamError(`context.tasks.createAsyncTask params is error`);
+        }
+    }
+    ;
+    /**
+     * 创建分布式任务
+     * @param dataset 待处理数据组成的数组
+     * @param handlerFunc 用于处理数据集的全局函数的 API name
+     * @param progressCallbackFunc 任务进度发生变化时回调的全局函数的 API name，可通过传入 '' / null / undefined 跳过此步骤
+     * @param completedCallbackFunc 任务完成时回调的全局函数的 API name，可通过传入 '' / null / undefined 跳过此步骤
+     * @param options 高级配置参数，可选
+     */
+    async createDistributedTask(dataset, handlerFunc, progressCallbackFunc, completedCallbackFunc, options) {
+        if (utils.isLocalDebug()) {
+            throw new exceptions.InvalidParamError("Local debugging isn't supported for distributed tasks. You can only deploy them to the cloud");
+        }
+        if (utils.getDistributedHandleMask()) {
+            throw new exceptions.InvalidParamError('Does not support creating distributed tasks in handler function and progress callback function');
+        }
+        // dataset
+        if (!(dataset instanceof Array)) {
+            throw new exceptions.InvalidParamError(`parameter dataset is not list`);
+        }
+        // handlerFunc
+        if (!handlerFunc || typeof handlerFunc !== 'string') {
+            throw new exceptions.InvalidParamError(`parameter handlerFunc is not string or handlerFunc is empty`);
+        }
+        // progressCallbackFunc
+        if (progressCallbackFunc === null || progressCallbackFunc === undefined) {
+            progressCallbackFunc = '';
+        }
+        if (typeof progressCallbackFunc !== 'string') {
+            throw new exceptions.InvalidParamError(`parameter progressCallbackFunc is not string`);
+        }
+        // completedCallbackFunc
+        if (completedCallbackFunc === null || completedCallbackFunc === undefined) {
+            completedCallbackFunc = '';
+        }
+        if (typeof completedCallbackFunc !== 'string') {
+            throw new exceptions.InvalidParamError(`parameter completedCallbackFunc is not string`);
+        }
+        // option.concurrency
+        if (options.concurrency === null || options.concurrency === undefined) {
+            options.concurrency = 5;
+        }
+        if ((typeof options.concurrency !== 'number') || options.concurrency <= 0) {
+            throw new exceptions.InvalidParamError(`parameter option.concurrency is not Number or not graterThan 0`);
+        }
+        // option.maxSliceNumber
+        if (options.maxSliceNumber === null || options.maxSliceNumber === undefined) {
+            options.maxSliceNumber = 5;
+        }
+        if ((typeof options.maxSliceNumber !== 'number') || options.maxSliceNumber <= 0) {
+            throw new exceptions.InvalidParamError(`parameter option.maxSliceNumber is not Number or not graterThan 0`);
+        }
+        // option.notifyStep
+        if (options.progressCallbackStep === null || options.progressCallbackStep === undefined) {
+            options.progressCallbackStep = 1;
+        }
+        if ((typeof options.progressCallbackStep !== 'number') || options.progressCallbackStep <= 0 || options.progressCallbackStep > 100) {
+            throw new exceptions.InvalidParamError(`parameter option.progressCallbackStep is not Number or not between 0 and 100`);
+        }
+        if (utils.isOnlineDev()) {
+            return Request.GetFaaSInfraInstance().createDistributeTaskV1([dataset], handlerFunc, progressCallbackFunc, completedCallbackFunc, options);
+        }
+        return Request.GetFaaSInfraInstance().createDistributeTaskV2([dataset], handlerFunc, progressCallbackFunc, completedCallbackFunc, options);
+    }
+    ;
+}
+exports.Tasks = Tasks;

package/data/index.d.ts

@@ -0,0 +1,27 @@
+export interface workflowVariables {
+}
+export type globalFuncNames = 'a' | 'b';
+export interface globalVariablesMap {
+    a: string;
+    b: string;
+}
+export type globalVariables = keyof globalVariablesMap;
+export interface metadataMap {
+    /**
+     * @description 用户
+     */
+    _user: User;
+    _department: Department;
+}
+export type currentObjApiName = '_user';
+interface User {
+    _name: string;
+    _id: number;
+    _department: Department;
+}
+interface Department {
+    _id: number;
+    _name: string;
+    _superior: Department;
+}
+export {};

package/data/index.js

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

package/global/application/flow/flow.d.ts

@@ -0,0 +1,99 @@
+import { IApprovalInstance, IApprovalInstanceListOptions, IApprovalInstanceList, IGetApprovalInstanceOptions } from '../../../request/structs';
+export declare function newFlow(context: any): Flow;
+export interface Flow {
+    /**
+     * 获取流程实例人工任务详情列表
+     * @param executionId
+     */
+    getExecutionUserTaskInfo: (executionId: number) => Promise<FlowTaskInfo[]>;
+    /**
+     * 执行流程
+     * @param apiName 流程的 APIName
+     * @param options 流程执行选项
+     * @param async 是否异步执行
+     *      - params 流程入参
+     * @constructor
+     */
+    execute: (apiName: string, options?: ExecuteOptions, async?: boolean) => Promise<ExecutionResult>;
+    /**
+     * 撤销流程实例 (仅支持撤销包含人工任务的流程实例)
+     * @param executionId 流程实例 Id
+     * @param options 撤销选项 reason: 多语原因
+     * @constructor
+     */
+    revokeExecution: (executionId: number, options: RevokeExecutionOptions) => Promise<void>;
+    /**
+     * 获取流程实例信息
+     * @param executionId 流程实例 Id
+     * @constructor
+     */
+    getExecutionInfo: (executionId: number) => Promise<ExecutionInfo>;
+    /**
+     * 获取审批实例列表
+     * @param options 请求参数，可选
+     */
+    getApprovalInstanceList: (options?: IApprovalInstanceListOptions) => Promise<IApprovalInstanceList>;
+    /**
+     * 获取审批实例详情
+     * @param approvalInstanceId 实例ID
+     * @param option 请求参数，可选
+     */
+    getApprovalInstance: (options: IGetApprovalInstanceOptions) => Promise<IApprovalInstance>;
+}
+export interface Execution {
+    /**
+     * 流程实例 id (函数被流程调用时有值)
+     */
+    id: number;
+}
+export interface ExecuteOptions {
+    params: Record<string, any>;
+}
+export interface ExecutionResult {
+    executionId: number;
+    status: ExecutionStatusType;
+    data: Record<string, any>;
+    errCode?: string;
+    errMsg?: string;
+}
+export type ExecutionStatusType = 'wait' | 'in_process' | 'end' | 'rejected' | 'canceled' | 'failed' | 'agreed';
+export interface RevokeExecutionOptions {
+    reason?: NewMultilingual;
+}
+export interface ExecutionInfo {
+    status: ExecutionStatusType;
+    data: Record<string, any>;
+    errCode?: string;
+    errMsg?: string;
+}
+export interface FlowTaskInfo {
+    taskId: number;
+    label: NewMultilingual;
+    taskType: TaskType;
+    taskStatus: TaskStatus;
+    opinionList: TaskOpinion[];
+    assigneeList: FlowUser[];
+    startedTime: number;
+    completedTime?: number;
+}
+export type TaskType = 'form' | 'approval' | 'CC';
+export type TaskStatus = 'in_process' | 'completed' | 'canceled' | 'failed' | 'auto_end' | 'agreed' | 'rejected';
+export interface NewMultilingual {
+    en_US?: string;
+    zh_CN?: string;
+}
+export interface FlowUserAvatar {
+    url: string;
+}
+export interface FlowUser {
+    userId: number;
+    feishuOpenId: string;
+    userName: NewMultilingual;
+}
+export interface TaskOpinion {
+    user: FlowUser;
+    feishuOpenId: number;
+    opinionResult?: string;
+    submitTime: number;
+    opinionContent?: string;
+}

package/global/application/flow/flow.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newFlow = void 0;
+const flow_1 = require("./impl/flow");
+function newFlow(context) {
+    return new flow_1.Flow(context?.flow);
+}
+exports.newFlow = newFlow;

package/global/application/flow/impl/flow.d.ts

@@ -0,0 +1,20 @@
+import { Flow as IFlow, ExecuteOptions, ExecutionResult, ExecutionInfo, FlowTaskInfo, RevokeExecutionOptions, Execution } from '../flow';
+import { IApprovalInstance, IApprovalInstanceList, IApprovalInstanceListOptions, IGetApprovalInstanceOptions } from "../../../../request/structs";
+export declare class Flow implements IFlow {
+    execution: Execution;
+    /**
+    * 工作流的 API name
+    */
+    apiName: string;
+    /**
+     * 工作流实例的 ID
+     */
+    instanceId: number;
+    constructor(flowParams: any);
+    execute(apiName: string, options: ExecuteOptions | undefined, async?: boolean | undefined): Promise<ExecutionResult>;
+    getExecutionInfo(executionId: number): Promise<ExecutionInfo>;
+    getExecutionUserTaskInfo(executionId: number): Promise<FlowTaskInfo[]>;
+    revokeExecution(executionId: number, options: RevokeExecutionOptions): Promise<void>;
+    getApprovalInstanceList(options?: IApprovalInstanceListOptions): Promise<IApprovalInstanceList>;
+    getApprovalInstance(options: IGetApprovalInstanceOptions): Promise<IApprovalInstance>;
+}

package/global/application/flow/impl/flow.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flow = void 0;
+const exceptions_1 = require("@byted-apaas/server-common-node/utils/exceptions");
+const Request = require("../../../../request/interface");
+const server_common_node_1 = require("@byted-apaas/server-common-node");
+class Flow {
+    constructor(flowParams) {
+        this.execution = flowParams?.execution;
+        this.apiName = flowParams?.apiName;
+        this.instanceId = flowParams?.instanceId;
+    }
+    async execute(apiName, options, async) {
+        if (!apiName || typeof apiName !== 'string') {
+            throw new exceptions_1.InvalidParamError(`param's type (${apiName}) need string, but is ${typeof apiName}`);
+        }
+        if (options && options.params && server_common_node_1.checkUtils.isNotObject(options.params)) {
+            throw new exceptions_1.InvalidParamError(`options.params's type (${options}) need object, but is ${Array.isArray(options) ? 'array' : typeof options.params}`);
+        }
+        if (!options) {
+            options = {};
+        }
+        return await Request.GetInstance().executeFlow(apiName, options, async);
+    }
+    async getExecutionInfo(executionId) {
+        if (!executionId || typeof executionId !== 'number') {
+            throw new exceptions_1.InvalidParamError(`param's type (${executionId}) is not matched to number, but is ${typeof executionId}`);
+        }
+        return await Request.GetInstance().getExecutionInfo(executionId);
+    }
+    async getExecutionUserTaskInfo(executionId) {
+        if (!executionId || typeof executionId !== 'number') {
+            throw new exceptions_1.InvalidParamError(`param's type (${executionId}) need number, but is ${typeof executionId}`);
+        }
+        return await Request.GetInstance().getExecutionUserTaskInfo(BigInt(executionId));
+    }
+    async revokeExecution(executionId, options) {
+        if (!executionId || typeof executionId !== 'number') {
+            throw new exceptions_1.InvalidParamError(`param's type (${executionId}) is need number, but is ${typeof executionId}`);
+        }
+        return await Request.GetInstance().revokeExecution(executionId, options);
+    }
+    async getApprovalInstanceList(options) {
+        return await Request.GetInstance().getApprovalInstanceList(options);
+    }
+    async getApprovalInstance(options) {
+        if (!options || !options.approvalInstanceId) {
+            throw new exceptions_1.InvalidParamError(`required parameter approvalInstanceId is empty`);
+        }
+        if (typeof options.approvalInstanceId !== 'number') {
+            throw new exceptions_1.InvalidParamError(`param's type (${options.approvalInstanceId}) is need number, but is ${typeof options.approvalInstanceId}`);
+        }
+        return await Request.GetInstance().getApprovalInstance(options);
+    }
+}
+exports.Flow = Flow;

package/global/application/globalVar/globalVar.d.ts

@@ -0,0 +1,7 @@
+export declare class GlobalVar<gv> {
+    /**
+     * 根据 apiName 获取对应的全局变量
+     * @param apiName 全局变量的 API Name
+     */
+    getVar<Key extends keyof gv>(apiName: Key): Promise<gv[Key]>;
+}

package/global/application/globalVar/globalVar.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/global/global.d.ts

@@ -0,0 +1,70 @@
+import { IOperator } from '../kunlun/operator/IOperator';
+import { GMTOffset as GMT } from '@byted-apaas/server-common-node/constants/timeZone';
+import { area2code } from '@byted-apaas/server-common-node/constants/countryCode';
+import * as common from '@byted-apaas/server-common-node';
+import { Flow } from './application/flow/flow';
+import { _Resources } from '../context/resources/impl/resources';
+import { Message } from '../context/msg/msg';
+import { _IIntegration } from '../context/integration/IIntegration';
+declare global {
+    export namespace application {
+        /**
+         * 操作 flow
+         */
+        let flow: Flow;
+        /**
+         * 静态资源类操作
+         */
+        let resources: _Resources;
+        /**
+         * 向消息中心推送及更新消息
+         */
+        let msg: Message;
+        /**
+         * 指令操作符
+         */
+        let operator: IOperator;
+        /**
+         * dataV3 接口
+         */
+        /**
+         * metadataV3 接口
+         */
+        /**
+         * 常量
+         */
+        namespace constants {
+            /**
+             * 引用时区信息
+             */
+            let GMTOffset: typeof GMT;
+            /**
+             * 引用国际区号
+             */
+            let countryCode: typeof area2code;
+            /**
+             * 错误码
+             */
+            const errorCode: {
+                RATE_LIMIT_ERROR: string;
+                Flows_NoPermission: string;
+                Flows_NotExist: string;
+                Flows_ExecutionNotExist: string;
+                Flows_NotSupportCallFlowType: string;
+                Flows_NotSupportRevokeFlow: string;
+                Flows_NoReqInputParamErr: string;
+                Flows_InvalidParamErr: string;
+            };
+            /**
+             * 生成复杂数据结构
+             */
+            namespace type {
+                export import Multilingual = common.fieldType.Multilingual;
+                export import Phone = common.fieldType.Phone;
+                export import Date = common.fieldType.Date;
+                export import DateTime = common.fieldType.DateTime;
+            }
+        }
+        const integration: _IIntegration;
+    }
+}

package/global/global.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common = require("@byted-apaas/server-common-node");