@webiny/api-aco 0.0.0-unstable.b14eaecf38 → 0.0.0-unstable.b6d7105cee

package/filter/filter.types.d.ts

@@ -0,0 +1,67 @@
+import type { AcoBaseFields, ListMeta, ListSort } from "../types.js";
+export declare enum Operation {
+    AND = "AND",
+    OR = "OR"
+}
+export interface GroupFilter {
+    field: string;
+    condition: string;
+    value: string;
+}
+export interface Group {
+    operation: Operation;
+    filters: GroupFilter[];
+}
+export interface Filter extends AcoBaseFields {
+    name: string;
+    description?: string;
+    namespace: string;
+    operation: Operation;
+    groups: Group[];
+}
+export interface ListFiltersWhere {
+    namespace: string;
+}
+export interface ListFiltersParams {
+    where: ListFiltersWhere;
+    sort?: ListSort;
+    limit?: number;
+    after?: string | null;
+}
+export type CreateFilterParams = Pick<Filter, "id" | "name" | "description" | "namespace" | "operation" | "groups">;
+export interface UpdateFilterParams {
+    name?: string;
+    description?: string;
+    namespace?: string;
+    operation?: Operation;
+    groups?: Group[];
+}
+export interface DeleteFilterParams {
+    id: string;
+}
+export interface StorageOperationsGetFilterParams {
+    id: string;
+}
+export type StorageOperationsListFiltersParams = ListFiltersParams;
+export interface StorageOperationsCreateFilterParams {
+    data: CreateFilterParams;
+}
+export interface StorageOperationsUpdateFilterParams {
+    id: string;
+    data: UpdateFilterParams;
+}
+export type StorageOperationsDeleteFilterParams = DeleteFilterParams;
+export interface AcoFilterCrud {
+    get(id: string): Promise<Filter>;
+    list(params: ListFiltersParams): Promise<[Filter[], ListMeta]>;
+    create(data: CreateFilterParams): Promise<Filter>;
+    update(id: string, data: UpdateFilterParams): Promise<Filter>;
+    delete(id: string): Promise<boolean>;
+}
+export interface AcoFilterStorageOperations {
+    getFilter(params: StorageOperationsGetFilterParams): Promise<Filter>;
+    listFilters(params: StorageOperationsListFiltersParams): Promise<[Filter[], ListMeta]>;
+    createFilter(params: StorageOperationsCreateFilterParams): Promise<Filter>;
+    updateFilter(params: StorageOperationsUpdateFilterParams): Promise<Filter>;
+    deleteFilter(params: StorageOperationsDeleteFilterParams): Promise<boolean>;
+}

package/filter/filter.types.js

@@ -0,0 +1,8 @@
+var filter_types_Operation = /*#__PURE__*/ function(Operation) {
+    Operation["AND"] = "AND";
+    Operation["OR"] = "OR";
+    return Operation;
+}({});
+export { filter_types_Operation as Operation };
+
+//# sourceMappingURL=filter.types.js.map

package/filter/filter.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter/filter.types.js","sources":["../../src/filter/filter.types.ts"],"sourcesContent":["import type { AcoBaseFields, ListMeta, ListSort } from \"~/types.js\";\n\nexport enum Operation {\n    AND = \"AND\",\n    OR = \"OR\"\n}\n\nexport interface GroupFilter {\n    field: string;\n    condition: string;\n    value: string;\n}\n\nexport interface Group {\n    operation: Operation;\n    filters: GroupFilter[];\n}\n\nexport interface Filter extends AcoBaseFields {\n    name: string;\n    description?: string;\n    namespace: string;\n    operation: Operation;\n    groups: Group[];\n}\n\nexport interface ListFiltersWhere {\n    namespace: string;\n}\n\nexport interface ListFiltersParams {\n    where: ListFiltersWhere;\n    sort?: ListSort;\n    limit?: number;\n    after?: string | null;\n}\n\nexport type CreateFilterParams = Pick<\n    Filter,\n    \"id\" | \"name\" | \"description\" | \"namespace\" | \"operation\" | \"groups\"\n>;\n\nexport interface UpdateFilterParams {\n    name?: string;\n    description?: string;\n    namespace?: string;\n    operation?: Operation;\n    groups?: Group[];\n}\n\nexport interface DeleteFilterParams {\n    id: string;\n}\n\nexport interface StorageOperationsGetFilterParams {\n    id: string;\n}\n\nexport type StorageOperationsListFiltersParams = ListFiltersParams;\n\nexport interface StorageOperationsCreateFilterParams {\n    data: CreateFilterParams;\n}\n\nexport interface StorageOperationsUpdateFilterParams {\n    id: string;\n    data: UpdateFilterParams;\n}\n\nexport type StorageOperationsDeleteFilterParams = DeleteFilterParams;\n\nexport interface AcoFilterCrud {\n    get(id: string): Promise<Filter>;\n    list(params: ListFiltersParams): Promise<[Filter[], ListMeta]>;\n    create(data: CreateFilterParams): Promise<Filter>;\n    update(id: string, data: UpdateFilterParams): Promise<Filter>;\n    delete(id: string): Promise<boolean>;\n}\n\nexport interface AcoFilterStorageOperations {\n    getFilter(params: StorageOperationsGetFilterParams): Promise<Filter>;\n    listFilters(params: StorageOperationsListFiltersParams): Promise<[Filter[], ListMeta]>;\n    createFilter(params: StorageOperationsCreateFilterParams): Promise<Filter>;\n    updateFilter(params: StorageOperationsUpdateFilterParams): Promise<Filter>;\n    deleteFilter(params: StorageOperationsDeleteFilterParams): Promise<boolean>;\n}\n"],"names":["Operation"],"mappings":"AAEO,IAAKA,yBAASA,WAAAA,GAAAA,SAATA,SAAS;;;WAATA"}

package/flp/flp.crud.d.ts

