@alfresco/js-api 7.3.0-1529 → 7.3.0

package/esm2020/api/activiti-rest-api/api/adminTenants.api.mjs

@@ -0,0 +1,160 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ImageUploadRepresentation, TenantEvent, TenantRepresentation } from '../model';
+import { BaseApi } from './base.api';
+import { throwIfNotDefined } from '../../../assert';
+/**
+ * AdminTenantsApi service.
+ */
+export class AdminTenantsApi extends BaseApi {
+    /**
+     * Create a tenant
+     * Only a tenant manager may access this endpoint
+     *
+     * @param createTenantRepresentation createTenantRepresentation
+     * @return Promise<LightTenantRepresentation>
+     */
+    createTenant(createTenantRepresentation) {
+        throwIfNotDefined(createTenantRepresentation, 'groupId');
+        return this.post({
+            path: '/api/enterprise/admin/tenants',
+            bodyParam: createTenantRepresentation
+        });
+    }
+    /**
+     * Delete a tenant
+     *
+     * @param tenantId tenantId
+     * @return Promise<{}>
+     */
+    deleteTenant(tenantId) {
+        throwIfNotDefined(tenantId, 'tenantId');
+        const pathParams = {
+            tenantId
+        };
+        return this.delete({
+            path: '/api/enterprise/admin/tenants/{tenantId}',
+            pathParams
+        });
+    }
+    /**
+     * Get tenant events
+     *
+     * @param tenantId tenantId
+     * @return Promise<TenantEvent>
+     */
+    getTenantEvents(tenantId) {
+        throwIfNotDefined(tenantId, 'tenantId');
+        const pathParams = {
+            tenantId
+        };
+        return this.get({
+            path: '/api/enterprise/admin/tenants/{tenantId}/events',
+            pathParams,
+            returnType: TenantEvent
+        });
+    }
+    /**
+     * Get a tenant's logo
+     *
+     * @param tenantId tenantId
+     * @return Promise<{}>
+     */
+    getTenantLogo(tenantId) {
+        throwIfNotDefined(tenantId, 'tenantId');
+        const pathParams = {
+            tenantId
+        };
+        return this.get({
+            path: '/api/enterprise/admin/tenants/{tenantId}/logo',
+            pathParams
+        });
+    }
+    /**
+     * Get a tenant
+     *
+     * @param tenantId tenantId
+     * @return Promise<TenantRepresentation>
+     */
+    getTenant(tenantId) {
+        throwIfNotDefined(tenantId, 'tenantId');
+        const pathParams = {
+            tenantId
+        };
+        return this.get({
+            path: '/api/enterprise/admin/tenants/{tenantId}',
+            pathParams,
+            returnType: TenantRepresentation
+        });
+    }
+    /**
+     * List tenants
+     * Only a tenant manager may access this endpoint
+     *
+     * @return Promise<LightTenantRepresentation>
+     */
+    getTenants() {
+        return this.get({
+            path: '/api/enterprise/admin/tenants'
+        });
+    }
+    /**
+     * Update a tenant
+     *
+     * @param tenantId tenantId
+     * @param createTenantRepresentation createTenantRepresentation
+     * @return Promise<TenantRepresentation>
+     */
+    update(tenantId, createTenantRepresentation) {
+        throwIfNotDefined(tenantId, 'tenantId');
+        throwIfNotDefined(createTenantRepresentation, 'createTenantRepresentation');
+        const pathParams = {
+            tenantId
+        };
+        return this.put({
+            path: '/api/enterprise/admin/tenants/{tenantId}',
+            pathParams,
+            bodyParam: createTenantRepresentation,
+            returnType: TenantRepresentation
+        });
+    }
+    /**
+     * Update a tenant's logo
+     *
+     * @param tenantId tenantId
+     * @param file file
+     * @return Promise<ImageUploadRepresentation>
+     */
+    uploadTenantLogo(tenantId, file) {
+        throwIfNotDefined(tenantId, 'tenantId');
+        throwIfNotDefined(file, 'file');
+        const pathParams = {
+            tenantId
+        };
+        const formParams = {
+            file
+        };
+        return this.post({
+            path: '/api/enterprise/admin/tenants/{tenantId}/logo',
+            pathParams,
+            formParams,
+            contentTypes: ['multipart/form-data'],
+            returnType: ImageUploadRepresentation
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adminTenants.api.js","sourceRoot":"","sources":["../../../../../../../lib/js-api/src/api/activiti-rest-api/api/adminTenants.api.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { CreateTenantRepresentation, ImageUploadRepresentation, LightTenantRepresentation, TenantEvent, TenantRepresentation } from '../model';\nimport { BaseApi } from './base.api';\nimport { throwIfNotDefined } from '../../../assert';\n\n/**\n * AdminTenantsApi service.\n */\nexport class AdminTenantsApi extends BaseApi {\n    /**\n     * Create a tenant\n     * Only a tenant manager may access this endpoint\n     *\n     * @param createTenantRepresentation createTenantRepresentation\n     * @return Promise<LightTenantRepresentation>\n     */\n    createTenant(createTenantRepresentation: CreateTenantRepresentation): Promise<LightTenantRepresentation> {\n        throwIfNotDefined(createTenantRepresentation, 'groupId');\n\n        return this.post({\n            path: '/api/enterprise/admin/tenants',\n            bodyParam: createTenantRepresentation\n        });\n    }\n\n    /**\n     * Delete a tenant\n     *\n     * @param tenantId tenantId\n     * @return Promise<{}>\n     */\n    deleteTenant(tenantId: number): Promise<void> {\n        throwIfNotDefined(tenantId, 'tenantId');\n\n        const pathParams = {\n            tenantId\n        };\n\n        return this.delete({\n            path: '/api/enterprise/admin/tenants/{tenantId}',\n            pathParams\n        });\n    }\n\n    /**\n     * Get tenant events\n     *\n     * @param tenantId tenantId\n     * @return Promise<TenantEvent>\n     */\n    getTenantEvents(tenantId: number): Promise<TenantEvent> {\n        throwIfNotDefined(tenantId, 'tenantId');\n\n        const pathParams = {\n            tenantId\n        };\n\n        return this.get({\n            path: '/api/enterprise/admin/tenants/{tenantId}/events',\n            pathParams,\n            returnType: TenantEvent\n        });\n    }\n\n    /**\n     * Get a tenant's logo\n     *\n     * @param tenantId tenantId\n     * @return Promise<{}>\n     */\n    getTenantLogo(tenantId: number): Promise<any> {\n        throwIfNotDefined(tenantId, 'tenantId');\n\n        const pathParams = {\n            tenantId\n        };\n\n        return this.get({\n            path: '/api/enterprise/admin/tenants/{tenantId}/logo',\n            pathParams\n        });\n    }\n\n    /**\n     * Get a tenant\n     *\n     * @param tenantId tenantId\n     * @return Promise<TenantRepresentation>\n     */\n    getTenant(tenantId: number): Promise<TenantRepresentation> {\n        throwIfNotDefined(tenantId, 'tenantId');\n\n        const pathParams = {\n            tenantId\n        };\n\n        return this.get({\n            path: '/api/enterprise/admin/tenants/{tenantId}',\n            pathParams,\n            returnType: TenantRepresentation\n        });\n    }\n\n    /**\n     * List tenants\n     * Only a tenant manager may access this endpoint\n     *\n     * @return Promise<LightTenantRepresentation>\n     */\n    getTenants(): Promise<LightTenantRepresentation> {\n        return this.get({\n            path: '/api/enterprise/admin/tenants'\n        });\n    }\n\n    /**\n     * Update a tenant\n     *\n     * @param tenantId tenantId\n     * @param createTenantRepresentation createTenantRepresentation\n     * @return Promise<TenantRepresentation>\n     */\n    update(tenantId: number, createTenantRepresentation: CreateTenantRepresentation): Promise<TenantRepresentation> {\n        throwIfNotDefined(tenantId, 'tenantId');\n        throwIfNotDefined(createTenantRepresentation, 'createTenantRepresentation');\n\n        const pathParams = {\n            tenantId\n        };\n\n        return this.put({\n            path: '/api/enterprise/admin/tenants/{tenantId}',\n            pathParams,\n            bodyParam: createTenantRepresentation,\n            returnType: TenantRepresentation\n        });\n    }\n\n    /**\n     * Update a tenant's logo\n     *\n     * @param tenantId tenantId\n     * @param file file\n     * @return Promise<ImageUploadRepresentation>\n     */\n    uploadTenantLogo(tenantId: number, file: any): Promise<ImageUploadRepresentation> {\n        throwIfNotDefined(tenantId, 'tenantId');\n        throwIfNotDefined(file, 'file');\n\n        const pathParams = {\n            tenantId\n        };\n\n        const formParams = {\n            file\n        };\n\n        return this.post({\n            path: '/api/enterprise/admin/tenants/{tenantId}/logo',\n            pathParams,\n            formParams,\n            contentTypes: ['multipart/form-data'],\n            returnType: ImageUploadRepresentation\n        });\n    }\n}\n"]}

package/esm2020/api/activiti-rest-api/api/adminUsers.api.mjs

@@ -0,0 +1,101 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { UserRepresentation } from '../model';
+import { BaseApi } from './base.api';
+import { throwIfNotDefined } from '../../../assert';
+/**
+ * AdminUsersApi service.
+ */
+export class AdminUsersApi extends BaseApi {
+    /**
+     * Bulk update a list of users
+     *
+     * @param update update
+     * @return Promise<{}>
+     */
+    bulkUpdateUsers(update) {
+        throwIfNotDefined(update, 'update');
+        return this.put({
+            path: '/api/enterprise/admin/users',
+            bodyParam: update
+        });
+    }
+    /**
+     * Create a user
+     *
+     * @param userRepresentation userRepresentation
+     * @return Promise<UserRepresentation>
+     */
+    createNewUser(userRepresentation) {
+        throwIfNotDefined(userRepresentation, 'userRepresentation');
+        return this.post({
+            path: '/api/enterprise/admin/users',
+            bodyParam: userRepresentation,
+            returnType: UserRepresentation
+        });
+    }
+    /**
+     * Get a user
+     *
+     * @param userId userId
+     * @param opts Optional parameters
+     * @return Promise<AbstractUserRepresentation>
+     */
+    getUser(userId, opts) {
+        throwIfNotDefined(userId, 'userId');
+        const pathParams = {
+            userId
+        };
+        return this.get({
+            path: '/api/enterprise/admin/users/{userId}',
+            pathParams,
+            queryParams: opts
+        });
+    }
+    /**
+     * Query users
+     *
+     * @param opts Optional parameters
+     * @return Promise<ResultListDataRepresentationAbstractUserRepresentation>
+     */
+    getUsers(opts) {
+        return this.get({
+            path: '/api/enterprise/admin/users',
+            queryParams: opts
+        });
+    }
+    /**
+     * Update a user
+     *
+     * @param userId userId
+     * @param userRepresentation userRepresentation
+     * @return Promise<{}>
+     */
+    updateUserDetails(userId, userRepresentation) {
+        throwIfNotDefined(userId, 'userId');
+        throwIfNotDefined(userRepresentation, 'userRepresentation');
+        const pathParams = {
+            userId
+        };
+        return this.put({
+            path: '/api/enterprise/admin/users/{userId}',
+            pathParams,
+            bodyParam: userRepresentation
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRtaW5Vc2Vycy5hcGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvanMtYXBpL3NyYy9hcGkvYWN0aXZpdGktcmVzdC1hcGkvYXBpL2FkbWluVXNlcnMuYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILE9BQU8sRUFJSCxrQkFBa0IsRUFDckIsTUFBTSxVQUFVLENBQUM7QUFDbEIsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLFlBQVksQ0FBQztBQUNyQyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQWdCcEQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sYUFBYyxTQUFRLE9BQU87SUFDdEM7Ozs7O09BS0c7SUFDSCxlQUFlLENBQUMsTUFBb0M7UUFDaEQsaUJBQWlCLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBRXBDLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQztZQUNaLElBQUksRUFBRSw2QkFBNkI7WUFDbkMsU0FBUyxFQUFFLE1BQU07U0FDcEIsQ0FBQyxDQUFDO0lBQ1AsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0gsYUFBYSxDQUFDLGtCQUFzQztRQUNoRCxpQkFBaUIsQ0FBQyxrQkFBa0IsRUFBRSxvQkFBb0IsQ0FBQyxDQUFDO1FBRTVELE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQztZQUNiLElBQUksRUFBRSw2QkFBNkI7WUFDbkMsU0FBUyxFQUFFLGtCQUFrQjtZQUM3QixVQUFVLEVBQUUsa0JBQWtCO1NBQ2pDLENBQUMsQ0FBQztJQUNQLENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSCxPQUFPLENBQUMsTUFBYyxFQUFFLElBQTRCO1FBQ2hELGlCQUFpQixDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsQ0FBQztRQUVwQyxNQUFNLFVBQVUsR0FBRztZQUNmLE1BQU07U0FDVCxDQUFDO1FBRUYsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDO1lBQ1osSUFBSSxFQUFFLHNDQUFzQztZQUM1QyxVQUFVO1lBQ1YsV0FBVyxFQUFFLElBQUk7U0FDcEIsQ0FBQyxDQUFDO0lBQ1AsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0gsUUFBUSxDQUFDLElBQW1CO1FBQ3hCLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQztZQUNaLElBQUksRUFBRSw2QkFBNkI7WUFDbkMsV0FBVyxFQUFFLElBQUk7U0FDcEIsQ0FBQyxDQUFDO0lBQ1AsQ0FBQztJQUVEOzs7Ozs7T0FNRztJQUNILGlCQUFpQixDQUFDLE1BQWMsRUFBRSxrQkFBc0M7UUFDcEUsaUJBQWlCLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBQ3BDLGlCQUFpQixDQUFDLGtCQUFrQixFQUFFLG9CQUFvQixDQUFDLENBQUM7UUFFNUQsTUFBTSxVQUFVLEdBQUc7WUFDZixNQUFNO1NBQ1QsQ0FBQztRQUVGLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQztZQUNaLElBQUksRUFBRSxzQ0FBc0M7WUFDNUMsVUFBVTtZQUNWLFNBQVMsRUFBRSxrQkFBa0I7U0FDaEMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyMyBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQge1xuICAgIEFic3RyYWN0VXNlclJlcHJlc2VudGF0aW9uLFxuICAgIEJ1bGtVc2VyVXBkYXRlUmVwcmVzZW50YXRpb24sXG4gICAgUmVzdWx0TGlzdERhdGFSZXByZXNlbnRhdGlvbkFic3RyYWN0VXNlclJlcHJlc2VudGF0aW9uLFxuICAgIFVzZXJSZXByZXNlbnRhdGlvblxufSBmcm9tICcuLi9tb2RlbCc7XG5pbXBvcnQgeyBCYXNlQXBpIH0gZnJvbSAnLi9iYXNlLmFwaSc7XG5pbXBvcnQgeyB0aHJvd0lmTm90RGVmaW5lZCB9IGZyb20gJy4uLy4uLy4uL2Fzc2VydCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgR2V0VXNlcnNPcHRzIHtcbiAgICBmaWx0ZXI/OiBzdHJpbmc7XG4gICAgc3RhdHVzPzogc3RyaW5nO1xuICAgIGFjY291bnRUeXBlPzogc3RyaW5nO1xuICAgIHNvcnQ/OiBzdHJpbmc7XG4gICAgY29tcGFueT86IHN0cmluZztcbiAgICBzdGFydD86IG51bWJlcjtcbiAgICBwYWdlPzogbnVtYmVyO1xuICAgIHNpemU/OiBudW1iZXI7XG4gICAgZ3JvdXBJZD86IG51bWJlcjtcbiAgICB0ZW5hbnRJZD86IG51bWJlcjtcbiAgICBzdW1tYXJ5PzogYm9vbGVhbjtcbn1cblxuLyoqXG4gKiBBZG1pblVzZXJzQXBpIHNlcnZpY2UuXG4gKi9cbmV4cG9ydCBjbGFzcyBBZG1pblVzZXJzQXBpIGV4dGVuZHMgQmFzZUFwaSB7XG4gICAgLyoqXG4gICAgICogQnVsayB1cGRhdGUgYSBsaXN0IG9mIHVzZXJzXG4gICAgICpcbiAgICAgKiBAcGFyYW0gdXBkYXRlIHVwZGF0ZVxuICAgICAqIEByZXR1cm4gUHJvbWlzZTx7fT5cbiAgICAgKi9cbiAgICBidWxrVXBkYXRlVXNlcnModXBkYXRlOiBCdWxrVXNlclVwZGF0ZVJlcHJlc2VudGF0aW9uKTogUHJvbWlzZTxhbnk+IHtcbiAgICAgICAgdGhyb3dJZk5vdERlZmluZWQodXBkYXRlLCAndXBkYXRlJyk7XG5cbiAgICAgICAgcmV0dXJuIHRoaXMucHV0KHtcbiAgICAgICAgICAgIHBhdGg6ICcvYXBpL2VudGVycHJpc2UvYWRtaW4vdXNlcnMnLFxuICAgICAgICAgICAgYm9keVBhcmFtOiB1cGRhdGVcbiAgICAgICAgfSk7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogQ3JlYXRlIGEgdXNlclxuICAgICAqXG4gICAgICogQHBhcmFtIHVzZXJSZXByZXNlbnRhdGlvbiB1c2VyUmVwcmVzZW50YXRpb25cbiAgICAgKiBAcmV0dXJuIFByb21pc2U8VXNlclJlcHJlc2VudGF0aW9uPlxuICAgICAqL1xuICAgIGNyZWF0ZU5ld1VzZXIodXNlclJlcHJlc2VudGF0aW9uOiBVc2VyUmVwcmVzZW50YXRpb24pOiBQcm9taXNlPFVzZXJSZXByZXNlbnRhdGlvbj4ge1xuICAgICAgICB0aHJvd0lmTm90RGVmaW5lZCh1c2VyUmVwcmVzZW50YXRpb24sICd1c2VyUmVwcmVzZW50YXRpb24nKTtcblxuICAgICAgICByZXR1cm4gdGhpcy5wb3N0KHtcbiAgICAgICAgICAgIHBhdGg6ICcvYXBpL2VudGVycHJpc2UvYWRtaW4vdXNlcnMnLFxuICAgICAgICAgICAgYm9keVBhcmFtOiB1c2VyUmVwcmVzZW50YXRpb24sXG4gICAgICAgICAgICByZXR1cm5UeXBlOiBVc2VyUmVwcmVzZW50YXRpb25cbiAgICAgICAgfSk7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogR2V0IGEgdXNlclxuICAgICAqXG4gICAgICogQHBhcmFtIHVzZXJJZCB1c2VySWRcbiAgICAgKiBAcGFyYW0gb3B0cyBPcHRpb25hbCBwYXJhbWV0ZXJzXG4gICAgICogQHJldHVybiBQcm9taXNlPEFic3RyYWN0VXNlclJlcHJlc2VudGF0aW9uPlxuICAgICAqL1xuICAgIGdldFVzZXIodXNlcklkOiBudW1iZXIsIG9wdHM/OiB7IHN1bW1hcnk/OiBib29sZWFuIH0pOiBQcm9taXNlPEFic3RyYWN0VXNlclJlcHJlc2VudGF0aW9uPiB7XG4gICAgICAgIHRocm93SWZOb3REZWZpbmVkKHVzZXJJZCwgJ3VzZXJJZCcpO1xuXG4gICAgICAgIGNvbnN0IHBhdGhQYXJhbXMgPSB7XG4gICAgICAgICAgICB1c2VySWRcbiAgICAgICAgfTtcblxuICAgICAgICByZXR1cm4gdGhpcy5nZXQoe1xuICAgICAgICAgICAgcGF0aDogJy9hcGkvZW50ZXJwcmlzZS9hZG1pbi91c2Vycy97dXNlcklkfScsXG4gICAgICAgICAgICBwYXRoUGFyYW1zLFxuICAgICAgICAgICAgcXVlcnlQYXJhbXM6IG9wdHNcbiAgICAgICAgfSk7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogUXVlcnkgdXNlcnNcbiAgICAgKlxuICAgICAqIEBwYXJhbSBvcHRzIE9wdGlvbmFsIHBhcmFtZXRlcnNcbiAgICAgKiBAcmV0dXJuIFByb21pc2U8UmVzdWx0TGlzdERhdGFSZXByZXNlbnRhdGlvbkFic3RyYWN0VXNlclJlcHJlc2VudGF0aW9uPlxuICAgICAqL1xuICAgIGdldFVzZXJzKG9wdHM/OiBHZXRVc2Vyc09wdHMpOiBQcm9taXNlPFJlc3VsdExpc3REYXRhUmVwcmVzZW50YXRpb25BYnN0cmFjdFVzZXJSZXByZXNlbnRhdGlvbj4ge1xuICAgICAgICByZXR1cm4gdGhpcy5nZXQoe1xuICAgICAgICAgICAgcGF0aDogJy9hcGkvZW50ZXJwcmlzZS9hZG1pbi91c2VycycsXG4gICAgICAgICAgICBxdWVyeVBhcmFtczogb3B0c1xuICAgICAgICB9KTtcbiAgICB9XG5cbiAgICAvKipcbiAgICAgKiBVcGRhdGUgYSB1c2VyXG4gICAgICpcbiAgICAgKiBAcGFyYW0gdXNlcklkIHVzZXJJZFxuICAgICAqIEBwYXJhbSB1c2VyUmVwcmVzZW50YXRpb24gdXNlclJlcHJlc2VudGF0aW9uXG4gICAgICogQHJldHVybiBQcm9taXNlPHt9PlxuICAgICAqL1xuICAgIHVwZGF0ZVVzZXJEZXRhaWxzKHVzZXJJZDogbnVtYmVyLCB1c2VyUmVwcmVzZW50YXRpb246IFVzZXJSZXByZXNlbnRhdGlvbik6IFByb21pc2U8YW55PiB7XG4gICAgICAgIHRocm93SWZOb3REZWZpbmVkKHVzZXJJZCwgJ3VzZXJJZCcpO1xuICAgICAgICB0aHJvd0lmTm90RGVmaW5lZCh1c2VyUmVwcmVzZW50YXRpb24sICd1c2VyUmVwcmVzZW50YXRpb24nKTtcblxuICAgICAgICBjb25zdCBwYXRoUGFyYW1zID0ge1xuICAgICAgICAgICAgdXNlcklkXG4gICAgICAgIH07XG5cbiAgICAgICAgcmV0dXJuIHRoaXMucHV0KHtcbiAgICAgICAgICAgIHBhdGg6ICcvYXBpL2VudGVycHJpc2UvYWRtaW4vdXNlcnMve3VzZXJJZH0nLFxuICAgICAgICAgICAgcGF0aFBhcmFtcyxcbiAgICAgICAgICAgIGJvZHlQYXJhbTogdXNlclJlcHJlc2VudGF0aW9uXG4gICAgICAgIH0pO1xuICAgIH1cbn1cbiJdfQ==

package/esm2020/api/activiti-rest-api/api/appDefinitions.api.mjs

@@ -0,0 +1,178 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { BaseApi } from './base.api';
+import { throwIfNotDefined } from '../../../assert';
+/**
+ * AppDefinitionsApi service.
+ */
+export class AppDefinitionsApi extends BaseApi {
+    /**
+     * deleteAppDefinition
+     *
+     * @param appDefinitionId appDefinitionId
+     * @return Promise<{}>
+     */
+    deleteAppDefinition(appDefinitionId) {
+        throwIfNotDefined(appDefinitionId, 'appDefinitionId');
+        const pathParams = {
+            appDefinitionId
+        };
+        return this.delete({
+            path: '/api/enterprise/app-definitions/{appDefinitionId}',
+            pathParams
+        });
+    }
+    /**
+     * Export an app definition
+     *
+     * This will return a zip file containing the app definition model and all related models (process definitions and forms).
+     *
+     * @param modelId modelId from a runtime app or the id of an app definition model
+     * @return Promise<{}>
+     */
+    exportAppDefinition(modelId) {
+        throwIfNotDefined(modelId, 'modelId');
+        const pathParams = {
+            modelId
+        };
+        const contentTypes = ['application/json'];
+        const accepts = ['application/json', 'application/zip'];
+        return this.get({
+            path: '/api/enterprise/app-definitions/{modelId}/export',
+            pathParams,
+            contentTypes,
+            accepts
+        });
+    }
+    /**
+     * Get an app definition
+     *
+     * @param modelId Application definition ID
+     * @return Promise<AppDefinitionRepresentation>
+     */
+    getAppDefinition(modelId) {
+        throwIfNotDefined(modelId, 'modelId');
+        const pathParams = {
+            modelId
+        };
+        return this.get({
+            path: '/api/enterprise/app-definitions/{modelId}',
+            pathParams
+        });
+    }
+    /**
+     * importAndPublishApp
+     *
+     * @param file file
+     * @param opts options
+     * @return Promise<AppDefinitionUpdateResultRepresentation>
+     */
+    importAndPublishApp(file, opts) {
+        throwIfNotDefined(file, 'file');
+        const formParams = {
+            file
+        };
+        const queryParams = {
+            renewIdmEntries: opts?.renewIdmEntries
+        };
+        return this.post({
+            path: '/api/enterprise/app-definitions/publish-app',
+            formParams,
+            queryParams,
+            contentTypes: ['multipart/form-data']
+        });
+    }
+    /**
+     * Import a new app definition
+     *
+     * Allows a zip file to be uploaded containing an app definition and any number of included models.
+     * <p>This is useful to bootstrap an environment (for users or continuous integration).<p>
+     * Before using any processes included in the import the app must be published and deployed.
+     *
+     * @param file file
+     * @param opts Optional parameters
+     * @param opts.renewIdmEntries Whether to renew user and group identifiers (default to false)
+     * @return Promise<AppDefinitionRepresentation>
+     */
+    importAppDefinition(file, opts) {
+        throwIfNotDefined(file, 'file');
+        const formParams = {
+            file
+        };
+        return this.post({
+            path: '/api/enterprise/app-definitions/import',
+            queryParams: opts,
+            formParams,
+            contentTypes: ['multipart/form-data']
+        });
+    }
+    /**
+     * Publish an app definition
+     *
+     * Publishing an app definition makes it available for use. The application must not have any validation errors or an error will be returned.<p>Before an app definition can be used by other users, it must also be deployed for their use
+     *
+     * @param modelId modelId
+     * @param publishModel publishModel
+     * @return Promise<AppDefinitionUpdateResultRepresentation>
+     */
+    publishAppDefinition(modelId, publishModel) {
+        throwIfNotDefined(modelId, 'modelId');
+        throwIfNotDefined(publishModel, 'publishModel');
+        const pathParams = {
+            modelId
+        };
+        return this.post({
+            path: '/api/enterprise/app-definitions/{modelId}/publish',
+            pathParams,
+            bodyParam: publishModel
+        });
+    }
+    /**
+     * Update an app definition
+     *
+     * @param modelId Application definition ID
+     * @param updatedModel updatedModel |
+     * @return Promise<AppDefinitionUpdateResultRepresentation>
+     */
+    updateAppDefinition(modelId, updatedModel) {
+        throwIfNotDefined(modelId, 'modelId');
+        throwIfNotDefined(updatedModel, 'updatedModel');
+        const pathParams = {
+            modelId
+        };
+        if (!updatedModel['appDefinition']) {
+            const formParams = {
+                file: updatedModel
+            };
+            return this.post({
+                path: '/api/enterprise/app-definitions/{modelId}/import',
+                pathParams,
+                formParams,
+                bodyParam: updatedModel,
+                contentTypes: ['multipart/form-data']
+            });
+        }
+        else {
+            return this.put({
+                path: '/api/enterprise/app-definitions/{modelId}',
+                pathParams,
+                bodyParam: updatedModel
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appDefinitions.api.js","sourceRoot":"","sources":["../../../../../../../lib/js-api/src/api/activiti-rest-api/api/appDefinitions.api.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n    AppDefinitionPublishRepresentation,\n    AppDefinitionRepresentation,\n    AppDefinitionSaveRepresentation,\n    AppDefinitionUpdateResultRepresentation\n} from '../model';\nimport { BaseApi } from './base.api';\nimport { throwIfNotDefined } from '../../../assert';\n\n/**\n * AppDefinitionsApi service.\n */\nexport class AppDefinitionsApi extends BaseApi {\n    /**\n     * deleteAppDefinition\n     *\n     * @param appDefinitionId appDefinitionId\n     * @return Promise<{}>\n     */\n    deleteAppDefinition(appDefinitionId: number): Promise<void> {\n        throwIfNotDefined(appDefinitionId, 'appDefinitionId');\n\n        const pathParams = {\n            appDefinitionId\n        };\n\n        return this.delete({\n            path: '/api/enterprise/app-definitions/{appDefinitionId}',\n            pathParams\n        });\n    }\n\n    /**\n     * Export an app definition\n     *\n     * This will return a zip file containing the app definition model and all related models (process definitions and forms).\n     *\n     * @param modelId modelId from a runtime app or the id of an app definition model\n     * @return Promise<{}>\n     */\n    exportAppDefinition(modelId: number): Promise<any> {\n        throwIfNotDefined(modelId, 'modelId');\n\n        const pathParams = {\n            modelId\n        };\n\n        const contentTypes = ['application/json'];\n        const accepts = ['application/json', 'application/zip'];\n\n        return this.get({\n            path: '/api/enterprise/app-definitions/{modelId}/export',\n            pathParams,\n            contentTypes,\n            accepts\n        });\n    }\n\n    /**\n     * Get an app definition\n     *\n     * @param modelId Application definition ID\n     * @return Promise<AppDefinitionRepresentation>\n     */\n    getAppDefinition(modelId: number): Promise<AppDefinitionRepresentation> {\n        throwIfNotDefined(modelId, 'modelId');\n\n        const pathParams = {\n            modelId\n        };\n\n        return this.get({\n            path: '/api/enterprise/app-definitions/{modelId}',\n            pathParams\n        });\n    }\n\n    /**\n     * importAndPublishApp\n     *\n     * @param file file\n     * @param opts options\n     * @return Promise<AppDefinitionUpdateResultRepresentation>\n     */\n    importAndPublishApp(file: any, opts?: { renewIdmEntries?: boolean }): Promise<AppDefinitionUpdateResultRepresentation> {\n        throwIfNotDefined(file, 'file');\n\n        const formParams = {\n            file\n        };\n\n        const queryParams = {\n            renewIdmEntries: opts?.renewIdmEntries\n        };\n\n        return this.post({\n            path: '/api/enterprise/app-definitions/publish-app',\n            formParams,\n            queryParams,\n            contentTypes: ['multipart/form-data']\n        });\n    }\n\n    /**\n     * Import a new app definition\n     *\n     * Allows a zip file to be uploaded containing an app definition and any number of included models.\n     * <p>This is useful to bootstrap an environment (for users or continuous integration).<p>\n     * Before using any processes included in the import the app must be published and deployed.\n     *\n     * @param file file\n     * @param opts Optional parameters\n     * @param opts.renewIdmEntries Whether to renew user and group identifiers (default to false)\n     * @return Promise<AppDefinitionRepresentation>\n     */\n    importAppDefinition(file: any, opts?: { renewIdmEntries?: string }): Promise<AppDefinitionRepresentation> {\n        throwIfNotDefined(file, 'file');\n\n        const formParams = {\n            file\n        };\n\n        return this.post({\n            path: '/api/enterprise/app-definitions/import',\n            queryParams: opts,\n            formParams,\n            contentTypes: ['multipart/form-data']\n        });\n    }\n\n    /**\n     * Publish an app definition\n     *\n     * Publishing an app definition makes it available for use. The application must not have any validation errors or an error will be returned.<p>Before an app definition can be used by other users, it must also be deployed for their use\n     *\n     * @param modelId modelId\n     * @param publishModel publishModel\n     * @return Promise<AppDefinitionUpdateResultRepresentation>\n     */\n    publishAppDefinition(modelId: number, publishModel: AppDefinitionPublishRepresentation): Promise<AppDefinitionUpdateResultRepresentation> {\n        throwIfNotDefined(modelId, 'modelId');\n        throwIfNotDefined(publishModel, 'publishModel');\n\n        const pathParams = {\n            modelId\n        };\n\n        return this.post({\n            path: '/api/enterprise/app-definitions/{modelId}/publish',\n            pathParams,\n            bodyParam: publishModel\n        });\n    }\n\n    /**\n     * Update an app definition\n     *\n     * @param modelId Application definition ID\n     * @param updatedModel updatedModel |\n     * @return Promise<AppDefinitionUpdateResultRepresentation>\n     */\n    updateAppDefinition(modelId: number, updatedModel: AppDefinitionSaveRepresentation | any): Promise<any> {\n        throwIfNotDefined(modelId, 'modelId');\n        throwIfNotDefined(updatedModel, 'updatedModel');\n\n        const pathParams = {\n            modelId\n        };\n\n        if (!updatedModel['appDefinition']) {\n            const formParams = {\n                file: updatedModel\n            };\n\n            return this.post({\n                path: '/api/enterprise/app-definitions/{modelId}/import',\n                pathParams,\n                formParams,\n                bodyParam: updatedModel,\n                contentTypes: ['multipart/form-data']\n            });\n        } else {\n            return this.put({\n                path: '/api/enterprise/app-definitions/{modelId}',\n                pathParams,\n                bodyParam: updatedModel\n            });\n        }\n    }\n}\n"]}

package/esm2020/api/activiti-rest-api/api/base.api.mjs

@@ -0,0 +1,23 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ApiClient } from '../../../api-clients/api-client';
+export class BaseApi extends ApiClient {
+    get apiClient() {
+        return this.httpClient ?? this.alfrescoApi.processClient;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5hcGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvanMtYXBpL3NyYy9hcGkvYWN0aXZpdGktcmVzdC1hcGkvYXBpL2Jhc2UuYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUc1RCxNQUFNLE9BQWdCLE9BQVEsU0FBUSxTQUFTO0lBQzNDLElBQWEsU0FBUztRQUNsQixPQUFPLElBQUksQ0FBQyxVQUFVLElBQUksSUFBSSxDQUFDLFdBQVcsQ0FBQyxhQUFhLENBQUM7SUFDN0QsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyMyBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQgeyBBcGlDbGllbnQgfSBmcm9tICcuLi8uLi8uLi9hcGktY2xpZW50cy9hcGktY2xpZW50JztcbmltcG9ydCB7IExlZ2FjeUh0dHBDbGllbnQgfSBmcm9tICcuLi8uLi8uLi9hcGktY2xpZW50cy9odHRwLWNsaWVudC5pbnRlcmZhY2UnO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQmFzZUFwaSBleHRlbmRzIEFwaUNsaWVudCB7XG4gICAgb3ZlcnJpZGUgZ2V0IGFwaUNsaWVudCgpOiBMZWdhY3lIdHRwQ2xpZW50IHtcbiAgICAgICAgcmV0dXJuIHRoaXMuaHR0cENsaWVudCA/PyB0aGlzLmFsZnJlc2NvQXBpLnByb2Nlc3NDbGllbnQ7XG4gICAgfVxufVxuIl19

package/esm2020/api/activiti-rest-api/api/checklists.api.mjs

@@ -0,0 +1,82 @@
+/*!
+ * @license
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ResultListDataRepresentationTaskRepresentation } from '../model/resultListDataRepresentationTaskRepresentation';
+import { TaskRepresentation } from '../model/taskRepresentation';
+import { BaseApi } from './base.api';
+import { throwIfNotDefined } from '../../../assert';
+/**
+ * Checklists service.
+ */
+export class ChecklistsApi extends BaseApi {
+    /**
+     * Create a task checklist
+     *
+     * @param taskId taskId
+     * @param taskRepresentation taskRepresentation
+     * @return Promise<TaskRepresentation>
+     */
+    addSubtask(taskId, taskRepresentation) {
+        throwIfNotDefined(taskId, 'taskId');
+        throwIfNotDefined(taskRepresentation, 'taskRepresentation');
+        const pathParams = {
+            taskId
+        };
+        return this.post({
+            path: '/api/enterprise/tasks/{taskId}/checklist',
+            pathParams,
+            bodyParam: taskRepresentation,
+            returnType: TaskRepresentation
+        });
+    }
+    /**
+     * Get checklist for a task
+     *
+     * @param taskId taskId
+     * @return Promise<ResultListDataRepresentationTaskRepresentation>
+     */
+    getChecklist(taskId) {
+        throwIfNotDefined(taskId, 'taskId');
+        const pathParams = {
+            taskId
+        };
+        return this.get({
+            path: '/api/enterprise/tasks/{taskId}/checklist',
+            pathParams,
+            returnType: ResultListDataRepresentationTaskRepresentation
+        });
+    }
+    /**
+     * Change the order of items on a checklist
+     *
+     * @param taskId taskId
+     * @param orderRepresentation orderRepresentation
+     * @return Promise<{}>
+     */
+    orderChecklist(taskId, orderRepresentation) {
+        throwIfNotDefined(taskId, 'taskId');
+        throwIfNotDefined(orderRepresentation, 'orderRepresentation');
+        const pathParams = {
+            taskId
+        };
+        return this.put({
+            path: '/api/enterprise/tasks/{taskId}/checklist',
+            bodyParam: orderRepresentation,
+            pathParams
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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