@xezzon/zeroweb-sdk 0.9.0 → 0.10.0

package/dist/index.cjs

@@ -0,0 +1,731 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ServiceType: ()=>metadata_ServiceType,
+    ZerowebOpenClient: ()=>src_open,
+    ZerowebAdminClient: ()=>admin,
+    FileProvider: ()=>file_FileProvider,
+    ZerowebMetadataClient: ()=>metadata,
+    OpenapiStatus: ()=>openapi_OpenapiStatus,
+    MenuType: ()=>metadata_MenuType,
+    ZerowebFileClient: ()=>src_file,
+    ErrorSource: ()=>types_ErrorSource,
+    zerowebErrorHandler: ()=>zerowebErrorHandler,
+    checksum: ()=>upload_checksum,
+    SubscriptionStatus: ()=>subscription_SubscriptionStatus,
+    ZerowebDevClient: ()=>dev,
+    ErrorCodeEnum: ()=>ErrorCodeEnum,
+    AttachmentStatus: ()=>attachment_AttachmentStatus
+});
+const external_axios_namespaceObject = require("axios");
+var external_axios_default = /*#__PURE__*/ __webpack_require__.n(external_axios_namespaceObject);
+var types_ErrorSource = /*#__PURE__*/ function(ErrorSource) {
+    ErrorSource[ErrorSource["NETWORK"] = 1] = "NETWORK";
+    ErrorSource[ErrorSource["INFRA"] = 2] = "INFRA";
+    ErrorSource[ErrorSource["INTERNAL"] = 3] = "INTERNAL";
+    ErrorSource[ErrorSource["BAD_REQUEST"] = 4] = "BAD_REQUEST";
+    return ErrorSource;
+}({});
+const ERROR_CODE_HEADER = 'x-error-code';
+const ErrorCodeEnum = {
+    ARGUMENT_INVALID: 'C0005'
+};
+function zerowebErrorHandler(error) {
+    const response = error.response;
+    if (!response) {
+        error.source = types_ErrorSource.NETWORK;
+        return Promise.reject(error);
+    }
+    const errorCode = response.headers[ERROR_CODE_HEADER];
+    if (!errorCode) {
+        error.source = types_ErrorSource.INFRA;
+        return Promise.reject(error);
+    }
+    error.errorCode = errorCode;
+    const responseBody = response.data;
+    if (response.status >= 500) {
+        error.source = types_ErrorSource.INTERNAL;
+        error.message = responseBody.message;
+        return Promise.reject(error);
+    }
+    error.source = types_ErrorSource.BAD_REQUEST;
+    if (errorCode !== ErrorCodeEnum.ARGUMENT_INVALID) error.notification = responseBody.message;
+    error.parameters = responseBody.parameters;
+    error.details = responseBody.details;
+    return Promise.reject(error);
+}
+var metadata_ServiceType = /*#__PURE__*/ function(ServiceType) {
+    ServiceType["CLIENT"] = "CLIENT";
+    ServiceType["SERVER"] = "SERVER";
+    return ServiceType;
+}({});
+var metadata_MenuType = /*#__PURE__*/ function(MenuType) {
+    MenuType["ROUTE"] = "ROUTE";
+    MenuType["EXTERNAL_LINK"] = "EXTERNAL_LINK";
+    MenuType["EMBEDDED"] = "EMBEDDED";
+    MenuType["PERMISSION"] = "PERMISSION";
+    MenuType["GROUP_PERMISSION"] = "GROUP_PERMISSION";
+    return MenuType;
+}({});
+const metadata = (config)=>{
+    const instance = external_axios_default().create(config);
+    const interceptors = instance.interceptors;
+    interceptors.response.use(null, zerowebErrorHandler);
+    return {
+        interceptors,
+        loadServiceInfo () {
+            return instance.request({
+                url: '/metadata/info.json',
+                method: 'GET'
+            });
+        },
+        loadResourceInfo () {
+            return instance.request({
+                url: '/metadata/menu.json',
+                method: 'GET'
+            });
+        }
+    };
+};
+const admin_app = (client)=>({
+        addApp: (app)=>client.request({
+                url: '/app',
+                method: 'POST',
+                data: app
+            }),
+        listApp: ()=>client.request({
+                url: '/app',
+                method: 'GET'
+            }),
+        queryAppById: (id)=>client.request({
+                url: `/app/${id}`,
+                method: 'GET'
+            }),
+        updateApp: (app)=>client.request({
+                url: '/app',
+                method: 'PUT',
+                data: app
+            }),
+        deleteApp: (id)=>client.request({
+                url: `/app/${id}`,
+                method: 'DELETE'
+            })
+    });
+const authn = (client)=>({
+        basicLogin: (user)=>client.request({
+                url: '/auth/login/basic',
+                method: 'POST',
+                auth: {
+                    username: user.username,
+                    password: user.password
+                },
+                data: user
+            }),
+        self: ()=>client.request({
+                url: '/auth/self',
+                method: 'GET'
+            }),
+        token: ()=>client.request({
+                url: '/auth/token',
+                method: 'GET'
+            }),
+        logout: ()=>client.request({
+                url: '/auth/logout',
+                method: 'PUT'
+            })
+    });
+const authz = (client)=>({
+        queryUserByRole: (roleId)=>client.request({
+                url: `/auth/role/${roleId}/user`,
+                method: 'GET'
+            }),
+        bindUserToRole: (roleUsers)=>client.request({
+                url: '/auth/role/-/user',
+                method: 'PUT',
+                data: roleUsers
+            }),
+        releaseRoleUser: (roleUsers)=>client.request({
+                url: '/auth/role/-/user',
+                method: 'DELETE',
+                data: roleUsers
+            }),
+        queryPermissionByRole: (roleId)=>client.request({
+                url: `/auth/role/${roleId}/permission`,
+                method: 'GET'
+            }),
+        bindPermissionToRole: (rolePermissions)=>client.request({
+                url: '/auth/role/-/permission',
+                method: 'PUT',
+                data: rolePermissions
+            }),
+        releaseRolePermission: (rolePermissions)=>client.request({
+                url: '/auth/role/-/permission',
+                method: 'DELETE',
+                data: rolePermissions
+            }),
+        queryRoleByUser: (userId)=>client.request({
+                url: `/auth/user/${userId}/role`,
+                method: 'GET'
+            }),
+        queryRoleByPermission: (permission)=>client.request({
+                url: '/auth/permission/-/role',
+                method: 'GET',
+                params: {
+                    permission
+                }
+            })
+    });
+const admin_crypto = ({ request })=>({
+        passwordStrength: (password, { username })=>request({
+                url: '/password-strength',
+                method: 'GET',
+                params: {
+                    password,
+                    username
+                }
+            })
+    });
+const admin_dict = (client)=>({
+        addDict: (dict)=>client.request({
+                url: '/dict',
+                method: 'POST',
+                data: dict
+            }),
+        getDictTagList: (odata)=>client.request({
+                url: '/dict',
+                method: 'GET',
+                params: odata
+            }),
+        getDictTreeByTag: (tag)=>client.request({
+                url: `/dict/tag/${tag}`,
+                method: 'GET'
+            }),
+        modifyDict: (dict)=>client.request({
+                url: '/dict',
+                method: 'PUT',
+                data: dict
+            }),
+        updateDictStatus: (ids, enabled)=>client.request({
+                url: '/dict/update-status',
+                method: 'PUT',
+                params: {
+                    enabled
+                },
+                data: ids
+            }),
+        removeDict: (ids)=>client.request({
+                url: '/dict',
+                method: 'DELETE',
+                data: ids
+            })
+    });
+const admin_role = (client)=>({
+        addRole: (role)=>client.request({
+                url: '/role',
+                method: 'POST',
+                data: role
+            }),
+        listAllRole: ()=>client.request({
+                url: '/role',
+                method: 'GET'
+            }),
+        deleteRole: (id)=>client.request({
+                url: `/role/${id}`,
+                method: 'DELETE'
+            }),
+        listMyRole: ()=>client.request({
+                url: '/role/mine',
+                method: 'GET'
+            })
+    });
+const admin_setting = (client)=>({
+        addSetting: (setting)=>client.request({
+                url: '/setting',
+                method: 'POST',
+                data: setting
+            }),
+        listSetting: ()=>client.request({
+                url: '/setting',
+                method: 'GET'
+            }),
+        querySettingByCode: (code)=>client.request({
+                url: `/setting/${code}`,
+                method: 'GET'
+            }),
+        updateSchema: (setting)=>client.request({
+                url: '/setting/schema',
+                method: 'PUT',
+                data: setting
+            }),
+        updateValue: (setting)=>client.request({
+                url: '/setting/value',
+                method: 'PUT',
+                data: setting
+            }),
+        deleteSetting: (id)=>client.request({
+                url: `/setting/${id}`,
+                method: 'DELETE'
+            })
+    });
+const admin_user = ({ request })=>({
+        register: (user)=>request({
+                url: '/user/register',
+                method: 'POST',
+                data: user
+            }),
+        getMyInfo: ()=>request({
+                url: '/user/me',
+                method: 'GET'
+            }),
+        queryUserList: (odata)=>request({
+                url: '/user',
+                method: 'GET',
+                params: odata
+            }),
+        queryUserById: (id)=>request({
+                url: `/user/${id}`,
+                method: 'GET'
+            })
+    });
+const admin = (config)=>{
+    const instance = external_axios_default().create(config);
+    const interceptors = instance.interceptors;
+    interceptors.response.use(null, zerowebErrorHandler);
+    return {
+        interceptors,
+        app: admin_app(instance),
+        authn: authn(instance),
+        authz: authz(instance),
+        crypto: admin_crypto(instance),
+        dict: admin_dict(instance),
+        role: admin_role(instance),
+        setting: admin_setting(instance),
+        user: admin_user(instance)
+    };
+};
+var openapi_OpenapiStatus = /*#__PURE__*/ function(OpenapiStatus) {
+    OpenapiStatus["DRAFT"] = "DRAFT";
+    OpenapiStatus["PUBLISHED"] = "PUBLISHED";
+    return OpenapiStatus;
+}({});
+const open_openapi = (client)=>({
+        addOpenapi: (openapi)=>client.request({
+                url: '/openapi',
+                method: 'POST',
+                data: openapi
+            }),
+        getOpenapiList: (odata)=>client.request({
+                url: '/openapi',
+                method: 'GET',
+                params: odata
+            }),
+        modifyOpenapi: (openapi)=>client.request({
+                url: '/openapi',
+                method: 'PUT',
+                data: openapi
+            }),
+        publishOpenapi: (id)=>client.request({
+                url: `/openapi/${id}/publish`,
+                method: 'PUT'
+            }),
+        deleteOpenapi: (id)=>client.request({
+                url: `/openapi/${id}`,
+                method: 'DELETE'
+            })
+    });
+const BASE_URL = '/third-party-app';
+const third_party_app = (client)=>({
+        addThirdPartyApp: (thirdPartyApp)=>client.request({
+                url: `${BASE_URL}`,
+                method: 'POST',
+                data: thirdPartyApp
+            }),
+        listMyThirdPartyApp: (odata)=>client.request({
+                url: `${BASE_URL}/mine`,
+                method: 'GET',
+                params: odata
+            }),
+        queryThirdPartyAppById: (id)=>client.request({
+                url: `${BASE_URL}/${id}`,
+                method: 'GET'
+            }),
+        listThirdPartyApp: (odata)=>client.request({
+                url: `${BASE_URL}`,
+                method: 'GET',
+                params: odata
+            }),
+        rollAccessSecret: (id)=>client.request({
+                url: `${BASE_URL}/${id}/roll`,
+                method: 'PATCH'
+            }),
+        inviteMember: (appId, timeout)=>client.request({
+                url: `/third-party-app/${appId}/member`,
+                method: 'POST',
+                params: {
+                    timeout
+                }
+            }),
+        inviteParticularMember: (appId, userId, timeout)=>client.request({
+                url: `/third-party-app/${appId}/member`,
+                method: 'POST',
+                params: {
+                    userId,
+                    timeout
+                }
+            }),
+        addThirdPartyAppMember: (token)=>client.request({
+                url: "/third-party-app/-/member",
+                method: 'PUT',
+                params: {
+                    token
+                }
+            }),
+        listThirdPartyAppMember: (appId)=>client.request({
+                url: `/third-party-app/${appId}/member`,
+                method: 'GET'
+            }),
+        moveOwnerShip: (appId, userId)=>client.request({
+                url: `/third-party-app/${appId}/owner`,
+                method: 'PATCH',
+                params: {
+                    userId
+                }
+            }),
+        deleteMember: (appId, memberId)=>client.request({
+                url: `/third-party-app/${appId}/member/${memberId}`,
+                method: 'DELETE'
+            })
+    });
+const subscription_BASE_URL = "/subscription";
+var subscription_SubscriptionStatus = /*#__PURE__*/ function(SubscriptionStatus) {
+    SubscriptionStatus["NONE"] = "NONE";
+    SubscriptionStatus["AUDITING"] = "AUDITING";
+    SubscriptionStatus["SUBSCRIBED"] = "SUBSCRIBED";
+    return SubscriptionStatus;
+}({});
+const open_subscription = (client)=>({
+        subscribe: (subscription)=>client.request({
+                url: `${subscription_BASE_URL}`,
+                method: 'POST',
+                data: subscription
+            }),
+        listSubscription: (appId)=>client.request({
+                url: `${subscription_BASE_URL}`,
+                method: 'GET',
+                params: {
+                    appId
+                }
+            }),
+        listSubscriptionWithOpenapi: (appId, odata)=>client.request({
+                url: `${BASE_URL}/${appId}/subscription`,
+                method: 'GET',
+                params: odata
+            }),
+        auditSubscription: (id)=>client.request({
+                url: `${subscription_BASE_URL}/${id}/audit`,
+                method: 'PUT'
+            })
+    });
+const src_open = (config)=>{
+    const instance = external_axios_default().create(config);
+    const interceptors = instance.interceptors;
+    interceptors.response.use(null, zerowebErrorHandler);
+    return {
+        interceptors: instance.interceptors,
+        openapi: open_openapi(instance),
+        subscription: open_subscription(instance),
+        thirdPartyApp: third_party_app(instance)
+    };
+};
+const external_crypto_js_namespaceObject = require("crypto-js");
+var external_crypto_js_default = /*#__PURE__*/ __webpack_require__.n(external_crypto_js_namespaceObject);
+const external_js_crc_namespaceObject = require("js-crc");
+async function upload_checksum(file) {
+    if (file.checksum && file.crc) return file;
+    return file.arrayBuffer().then((arrayBuffer)=>Promise.all([
+            Promise.resolve().then(()=>external_crypto_js_default().SHA256(external_crypto_js_default().lib.WordArray.create(arrayBuffer)).toString(external_crypto_js_default().enc.Base64)).then((checksum)=>{
+                file.checksum = checksum;
+            }),
+            Promise.resolve().then(()=>external_crypto_js_default().enc.Base64.stringify(external_crypto_js_default().enc.Hex.parse(external_js_crc_namespaceObject.crc32.hex(arrayBuffer)))).then((crc)=>{
+                file.crc = crc;
+            })
+        ])).then(()=>file);
+}
+function upload(client, attachmentApi) {
+    return async (file, uploadInfo)=>file.arrayBuffer().then((arrayBuffer)=>{
+            const partCount = uploadInfo.partCount;
+            const partSize = uploadInfo.partSize;
+            const parts = [];
+            for(let index = 0; index < partCount - 1; index++){
+                const content = arrayBuffer.slice(index * partSize, (index + 1) * partSize);
+                const crc = external_crypto_js_default().enc.Base64.stringify(external_crypto_js_default().enc.Hex.parse(external_js_crc_namespaceObject.crc32.hex(content)));
+                parts.push({
+                    content,
+                    crc
+                });
+            }
+            const content = arrayBuffer.slice((partCount - 1) * partSize, file.size);
+            const crc = external_crypto_js_default().enc.Base64.stringify(external_crypto_js_default().enc.Hex.parse(external_js_crc_namespaceObject.crc32.hex(content)));
+            parts.push({
+                content,
+                crc
+            });
+            return parts;
+        }).then((parts)=>Promise.all(parts.map(async (part, index)=>Promise.resolve().then(()=>{
+                    if (uploadInfo.partCount > 1) return attachmentApi.getMultipartUploadEndpoint(uploadInfo.id, index + 1, part.crc);
+                    return attachmentApi.getUploadEndpoint(uploadInfo.id);
+                }).then((response)=>response.data).then(async ({ endpoint })=>{
+                    if (!endpoint) return;
+                    const partChecksum = external_crypto_js_default().SHA256(external_crypto_js_default().lib.WordArray.create(part.content)).toString(external_crypto_js_default().enc.Base64);
+                    let headers;
+                    headers = uploadInfo.partCount > 1 ? {
+                        'x-amz-sdk-checksum-algorithm': 'CRC32',
+                        'x-amz-checksum-crc32': part.crc
+                    } : {
+                        'x-amz-sdk-checksum-algorithm': 'SHA256',
+                        'x-amz-checksum-sha256': partChecksum,
+                        'x-amz-meta-id': uploadInfo.id,
+                        'x-amz-meta-filename': file.name,
+                        'Content-Type': file.type
+                    };
+                    return client.request({
+                        url: endpoint,
+                        method: 'PUT',
+                        data: part.content,
+                        headers: headers
+                    });
+                })))).then(()=>attachmentApi.finishUpload(uploadInfo.id));
+}
+function resolveDownloadUrl(attachmentApi, baseURL = '') {
+    return async (attachment)=>attachmentApi.getDownloadEndpoint(attachment.id).then((response)=>response.data).then(({ endpoint, filename })=>({
+                endpoint: attachment.provider === file_FileProvider.FS ? `${baseURL}${endpoint}` : endpoint,
+                filename
+            }));
+}
+var attachment_AttachmentStatus = /*#__PURE__*/ function(AttachmentStatus) {
+    AttachmentStatus["UPLOADING"] = "UPLOADING";
+    AttachmentStatus["DONE"] = "DONE";
+    return AttachmentStatus;
+}({});
+const file_attachment = (client)=>({
+        addAttachment: async (file, bizType, bizId)=>{
+            await upload_checksum(file);
+            const req = {
+                name: file.name,
+                checksum: file.checksum,
+                size: file.size,
+                type: file.type,
+                bizType,
+                bizId
+            };
+            return client.request({
+                url: '/attachment',
+                method: 'POST',
+                data: req,
+                params: {
+                    crc: file.crc
+                }
+            });
+        },
+        getUploadInfo: (id, checksum, fileSize)=>client.request({
+                url: `/attachment/${id}/resume`,
+                method: 'GET',
+                params: {
+                    checksum,
+                    fileSize
+                }
+            }),
+        getUploadEndpoint: (id)=>client.request({
+                url: `/attachment/${id}/endpoint/upload`,
+                method: 'GET',
+                params: {
+                    partNumber: 0
+                }
+            }),
+        getMultipartUploadEndpoint: (id, partNumber, crc)=>client.request({
+                url: `/attachment/${id}/endpoint/upload`,
+                method: 'GET',
+                params: {
+                    partNumber,
+                    crc
+                }
+            }),
+        finishUpload: (id)=>client.request({
+                url: `/attachment/${id}/status/done`,
+                method: 'PUT'
+            }),
+        queryAttachmentByBiz: (bizType, bizId)=>client.request({
+                url: "/attachment/list",
+                method: 'GET',
+                params: {
+                    bizType,
+                    bizId
+                }
+            }),
+        queryById: (id)=>client.request({
+                url: `/attachment/${id}`,
+                method: 'GET'
+            }),
+        getDownloadEndpoint: (id)=>client.request({
+                url: `/attachment/${id}/endpoint/download`,
+                method: 'GET'
+            }),
+        deleteAttachment: (id)=>client.request({
+                url: `/attachment/${id}`,
+                method: 'DELETE'
+            }),
+        queryPage: (odata)=>client.request({
+                url: '/attachment/page',
+                method: 'GET',
+                params: odata
+            })
+    });
+const src_file = (config)=>{
+    const instance = external_axios_default().create(config);
+    const interceptors = instance.interceptors;
+    interceptors.response.use(null, zerowebErrorHandler);
+    const attachmentApi = file_attachment(instance);
+    return {
+        interceptors,
+        attachment: attachmentApi,
+        upload: upload(instance, attachmentApi),
+        resolveDownloadUrl: resolveDownloadUrl(attachmentApi, config.baseURL)
+    };
+};
+var file_FileProvider = /*#__PURE__*/ function(FileProvider) {
+    FileProvider["FS"] = "FS";
+    FileProvider["S3"] = "S3";
+    return FileProvider;
+}({});
+const locale = (client)=>({
+        addLanguage: (language)=>client.request({
+                url: '/language',
+                method: 'POST',
+                data: language
+            }),
+        queryLanguageList: ()=>client.request({
+                url: '/language',
+                method: 'GET'
+            }),
+        updateLanguage: (language)=>client.request({
+                url: '/language',
+                method: 'PUT',
+                data: language
+            }),
+        deleteLanguage: (id)=>client.request({
+                url: `/language/${id}`,
+                method: 'DELETE'
+            }),
+        addI18nMessage: (i18nMessage)=>client.request({
+                url: '/i18n',
+                method: 'POST',
+                data: i18nMessage
+            }),
+        listI18nNamespace: ()=>client.request({
+                url: '/i18n',
+                method: 'GET'
+            }),
+        queryI18nMessageList: (namespace, odata)=>client.request({
+                url: `/i18n/${namespace}`,
+                method: 'GET',
+                params: odata
+            }),
+        updateI18nMessage: (i18nMessage)=>client.request({
+                url: '/i18n',
+                method: 'PUT',
+                data: i18nMessage
+            }),
+        deleteI18nMessage: (id)=>client.request({
+                url: `/i18n/${id}`,
+                method: 'DELETE'
+            }),
+        queryTranslation: (namespace, messageKey)=>client.request({
+                url: `/i18n/${namespace}/${messageKey}`,
+                method: 'GET'
+            }),
+        upsertTranslation: (translation)=>client.request({
+                url: '/locale',
+                method: 'PUT',
+                data: translation
+            }),
+        loadTranslation: (language, namespace)=>client.request({
+                url: `/locale/${language}/${namespace}`,
+                method: 'GET'
+            })
+    });
+const dev = (config)=>{
+    const instance = external_axios_default().create(config);
+    const interceptors = instance.interceptors;
+    interceptors.response.use(null, zerowebErrorHandler);
+    return {
+        interceptors,
+        locale: locale(instance)
+    };
+};
+exports.AttachmentStatus = __webpack_exports__.AttachmentStatus;
+exports.ErrorCodeEnum = __webpack_exports__.ErrorCodeEnum;
+exports.ErrorSource = __webpack_exports__.ErrorSource;
+exports.FileProvider = __webpack_exports__.FileProvider;
+exports.MenuType = __webpack_exports__.MenuType;
+exports.OpenapiStatus = __webpack_exports__.OpenapiStatus;
+exports.ServiceType = __webpack_exports__.ServiceType;
+exports.SubscriptionStatus = __webpack_exports__.SubscriptionStatus;
+exports.ZerowebAdminClient = __webpack_exports__.ZerowebAdminClient;
+exports.ZerowebDevClient = __webpack_exports__.ZerowebDevClient;
+exports.ZerowebFileClient = __webpack_exports__.ZerowebFileClient;
+exports.ZerowebMetadataClient = __webpack_exports__.ZerowebMetadataClient;
+exports.ZerowebOpenClient = __webpack_exports__.ZerowebOpenClient;
+exports.checksum = __webpack_exports__.checksum;
+exports.zerowebErrorHandler = __webpack_exports__.zerowebErrorHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AttachmentStatus",
+    "ErrorCodeEnum",
+    "ErrorSource",
+    "FileProvider",
+    "MenuType",
+    "OpenapiStatus",
+    "ServiceType",
+    "SubscriptionStatus",
+    "ZerowebAdminClient",
+    "ZerowebDevClient",
+    "ZerowebFileClient",
+    "ZerowebMetadataClient",
+    "ZerowebOpenClient",
+    "checksum",
+    "zerowebErrorHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});