@@ -0,0 +1,7 @@
+import { type AcoFolderLevelPermissionsCrud, type AcoStorageOperations } from "../types.js";
+import type { Tenant } from "@webiny/api-core/types/tenancy.js";
+export interface CreateFlpCrudMethodsParams {
+    getTenant: () => Tenant;
+    storageOperations: AcoStorageOperations;
+}
+export declare const createFlpCrudMethods: ({ storageOperations, getTenant }: CreateFlpCrudMethodsParams) => AcoFolderLevelPermissionsCrud;

package/flp/flp.crud.js

@@ -0,0 +1,74 @@
+import { WebinyError } from "@webiny/error";
+import { EntryId } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+const createFlpCrudMethods = ({ storageOperations, getTenant })=>({
+        async create (params) {
+            return await storageOperations.flp.create({
+                data: {
+                    ...params,
+                    tenant: getTenant().id
+                }
+            });
+        },
+        async update (id, data) {
+            const original = await this.get(id);
+            if (!original) throw new WebinyError(`Folder level permission with id "${id}" not found.`, "GET_ITEM_UPDATE_FLP_ERROR", {
+                id,
+                data
+            });
+            return await storageOperations.flp.update({
+                original,
+                data: {
+                    ...data,
+                    tenant: getTenant().id
+                }
+            });
+        },
+        async batchUpdate (items) {
+            const batchItems = (await Promise.all(items.map(async ({ id, data })=>{
+                const original = await this.get(id);
+                if (!original) return null;
+                return {
+                    original,
+                    data: {
+                        ...data,
+                        tenant: getTenant().id
+                    }
+                };
+            }))).filter((item)=>null !== item);
+            if (0 === batchItems.length) return [];
+            return await storageOperations.flp.batchUpdate({
+                items: batchItems
+            });
+        },
+        async delete (id) {
+            const flp = await this.get(id);
+            if (!flp) throw new WebinyError(`Folder level permission with id "${id}" not found.`, "GET_ITEM_DELETE_FLP_ERROR", {
+                id
+            });
+            await storageOperations.flp.delete({
+                flp: {
+                    ...flp,
+                    tenant: getTenant().id
+                }
+            });
+            return true;
+        },
+        async get (id) {
+            const entryId = EntryId.from(id);
+            return await storageOperations.flp.get({
+                id: entryId.id,
+                tenant: getTenant().id
+            });
+        },
+        async list ({ where }) {
+            return await storageOperations.flp.list({
+                where: {
+                    ...where,
+                    tenant: getTenant().id
+                }
+            });
+        }
+    });
+export { createFlpCrudMethods };
+
+//# sourceMappingURL=flp.crud.js.map

package/flp/flp.crud.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flp/flp.crud.js","sources":["../../src/flp/flp.crud.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport {\n    type AcoFolderLevelPermissionsCrud,\n    type AcoStorageOperations,\n    type CreateFlpParams,\n    type UpdateFlpParams\n} from \"~/types.js\";\nimport type { Tenant } from \"@webiny/api-core/types/tenancy.js\";\nimport { EntryId } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\n\nexport interface CreateFlpCrudMethodsParams {\n    getTenant: () => Tenant;\n    storageOperations: AcoStorageOperations;\n}\n\nexport const createFlpCrudMethods = ({\n    storageOperations,\n    getTenant\n}: CreateFlpCrudMethodsParams): AcoFolderLevelPermissionsCrud => {\n    return {\n        async create(params: CreateFlpParams) {\n            return await storageOperations.flp.create({\n                data: { ...params, tenant: getTenant().id }\n            });\n        },\n        async update(id: string, data: UpdateFlpParams) {\n            const original = await this.get(id);\n            if (!original) {\n                throw new WebinyError(\n                    `Folder level permission with id \"${id}\" not found.`,\n                    \"GET_ITEM_UPDATE_FLP_ERROR\",\n                    {\n                        id,\n                        data\n                    }\n                );\n            }\n\n            return await storageOperations.flp.update({\n                original,\n                data: {\n                    ...data,\n                    tenant: getTenant().id\n                }\n            });\n        },\n        async batchUpdate(items: Array<{ id: string; data: UpdateFlpParams }>) {\n            const batchItems = (\n                await Promise.all(\n                    items.map(async ({ id, data }) => {\n                        const original = await this.get(id);\n                        if (!original) {\n                            return null;\n                        }\n                        return {\n                            original,\n                            data: {\n                                ...data,\n                                tenant: getTenant().id\n                            }\n                        };\n                    })\n                )\n            ).filter((item): item is NonNullable<typeof item> => item !== null);\n\n            if (batchItems.length === 0) {\n                return [];\n            }\n\n            return await storageOperations.flp.batchUpdate({\n                items: batchItems\n            });\n        },\n        async delete(id: string) {\n            const flp = await this.get(id);\n            if (!flp) {\n                throw new WebinyError(\n                    `Folder level permission with id \"${id}\" not found.`,\n                    \"GET_ITEM_DELETE_FLP_ERROR\",\n                    {\n                        id\n                    }\n                );\n            }\n\n            await storageOperations.flp.delete({\n                flp: {\n                    ...flp,\n                    tenant: getTenant().id\n                }\n            });\n\n            return true;\n        },\n        async get(id: string) {\n            const entryId = EntryId.from(id);\n            return await storageOperations.flp.get({\n                id: entryId.id,\n                tenant: getTenant().id\n            });\n        },\n        async list({ where }) {\n            return await storageOperations.flp.list({\n                where: {\n                    ...where,\n                    tenant: getTenant().id\n                }\n            });\n        }\n    };\n};\n"],"names":["createFlpCrudMethods","storageOperations","getTenant","params","id","data","original","WebinyError","items","batchItems","Promise","item","flp","entryId","EntryId","where"],"mappings":";;AAeO,MAAMA,uBAAuB,CAAC,EACjCC,iBAAiB,EACjBC,SAAS,EACgB,GAClB;QACH,MAAM,QAAOC,MAAuB;YAChC,OAAO,MAAMF,kBAAkB,GAAG,CAAC,MAAM,CAAC;gBACtC,MAAM;oBAAE,GAAGE,MAAM;oBAAE,QAAQD,YAAY,EAAE;gBAAC;YAC9C;QACJ;QACA,MAAM,QAAOE,EAAU,EAAEC,IAAqB;YAC1C,MAAMC,WAAW,MAAM,IAAI,CAAC,GAAG,CAACF;YAChC,IAAI,CAACE,UACD,MAAM,IAAIC,YACN,CAAC,iCAAiC,EAAEH,GAAG,YAAY,CAAC,EACpD,6BACA;gBACIA;gBACAC;YACJ;YAIR,OAAO,MAAMJ,kBAAkB,GAAG,CAAC,MAAM,CAAC;gBACtCK;gBACA,MAAM;oBACF,GAAGD,IAAI;oBACP,QAAQH,YAAY,EAAE;gBAC1B;YACJ;QACJ;QACA,MAAM,aAAYM,KAAmD;YACjE,MAAMC,aACF,OAAMC,QAAQ,GAAG,CACbF,MAAM,GAAG,CAAC,OAAO,EAAEJ,EAAE,EAAEC,IAAI,EAAE;gBACzB,MAAMC,WAAW,MAAM,IAAI,CAAC,GAAG,CAACF;gBAChC,IAAI,CAACE,UACD,OAAO;gBAEX,OAAO;oBACHA;oBACA,MAAM;wBACF,GAAGD,IAAI;wBACP,QAAQH,YAAY,EAAE;oBAC1B;gBACJ;YACJ,GAAE,EAER,MAAM,CAAC,CAACS,OAA2CA,AAAS,SAATA;YAErD,IAAIF,AAAsB,MAAtBA,WAAW,MAAM,EACjB,OAAO,EAAE;YAGb,OAAO,MAAMR,kBAAkB,GAAG,CAAC,WAAW,CAAC;gBAC3C,OAAOQ;YACX;QACJ;QACA,MAAM,QAAOL,EAAU;YACnB,MAAMQ,MAAM,MAAM,IAAI,CAAC,GAAG,CAACR;YAC3B,IAAI,CAACQ,KACD,MAAM,IAAIL,YACN,CAAC,iCAAiC,EAAEH,GAAG,YAAY,CAAC,EACpD,6BACA;gBACIA;YACJ;YAIR,MAAMH,kBAAkB,GAAG,CAAC,MAAM,CAAC;gBAC/B,KAAK;oBACD,GAAGW,GAAG;oBACN,QAAQV,YAAY,EAAE;gBAC1B;YACJ;YAEA,OAAO;QACX;QACA,MAAM,KAAIE,EAAU;YAChB,MAAMS,UAAUC,QAAQ,IAAI,CAACV;YAC7B,OAAO,MAAMH,kBAAkB,GAAG,CAAC,GAAG,CAAC;gBACnC,IAAIY,QAAQ,EAAE;gBACd,QAAQX,YAAY,EAAE;YAC1B;QACJ;QACA,MAAM,MAAK,EAAEa,KAAK,EAAE;YAChB,OAAO,MAAMd,kBAAkB,GAAG,CAAC,IAAI,CAAC;gBACpC,OAAO;oBACH,GAAGc,KAAK;oBACR,QAAQb,YAAY,EAAE;gBAC1B;YACJ;QACJ;IACJ"}

package/flp/flp.types.d.ts

@@ -0,0 +1,93 @@
+import { type Folder } from "../types.js";
+import type { FolderLevelPermission, FolderPermission } from "@webiny/shared-aco/flp/flp.types.js";
+export type * from "@webiny/shared-aco/flp/flp.types.js";
+/********
+ * CRUD operations
+ *******/
+export interface ListFlpsParams {
+    where: {
+        path_startsWith?: string;
+        parentId?: string;
+        type: string;
+    };
+}
+export type CreateFlpParams = Pick<FolderLevelPermission, "id" | "type" | "permissions" | "path" | "parentId" | "slug">;
+export interface UpdateFlpParams {
+    parentId?: string;
+    slug?: string;
+    path?: string;
+    permissions?: FolderPermission[];
+    type?: string;
+}
+export interface AcoFolderLevelPermissionsCrud {
+    list(params: ListFlpsParams): Promise<FolderLevelPermission[]>;
+    get(id: string): Promise<FolderLevelPermission | null>;
+    create(params: CreateFlpParams): Promise<FolderLevelPermission>;
+    update(id: string, data: UpdateFlpParams): Promise<FolderLevelPermission>;
+    delete(id: string): Promise<boolean>;
+    batchUpdate(items: Array<{
+        id: string;
+        data: UpdateFlpParams;
+    }>): Promise<FolderLevelPermission[]>;
+}
+/********
+ * Storage operations
+ *******/
+export interface StorageOperationsListFlpsParams {
+    where: ListFlpsParams["where"] & {
+        tenant: string;
+    };
+}
+export interface StorageOperationsGetFlpParams {
+    id: string;
+    tenant: string;
+}
+export type StorageOperationsCreateFlpParams = {
+    data: FolderLevelPermission & {
+        tenant: string;
+    };
+};
+export type StorageOperationsUpdateFlpParams = {
+    original: FolderLevelPermission;
+    data: UpdateFlpParams & {
+        tenant: string;
+    };
+};
+export type StorageOperationsDeleteFlpParams = {
+    flp: FolderLevelPermission & {
+        tenant: string;
+    };
+};
+export interface StorageOperationsBatchUpdateFlpParams {
+    items: Array<{
+        original: FolderLevelPermission;
+        data: UpdateFlpParams & {
+            tenant: string;
+        };
+    }>;
+}
+export interface AcoFolderLevelPermissionsStorageOperations {
+    list(params: StorageOperationsListFlpsParams): Promise<FolderLevelPermission[]>;
+    get(params: StorageOperationsGetFlpParams): Promise<FolderLevelPermission | null>;
+    create(params: StorageOperationsCreateFlpParams): Promise<FolderLevelPermission>;
+    update(params: StorageOperationsUpdateFlpParams): Promise<FolderLevelPermission>;
+    delete(params: StorageOperationsDeleteFlpParams): Promise<void>;
+    batchUpdate(params: StorageOperationsBatchUpdateFlpParams): Promise<FolderLevelPermission[]>;
+}
+/********
+ *  Background Tasks
+ *******/
+export interface ICreateFlpTaskInput {
+    folder: Folder;
+}
+export interface IUpdateFlpTaskInput {
+    folder: Folder;
+    queued?: string[];
+}
+export interface IDeleteFlpTaskInput {
+    folder: Folder;
+}
+export interface ISyncFlpTaskInput {
+    type?: string;
+    folderId?: string;
+}

package/flp/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./flp.crud.js";
+export * from "./tasks/index.js";

package/flp/index.js

@@ -0,0 +1,2 @@
+export * from "./flp.crud.js";
+export * from "./tasks/index.js";

package/flp/tasks/createFlp.task.d.ts

@@ -0,0 +1,18 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { type ICreateFlpTaskInput } from "../../types.js";
+import { CreateFlpUseCase } from "../../features/flp/CreateFlp/index.js";
+declare class CreateFlpTaskImpl implements TaskDefinition.Interface<ICreateFlpTaskInput> {
+    private createFlp;
+    readonly id = "acoCreateFlp";
+    readonly title = "ACO - Create FLP record";
+    readonly description = "Synchronizes the FLP catalog by creating the FLP record based on the provided folder.";
+    readonly databaseLogs = false;
+    readonly isPrivate = true;
+    readonly selfCleanup: ("onAbort" | "onSuccess")[];
+    constructor(createFlp: CreateFlpUseCase.Interface);
+    run({ input, controller }: TaskDefinition.RunParams<ICreateFlpTaskInput>): Promise<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultAborted | import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultError | TaskDefinition.ResultContinue<ICreateFlpTaskInput> | TaskDefinition.ResultDone<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+}
+export declare const CreateFlpTask: typeof CreateFlpTaskImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskDefinition<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+};
+export {};

package/flp/tasks/createFlp.task.js

@@ -0,0 +1,36 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { CREATE_FLP_TASK_ID } from "./index.js";
+import { CreateFlpUseCase } from "../../features/flp/CreateFlp/index.js";
+class CreateFlpTaskImpl {
+    constructor(createFlp){
+        this.createFlp = createFlp;
+        this.id = CREATE_FLP_TASK_ID;
+        this.title = "ACO - Create FLP record";
+        this.description = "Synchronizes the FLP catalog by creating the FLP record based on the provided folder.";
+        this.databaseLogs = false;
+        this.isPrivate = true;
+        this.selfCleanup = [
+            "onSuccess",
+            "onAbort"
+        ];
+    }
+    async run({ input, controller }) {
+        try {
+            if (controller.runtime.isAborted()) return controller.response.aborted();
+            if (controller.runtime.isCloseToTimeout()) return controller.response.continue(input);
+            await this.createFlp.execute(input.folder);
+            return controller.response.done("Task done: FLP record created.");
+        } catch (error) {
+            return controller.response.error(error);
+        }
+    }
+}
+const CreateFlpTask = TaskDefinition.createImplementation({
+    implementation: CreateFlpTaskImpl,
+    dependencies: [
+        CreateFlpUseCase
+    ]
+});
+export { CreateFlpTask };
+
+//# sourceMappingURL=createFlp.task.js.map

package/flp/tasks/createFlp.task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flp/tasks/createFlp.task.js","sources":["../../../src/flp/tasks/createFlp.task.ts"],"sourcesContent":["import { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { CREATE_FLP_TASK_ID } from \"~/flp/tasks/index.js\";\nimport { type ICreateFlpTaskInput } from \"~/types.js\";\nimport { CreateFlpUseCase } from \"~/features/flp/CreateFlp/index.js\";\n\nclass CreateFlpTaskImpl implements TaskDefinition.Interface<ICreateFlpTaskInput> {\n    public readonly id = CREATE_FLP_TASK_ID;\n    public readonly title = \"ACO - Create FLP record\";\n    public readonly description =\n        \"Synchronizes the FLP catalog by creating the FLP record based on the provided folder.\";\n    public readonly databaseLogs = false;\n    public readonly isPrivate = true;\n    public readonly selfCleanup = [\"onSuccess\" as const, \"onAbort\" as const];\n\n    constructor(private createFlp: CreateFlpUseCase.Interface) {}\n\n    async run({ input, controller }: TaskDefinition.RunParams<ICreateFlpTaskInput>) {\n        try {\n            if (controller.runtime.isAborted()) {\n                return controller.response.aborted();\n            }\n\n            if (controller.runtime.isCloseToTimeout()) {\n                return controller.response.continue(input);\n            }\n\n            await this.createFlp.execute(input.folder);\n\n            return controller.response.done(\"Task done: FLP record created.\");\n        } catch (error) {\n            return controller.response.error(error);\n        }\n    }\n}\n\nexport const CreateFlpTask = TaskDefinition.createImplementation({\n    implementation: CreateFlpTaskImpl,\n    dependencies: [CreateFlpUseCase]\n});\n"],"names":["CreateFlpTaskImpl","createFlp","CREATE_FLP_TASK_ID","input","controller","error","CreateFlpTask","TaskDefinition","CreateFlpUseCase"],"mappings":";;;AAKA,MAAMA;IASF,YAAoBC,SAAqC,CAAE;aAAvCA,SAAS,GAATA;aARJ,EAAE,GAAGC;aACL,KAAK,GAAG;aACR,WAAW,GACvB;aACY,YAAY,GAAG;aACf,SAAS,GAAG;aACZ,WAAW,GAAG;YAAC;YAAsB;SAAmB;IAEZ;IAE5D,MAAM,IAAI,EAAEC,KAAK,EAAEC,UAAU,EAAiD,EAAE;QAC5E,IAAI;YACA,IAAIA,WAAW,OAAO,CAAC,SAAS,IAC5B,OAAOA,WAAW,QAAQ,CAAC,OAAO;YAGtC,IAAIA,WAAW,OAAO,CAAC,gBAAgB,IACnC,OAAOA,WAAW,QAAQ,CAAC,QAAQ,CAACD;YAGxC,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACA,MAAM,MAAM;YAEzC,OAAOC,WAAW,QAAQ,CAAC,IAAI,CAAC;QACpC,EAAE,OAAOC,OAAO;YACZ,OAAOD,WAAW,QAAQ,CAAC,KAAK,CAACC;QACrC;IACJ;AACJ;AAEO,MAAMC,gBAAgBC,eAAe,oBAAoB,CAAC;IAC7D,gBAAgBP;IAChB,cAAc;QAACQ;KAAiB;AACpC"}

package/flp/tasks/deleteFlp.task.d.ts

@@ -0,0 +1,18 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { type IDeleteFlpTaskInput } from "../../types.js";
+import { DeleteFlpUseCase } from "../../features/flp/DeleteFlp/index.js";
+declare class DeleteFlpTaskImpl implements TaskDefinition.Interface<IDeleteFlpTaskInput> {
+    private deleteFlp;
+    readonly id = "acoDeleteFlp";
+    readonly title = "ACO - Delete FLP record";
+    readonly description = "Synchronizes the FLP catalog by deleting the FLP record based on the provided folder.";
+    readonly databaseLogs = false;
+    readonly isPrivate = true;
+    readonly selfCleanup: ("onAbort" | "onSuccess")[];
+    constructor(deleteFlp: DeleteFlpUseCase.Interface);
+    run({ input, controller }: TaskDefinition.RunParams<IDeleteFlpTaskInput>): Promise<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultAborted | import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultError | TaskDefinition.ResultContinue<IDeleteFlpTaskInput> | TaskDefinition.ResultDone<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+}
+export declare const DeleteFlpTask: typeof DeleteFlpTaskImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskDefinition<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+};
+export {};

package/flp/tasks/deleteFlp.task.js

@@ -0,0 +1,36 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { DELETE_FLP_TASK_ID } from "./index.js";
+import { DeleteFlpUseCase } from "../../features/flp/DeleteFlp/index.js";
+class DeleteFlpTaskImpl {
+    constructor(deleteFlp){
+        this.deleteFlp = deleteFlp;
+        this.id = DELETE_FLP_TASK_ID;
+        this.title = "ACO - Delete FLP record";
+        this.description = "Synchronizes the FLP catalog by deleting the FLP record based on the provided folder.";
+        this.databaseLogs = false;
+        this.isPrivate = true;
+        this.selfCleanup = [
+            "onSuccess",
+            "onAbort"
+        ];
+    }
+    async run({ input, controller }) {
+        try {
+            if (controller.runtime.isAborted()) return controller.response.aborted();
+            if (controller.runtime.isCloseToTimeout()) return controller.response.continue(input);
+            await this.deleteFlp.execute(input.folder);
+            return controller.response.done("Task done: FLP record deleted.");
+        } catch (error) {
+            return controller.response.error(error);
+        }
+    }
+}
+const DeleteFlpTask = TaskDefinition.createImplementation({
+    implementation: DeleteFlpTaskImpl,
+    dependencies: [
+        DeleteFlpUseCase
+    ]
+});
+export { DeleteFlpTask };
+
+//# sourceMappingURL=deleteFlp.task.js.map

package/flp/tasks/deleteFlp.task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flp/tasks/deleteFlp.task.js","sources":["../../../src/flp/tasks/deleteFlp.task.ts"],"sourcesContent":["import { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { DELETE_FLP_TASK_ID } from \"~/flp/tasks/index.js\";\nimport { type IDeleteFlpTaskInput } from \"~/types.js\";\nimport { DeleteFlpUseCase } from \"~/features/flp/DeleteFlp/index.js\";\n\nclass DeleteFlpTaskImpl implements TaskDefinition.Interface<IDeleteFlpTaskInput> {\n    public readonly id = DELETE_FLP_TASK_ID;\n    public readonly title = \"ACO - Delete FLP record\";\n    public readonly description =\n        \"Synchronizes the FLP catalog by deleting the FLP record based on the provided folder.\";\n    public readonly databaseLogs = false;\n    public readonly isPrivate = true;\n    public readonly selfCleanup = [\"onSuccess\" as const, \"onAbort\" as const];\n\n    constructor(private deleteFlp: DeleteFlpUseCase.Interface) {}\n\n    async run({ input, controller }: TaskDefinition.RunParams<IDeleteFlpTaskInput>) {\n        try {\n            if (controller.runtime.isAborted()) {\n                return controller.response.aborted();\n            }\n\n            if (controller.runtime.isCloseToTimeout()) {\n                return controller.response.continue(input);\n            }\n\n            await this.deleteFlp.execute(input.folder);\n\n            return controller.response.done(\"Task done: FLP record deleted.\");\n        } catch (error) {\n            return controller.response.error(error);\n        }\n    }\n}\n\nexport const DeleteFlpTask = TaskDefinition.createImplementation({\n    implementation: DeleteFlpTaskImpl,\n    dependencies: [DeleteFlpUseCase]\n});\n"],"names":["DeleteFlpTaskImpl","deleteFlp","DELETE_FLP_TASK_ID","input","controller","error","DeleteFlpTask","TaskDefinition","DeleteFlpUseCase"],"mappings":";;;AAKA,MAAMA;IASF,YAAoBC,SAAqC,CAAE;aAAvCA,SAAS,GAATA;aARJ,EAAE,GAAGC;aACL,KAAK,GAAG;aACR,WAAW,GACvB;aACY,YAAY,GAAG;aACf,SAAS,GAAG;aACZ,WAAW,GAAG;YAAC;YAAsB;SAAmB;IAEZ;IAE5D,MAAM,IAAI,EAAEC,KAAK,EAAEC,UAAU,EAAiD,EAAE;QAC5E,IAAI;YACA,IAAIA,WAAW,OAAO,CAAC,SAAS,IAC5B,OAAOA,WAAW,QAAQ,CAAC,OAAO;YAGtC,IAAIA,WAAW,OAAO,CAAC,gBAAgB,IACnC,OAAOA,WAAW,QAAQ,CAAC,QAAQ,CAACD;YAGxC,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACA,MAAM,MAAM;YAEzC,OAAOC,WAAW,QAAQ,CAAC,IAAI,CAAC;QACpC,EAAE,OAAOC,OAAO;YACZ,OAAOD,WAAW,QAAQ,CAAC,KAAK,CAACC;QACrC;IACJ;AACJ;AAEO,MAAMC,gBAAgBC,eAAe,oBAAoB,CAAC;IAC7D,gBAAgBP;IAChB,cAAc;QAACQ;KAAiB;AACpC"}

package/flp/tasks/index.d.ts

@@ -0,0 +1,5 @@
+export declare const CREATE_FLP_TASK_ID = "acoCreateFlp";
+export declare const DELETE_FLP_TASK_ID = "acoDeleteFlp";
+export declare const UPDATE_FLP_TASK_ID = "acoUpdateFlp";
+export declare const SYNC_FLP_TASK_ID = "acoSyncFlp";
+export declare const flpTasks: () => import("@webiny/api").ContextPlugin<import("@webiny/api/types.js").Context>[];

package/flp/tasks/index.js

@@ -0,0 +1,20 @@
+import { CreateFlpTask } from "./createFlp.task.js";
+import { UpdateFlpTask } from "./updateFlp.task.js";
+import { DeleteFlpTask } from "./deleteFlp.task.js";
+import { SyncFlpTask } from "./syncFlp.task.js";
+import { createContextPlugin } from "@webiny/api";
+const CREATE_FLP_TASK_ID = "acoCreateFlp";
+const DELETE_FLP_TASK_ID = "acoDeleteFlp";
+const UPDATE_FLP_TASK_ID = "acoUpdateFlp";
+const SYNC_FLP_TASK_ID = "acoSyncFlp";
+const flpTasks = ()=>[
+        createContextPlugin((context)=>{
+            context.container.register(CreateFlpTask);
+            context.container.register(UpdateFlpTask);
+            context.container.register(DeleteFlpTask);
+            context.container.register(SyncFlpTask);
+        })
+    ];
+export { CREATE_FLP_TASK_ID, DELETE_FLP_TASK_ID, SYNC_FLP_TASK_ID, UPDATE_FLP_TASK_ID, flpTasks };
+
+//# sourceMappingURL=index.js.map

package/flp/tasks/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flp/tasks/index.js","sources":["../../../src/flp/tasks/index.ts"],"sourcesContent":["import { CreateFlpTask } from \"./createFlp.task.js\";\nimport { UpdateFlpTask } from \"./updateFlp.task.js\";\nimport { DeleteFlpTask } from \"./deleteFlp.task.js\";\nimport { SyncFlpTask } from \"./syncFlp.task.js\";\nimport { createContextPlugin } from \"@webiny/api\";\n\nexport const CREATE_FLP_TASK_ID = \"acoCreateFlp\";\nexport const DELETE_FLP_TASK_ID = \"acoDeleteFlp\";\nexport const UPDATE_FLP_TASK_ID = \"acoUpdateFlp\";\nexport const SYNC_FLP_TASK_ID = \"acoSyncFlp\";\n\nexport const flpTasks = () => {\n    return [\n        createContextPlugin(context => {\n            context.container.register(CreateFlpTask);\n            context.container.register(UpdateFlpTask);\n            context.container.register(DeleteFlpTask);\n            context.container.register(SyncFlpTask);\n        })\n    ];\n};\n"],"names":["CREATE_FLP_TASK_ID","DELETE_FLP_TASK_ID","UPDATE_FLP_TASK_ID","SYNC_FLP_TASK_ID","flpTasks","createContextPlugin","context","CreateFlpTask","UpdateFlpTask","DeleteFlpTask","SyncFlpTask"],"mappings":";;;;;AAMO,MAAMA,qBAAqB;AAC3B,MAAMC,qBAAqB;AAC3B,MAAMC,qBAAqB;AAC3B,MAAMC,mBAAmB;AAEzB,MAAMC,WAAW,IACb;QACHC,oBAAoBC,CAAAA;YAChBA,QAAQ,SAAS,CAAC,QAAQ,CAACC;YAC3BD,QAAQ,SAAS,CAAC,QAAQ,CAACE;YAC3BF,QAAQ,SAAS,CAAC,QAAQ,CAACG;YAC3BH,QAAQ,SAAS,CAAC,QAAQ,CAACI;QAC/B;KACH"}

package/flp/tasks/syncFlp.task.d.ts

@@ -0,0 +1,22 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/features/contentModel/ListModels/index.js";
+import { type ISyncFlpTaskInput } from "../../types.js";
+import { GetFolderUseCase } from "../../features/folder/GetFolder/index.js";
+import { ListFoldersUseCase } from "../../features/folder/ListFolders/index.js";
+declare class SyncFlpTaskImpl implements TaskDefinition.Interface<ISyncFlpTaskInput> {
+    private getFolder;
+    private listFolders;
+    private listModels;
+    readonly id = "acoSyncFlp";
+    readonly title = "ACO - Sync FLP record";
+    readonly description = "Synchronizes the FLP catalog by updating the FLP record and its descendants.";
+    readonly databaseLogs = false;
+    readonly isPrivate = true;
+    readonly selfCleanup: ("onAbort" | "onSuccess")[];
+    constructor(getFolder: GetFolderUseCase.Interface, listFolders: ListFoldersUseCase.Interface, listModels: ListModelsUseCase.Interface);
+    run({ input, controller }: TaskDefinition.RunParams<ISyncFlpTaskInput>): Promise<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultAborted | import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultError | TaskDefinition.ResultDone<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+}
+export declare const SyncFlpTask: typeof SyncFlpTaskImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskDefinition<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+};
+export {};

package/flp/tasks/syncFlp.task.js

@@ -0,0 +1,112 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/features/contentModel/ListModels/index.js";
+import { SYNC_FLP_TASK_ID, UPDATE_FLP_TASK_ID } from "./index.js";
+import { FM_FILE_TYPE } from "../../constants.js";
+import { GetFolderUseCase } from "../../features/folder/GetFolder/index.js";
+import { ListFoldersUseCase } from "../../features/folder/ListFolders/index.js";
+class SyncFlpTaskImpl {
+    constructor(getFolder, listFolders, listModels){
+        this.getFolder = getFolder;
+        this.listFolders = listFolders;
+        this.listModels = listModels;
+        this.id = SYNC_FLP_TASK_ID;
+        this.title = "ACO - Sync FLP record";
+        this.description = "Synchronizes the FLP catalog by updating the FLP record and its descendants.";
+        this.databaseLogs = false;
+        this.isPrivate = true;
+        this.selfCleanup = [
+            "onSuccess",
+            "onAbort"
+        ];
+    }
+    async run({ input, controller }) {
+        try {
+            if (controller.runtime.isAborted()) return controller.response.aborted();
+            if (input.folderId) {
+                const result = await this.getFolder.execute(input.folderId);
+                if (result.isFail()) return controller.response.error(result.error);
+                const folder = result.value;
+                await controller.task.trigger({
+                    definition: UPDATE_FLP_TASK_ID,
+                    input: {
+                        folder
+                    }
+                });
+                return controller.response.done(`Task completed successfully: all FLP records for folderId "${input.folderId}" and its children have been queued to be synchronized.`);
+            }
+            if (input.type && "*" === input.type) {
+                const folderTypes = [
+                    FM_FILE_TYPE
+                ];
+                const modelsResult = await this.listModels.execute();
+                if (modelsResult.isOk()) {
+                    const models = modelsResult.value;
+                    for (const model of models)folderTypes.push(`cms:${model.modelId}`);
+                }
+                for (const folderType of folderTypes){
+                    const result = await this.listFolders.execute({
+                        where: {
+                            type: folderType,
+                            parentId: null
+                        }
+                    });
+                    if (result.isFail()) {
+                        await controller.logger.error({
+                            message: `Failed to list root folders for type ${folderType}`,
+                            data: {
+                                type: folderType,
+                                error: result.error
+                            }
+                        });
+                        continue;
+                    }
+                    const { folders } = result.value;
+                    for (const folder of folders)await controller.task.trigger({
+                        definition: UPDATE_FLP_TASK_ID,
+                        input: {
+                            folder
+                        }
+                    });
+                    await controller.logger.info({
+                        message: `FLP Update task triggered for type ${folderType}`,
+                        data: {
+                            type: folderType
+                        }
+                    });
+                }
+                return controller.response.done("Task completed successfully: all FLP records have been queued to be synchronized.");
+            }
+            if (input.type) {
+                const result = await this.listFolders.execute({
+                    where: {
+                        type: input.type,
+                        parentId: null
+                    }
+                });
+                if (result.isFail()) return controller.response.error(result.error);
+                const { folders } = result.value;
+                for (const folder of folders)await controller.task.trigger({
+                    definition: UPDATE_FLP_TASK_ID,
+                    input: {
+                        folder
+                    }
+                });
+                return controller.response.done(`Task completed successfully: all FLP records for type "${input.type}" have been queued to be synchronized.`);
+            }
+            return controller.response.error("Invalid input: please provide either `type` or `folderId`.");
+        } catch (error) {
+            return controller.response.error(error);
+        }
+    }
+}
+const SyncFlpTask = TaskDefinition.createImplementation({
+    implementation: SyncFlpTaskImpl,
+    dependencies: [
+        GetFolderUseCase,
+        ListFoldersUseCase,
+        ListModelsUseCase
+    ]
+});
+export { SyncFlpTask };
+
+//# sourceMappingURL=syncFlp.task.js.map

package/flp/tasks/syncFlp.task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flp/tasks/syncFlp.task.js","sources":["../../../src/flp/tasks/syncFlp.task.ts"],"sourcesContent":["import { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { ListModelsUseCase } from \"@webiny/api-headless-cms/features/contentModel/ListModels/index.js\";\nimport { SYNC_FLP_TASK_ID, UPDATE_FLP_TASK_ID } from \"~/flp/tasks/index.js\";\nimport { type ISyncFlpTaskInput, type IUpdateFlpTaskInput } from \"~/types.js\";\nimport { FM_FILE_TYPE } from \"~/constants.js\";\nimport { GetFolderUseCase } from \"~/features/folder/GetFolder/index.js\";\nimport { ListFoldersUseCase } from \"~/features/folder/ListFolders/index.js\";\n\nclass SyncFlpTaskImpl implements TaskDefinition.Interface<ISyncFlpTaskInput> {\n    public readonly id = SYNC_FLP_TASK_ID;\n    public readonly title = \"ACO - Sync FLP record\";\n    public readonly description =\n        \"Synchronizes the FLP catalog by updating the FLP record and its descendants.\";\n    public readonly databaseLogs = false;\n    public readonly isPrivate = true;\n    public readonly selfCleanup = [\"onSuccess\" as const, \"onAbort\" as const];\n\n    public constructor(\n        private getFolder: GetFolderUseCase.Interface,\n        private listFolders: ListFoldersUseCase.Interface,\n        private listModels: ListModelsUseCase.Interface\n    ) {}\n\n    async run({ input, controller }: TaskDefinition.RunParams<ISyncFlpTaskInput>) {\n        try {\n            if (controller.runtime.isAborted()) {\n                return controller.response.aborted();\n            }\n\n            /**\n             * `folderId` provided in the task input. We need to:\n             *\n             * - update the FLP records for the found folder and all its descendants.\n             */\n            if (input.folderId) {\n                const result = await this.getFolder.execute(input.folderId);\n                if (result.isFail()) {\n                    return controller.response.error(result.error);\n                }\n                const folder = result.value;\n\n                await controller.task.trigger<IUpdateFlpTaskInput>({\n                    definition: UPDATE_FLP_TASK_ID,\n                    input: {\n                        folder\n                    }\n                });\n\n                return controller.response.done(\n                    `Task completed successfully: all FLP records for folderId \"${input.folderId}\" and its children have been queued to be synchronized.`\n                );\n            }\n\n            /**\n             *  Full update required. We need to:\n             *\n             *  - list cms models to collect their types, together with the default ones [FM_FILE_TYPE]\n             *  - list all root folders\n             *  - update the FLP records for the found folders and all its descendants.\n             */\n            if (input.type && input.type === \"*\") {\n                // Some folder types are fixed: pages and files.\n                const folderTypes = [FM_FILE_TYPE];\n\n                // List all non-private models\n                const modelsResult = await this.listModels.execute();\n                if (modelsResult.isOk()) {\n                    const models = modelsResult.value;\n                    for (const model of models) {\n                        folderTypes.push(`cms:${model.modelId}`);\n                    }\n                }\n\n                for (const folderType of folderTypes) {\n                    const result = await this.listFolders.execute({\n                        where: {\n                            type: folderType,\n                            parentId: null\n                        }\n                    });\n                    if (result.isFail()) {\n                        await controller.logger.error({\n                            message: `Failed to list root folders for type ${folderType}`,\n                            data: {\n                                type: folderType,\n                                error: result.error\n                            }\n                        });\n                        continue;\n                    }\n\n                    const { folders } = result.value;\n\n                    for (const folder of folders) {\n                        await controller.task.trigger<IUpdateFlpTaskInput>({\n                            definition: UPDATE_FLP_TASK_ID,\n                            input: {\n                                folder\n                            }\n                        });\n                    }\n\n                    await controller.logger.info({\n                        message: `FLP Update task triggered for type ${folderType}`,\n                        data: {\n                            type: folderType\n                        }\n                    });\n                }\n\n                return controller.response.done(\n                    `Task completed successfully: all FLP records have been queued to be synchronized.`\n                );\n            }\n\n            /**\n             * `type` provided in the task input. We need to:\n             *\n             * - list all root folders for the provided type\n             * - update the FLP records for the found folders and all its descendants.\n             */\n            if (input.type) {\n                const result = await this.listFolders.execute({\n                    where: {\n                        type: input.type!,\n                        parentId: null\n                    }\n                });\n                if (result.isFail()) {\n                    return controller.response.error(result.error);\n                }\n\n                const { folders } = result.value;\n\n                for (const folder of folders) {\n                    await controller.task.trigger<IUpdateFlpTaskInput>({\n                        definition: UPDATE_FLP_TASK_ID,\n                        input: {\n                            folder\n                        }\n                    });\n                }\n\n                return controller.response.done(\n                    `Task completed successfully: all FLP records for type \"${input.type}\" have been queued to be synchronized.`\n                );\n            }\n\n            return controller.response.error(\n                \"Invalid input: please provide either `type` or `folderId`.\"\n            );\n        } catch (error) {\n            return controller.response.error(error);\n        }\n    }\n}\n\nexport const SyncFlpTask = TaskDefinition.createImplementation({\n    implementation: SyncFlpTaskImpl,\n    dependencies: [GetFolderUseCase, ListFoldersUseCase, ListModelsUseCase]\n});\n"],"names":["SyncFlpTaskImpl","getFolder","listFolders","listModels","SYNC_FLP_TASK_ID","input","controller","result","folder","UPDATE_FLP_TASK_ID","folderTypes","FM_FILE_TYPE","modelsResult","models","model","folderType","folders","error","SyncFlpTask","TaskDefinition","GetFolderUseCase","ListFoldersUseCase","ListModelsUseCase"],"mappings":"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"}

package/flp/tasks/updateFlp.task.d.ts

@@ -0,0 +1,18 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { type IUpdateFlpTaskInput } from "../../types.js";
+import { UpdateFlpUseCase } from "../../features/flp/UpdateFlp/index.js";
+declare class UpdateFlpTaskImpl implements TaskDefinition.Interface<IUpdateFlpTaskInput> {
+    private updateFlp;
+    readonly id = "acoUpdateFlp";
+    readonly title = "ACO - Update FLP record";
+    readonly description = "Synchronizes the FLP catalog by updating the FLP record and its descendants based on the provided folder.";
+    readonly databaseLogs = false;
+    readonly isPrivate = true;
+    readonly selfCleanup: ("onAbort" | "onSuccess")[];
+    constructor(updateFlp: UpdateFlpUseCase.Interface);
+    run({ input, controller }: TaskDefinition.RunParams<IUpdateFlpTaskInput>): Promise<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultAborted | import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResultError | TaskDefinition.ResultDone<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+}
+export declare const UpdateFlpTask: typeof UpdateFlpTaskImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskDefinition<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+};
+export {};