@webiny/app-headless-cms 6.4.5-beta.0 → 6.6.0-alpha.0

package/features/model/createModel/CreateModelUseCase.d.ts

@@ -0,0 +1,11 @@
+import { CreateModelUseCase as UseCaseAbstraction, CreateModelRepository } from "./abstractions.js";
+import type { CreateModelParams } from "./abstractions.js";
+declare class CreateModelUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: CreateModelRepository.Interface);
+    execute(data: CreateModelParams): Promise<import("@webiny/app-headless-cms-common/types/model.js").CmsModel>;
+}
+export declare const CreateModelUseCase: typeof CreateModelUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateModelUseCase>;
+};
+export {};

package/features/model/createModel/CreateModelUseCase.js

@@ -0,0 +1,18 @@
+import { CreateModelRepository, CreateModelUseCase } from "./abstractions.js";
+class CreateModelUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(data) {
+        return this.repository.execute(data);
+    }
+}
+const CreateModelUseCase_CreateModelUseCase = CreateModelUseCase.createImplementation({
+    implementation: CreateModelUseCaseImpl,
+    dependencies: [
+        CreateModelRepository
+    ]
+});
+export { CreateModelUseCase_CreateModelUseCase as CreateModelUseCase };
+
+//# sourceMappingURL=CreateModelUseCase.js.map

package/features/model/createModel/CreateModelUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/createModel/CreateModelUseCase.js","sources":["../../../../src/features/model/createModel/CreateModelUseCase.ts"],"sourcesContent":["import { CreateModelUseCase as UseCaseAbstraction, CreateModelRepository } from \"./abstractions.js\";\nimport type { CreateModelParams } from \"./abstractions.js\";\n\nclass CreateModelUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: CreateModelRepository.Interface) {}\n\n    async execute(data: CreateModelParams) {\n        return this.repository.execute(data);\n    }\n}\n\nexport const CreateModelUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CreateModelUseCaseImpl,\n    dependencies: [CreateModelRepository]\n});\n"],"names":["CreateModelUseCaseImpl","repository","data","CreateModelUseCase","UseCaseAbstraction","CreateModelRepository"],"mappings":";AAGA,MAAMA;IACF,YAAoBC,UAA2C,CAAE;aAA7CA,UAAU,GAAVA;IAA8C;IAElE,MAAM,QAAQC,IAAuB,EAAE;QACnC,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBJ;IAChB,cAAc;QAACK;KAAsB;AACzC"}

package/features/model/createModel/abstractions.d.ts

@@ -0,0 +1,33 @@
+import type { CmsModel } from "../../../types.js";
+export interface CreateModelParams {
+    name: string;
+    singularApiName: string;
+    pluralApiName?: string;
+    group: string;
+    icon?: string;
+    description?: string;
+    defaultFields?: boolean;
+    tags?: string[];
+}
+export interface ICreateModelGateway {
+    execute(data: CreateModelParams): Promise<CmsModel>;
+}
+export declare const CreateModelGateway: import("@webiny/di").Abstraction<ICreateModelGateway>;
+export declare namespace CreateModelGateway {
+    type Interface = ICreateModelGateway;
+}
+export interface ICreateModelRepository {
+    execute(data: CreateModelParams): Promise<CmsModel>;
+}
+export declare const CreateModelRepository: import("@webiny/di").Abstraction<ICreateModelRepository>;
+export declare namespace CreateModelRepository {
+    type Interface = ICreateModelRepository;
+}
+export interface ICreateModelUseCase {
+    execute(data: CreateModelParams): Promise<CmsModel>;
+}
+export declare const CreateModelUseCase: import("@webiny/di").Abstraction<ICreateModelUseCase>;
+export declare namespace CreateModelUseCase {
+    type Interface = ICreateModelUseCase;
+    type Params = CreateModelParams;
+}

package/features/model/createModel/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const CreateModelGateway = createAbstraction("CreateModelGateway");
+const CreateModelRepository = createAbstraction("CreateModelRepository");
+const CreateModelUseCase = createAbstraction("CreateModelUseCase");
+export { CreateModelGateway, CreateModelRepository, CreateModelUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/model/createModel/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/createModel/abstractions.js","sources":["../../../../src/features/model/createModel/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { CmsModel } from \"~/types.js\";\n\nexport interface CreateModelParams {\n    name: string;\n    singularApiName: string;\n    pluralApiName?: string;\n    group: string;\n    icon?: string;\n    description?: string;\n    defaultFields?: boolean;\n    tags?: string[];\n}\n\nexport interface ICreateModelGateway {\n    execute(data: CreateModelParams): Promise<CmsModel>;\n}\n\nexport const CreateModelGateway = createAbstraction<ICreateModelGateway>(\"CreateModelGateway\");\n\nexport namespace CreateModelGateway {\n    export type Interface = ICreateModelGateway;\n}\n\nexport interface ICreateModelRepository {\n    execute(data: CreateModelParams): Promise<CmsModel>;\n}\n\nexport const CreateModelRepository =\n    createAbstraction<ICreateModelRepository>(\"CreateModelRepository\");\n\nexport namespace CreateModelRepository {\n    export type Interface = ICreateModelRepository;\n}\n\nexport interface ICreateModelUseCase {\n    execute(data: CreateModelParams): Promise<CmsModel>;\n}\n\nexport const CreateModelUseCase = createAbstraction<ICreateModelUseCase>(\"CreateModelUseCase\");\n\nexport namespace CreateModelUseCase {\n    export type Interface = ICreateModelUseCase;\n    export type Params = CreateModelParams;\n}\n"],"names":["CreateModelGateway","createAbstraction","CreateModelRepository","CreateModelUseCase"],"mappings":";AAkBO,MAAMA,qBAAqBC,kBAAuC;AAUlE,MAAMC,wBACTD,kBAA0C;AAUvC,MAAME,qBAAqBF,kBAAuC"}

package/features/model/createModel/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const CreateModelFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    useCase: import("./abstractions.js").ICreateModelUseCase;
+}, []>;

package/features/model/createModel/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { CreateModelUseCase } from "./abstractions.js";
+import { CreateModelUseCase as external_CreateModelUseCase_js_CreateModelUseCase } from "./CreateModelUseCase.js";
+import { CreateModelRepository } from "./CreateModelRepository.js";
+import { CreateModelGateway } from "./CreateModelGateway.js";
+const CreateModelFeature = createFeature({
+    name: "CmsModel/CreateModel",
+    register (container) {
+        container.register(external_CreateModelUseCase_js_CreateModelUseCase);
+        container.register(CreateModelRepository).inSingletonScope();
+        container.register(CreateModelGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(CreateModelUseCase)
+        };
+    }
+});
+export { CreateModelFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/model/createModel/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/createModel/feature.js","sources":["../../../../src/features/model/createModel/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { CreateModelUseCase as UseCase } from \"./abstractions.js\";\nimport { CreateModelUseCase } from \"./CreateModelUseCase.js\";\nimport { CreateModelRepository } from \"./CreateModelRepository.js\";\nimport { CreateModelGateway } from \"./CreateModelGateway.js\";\n\nexport const CreateModelFeature = createFeature({\n    name: \"CmsModel/CreateModel\",\n    register(container) {\n        container.register(CreateModelUseCase);\n        container.register(CreateModelRepository).inSingletonScope();\n        container.register(CreateModelGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["CreateModelFeature","createFeature","container","CreateModelUseCase","CreateModelRepository","CreateModelGateway","UseCase"],"mappings":";;;;;AAMO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,uBAAuB,gBAAgB;QAC1DF,UAAU,QAAQ,CAACG,oBAAoB,gBAAgB;IAC3D;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}

package/features/model/deleteModel/DeleteModelGateway.d.ts

@@ -0,0 +1,12 @@
+import { CmsGraphQLClient } from "../../../features/graphQLClient/abstractions.js";
+import type { DeleteModelResult } from "./abstractions.js";
+import { DeleteModelGateway as GatewayAbstraction } from "./abstractions.js";
+declare class DeleteModelGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: CmsGraphQLClient.Interface);
+    execute(modelId: string, confirmation: string): Promise<DeleteModelResult>;
+}
+export declare const DeleteModelGateway: typeof DeleteModelGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteModelGateway>;
+};
+export {};

package/features/model/deleteModel/DeleteModelGateway.js

@@ -0,0 +1,45 @@
+import { CmsGraphQLClient } from "../../graphQLClient/abstractions.js";
+import { DeleteModelGateway } from "./abstractions.js";
+const FULLY_DELETE_CONTENT_MODEL = `
+    mutation CmsFullyDeleteContentModel($modelId: ID!, $confirmation: String!) {
+        fullyDeleteModel(modelId: $modelId, confirmation: $confirmation) {
+            data {
+                id
+                status
+                deleted
+                total
+            }
+            error {
+                message
+                code
+                data
+            }
+        }
+    }
+`;
+class DeleteModelGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(modelId, confirmation) {
+        const response = await this.client.execute({
+            query: FULLY_DELETE_CONTENT_MODEL,
+            variables: {
+                modelId,
+                confirmation
+            }
+        });
+        const { data: result, error } = response.fullyDeleteModel;
+        if (!result) throw new Error(error?.message || "Could not delete content model");
+        return result;
+    }
+}
+const DeleteModelGateway_DeleteModelGateway = DeleteModelGateway.createImplementation({
+    implementation: DeleteModelGatewayImpl,
+    dependencies: [
+        CmsGraphQLClient
+    ]
+});
+export { DeleteModelGateway_DeleteModelGateway as DeleteModelGateway };
+
+//# sourceMappingURL=DeleteModelGateway.js.map

package/features/model/deleteModel/DeleteModelGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/deleteModel/DeleteModelGateway.js","sources":["../../../../src/features/model/deleteModel/DeleteModelGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsErrorResponse } from \"~/types.js\";\nimport type { DeleteModelResult } from \"./abstractions.js\";\nimport { DeleteModelGateway as GatewayAbstraction } from \"./abstractions.js\";\n\ninterface DeleteModelResponse {\n    fullyDeleteModel: {\n        data: DeleteModelResult | null;\n        error: CmsErrorResponse | null;\n    };\n}\n\ninterface DeleteModelVariables {\n    modelId: string;\n    confirmation: string;\n}\n\nconst FULLY_DELETE_CONTENT_MODEL = /* GraphQL */ `\n    mutation CmsFullyDeleteContentModel($modelId: ID!, $confirmation: String!) {\n        fullyDeleteModel(modelId: $modelId, confirmation: $confirmation) {\n            data {\n                id\n                status\n                deleted\n                total\n            }\n            error {\n                message\n                code\n                data\n            }\n        }\n    }\n`;\n\nclass DeleteModelGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: CmsGraphQLClient.Interface) {}\n\n    async execute(modelId: string, confirmation: string) {\n        const response = await this.client.execute<DeleteModelResponse, DeleteModelVariables>({\n            query: FULLY_DELETE_CONTENT_MODEL,\n            variables: { modelId, confirmation }\n        });\n\n        const { data: result, error } = response.fullyDeleteModel;\n\n        if (!result) {\n            throw new Error(error?.message || \"Could not delete content model\");\n        }\n\n        return result;\n    }\n}\n\nexport const DeleteModelGateway = GatewayAbstraction.createImplementation({\n    implementation: DeleteModelGatewayImpl,\n    dependencies: [CmsGraphQLClient]\n});\n"],"names":["FULLY_DELETE_CONTENT_MODEL","DeleteModelGatewayImpl","client","modelId","confirmation","response","result","error","Error","DeleteModelGateway","GatewayAbstraction","CmsGraphQLClient"],"mappings":";;AAiBA,MAAMA,6BAA2C,CAAC;;;;;;;;;;;;;;;;AAgBlD,CAAC;AAED,MAAMC;IACF,YAAoBC,MAAkC,CAAE;aAApCA,MAAM,GAANA;IAAqC;IAEzD,MAAM,QAAQC,OAAe,EAAEC,YAAoB,EAAE;QACjD,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAA4C;YAClF,OAAOL;YACP,WAAW;gBAAEG;gBAASC;YAAa;QACvC;QAEA,MAAM,EAAE,MAAME,MAAM,EAAEC,KAAK,EAAE,GAAGF,SAAS,gBAAgB;QAEzD,IAAI,CAACC,QACD,MAAM,IAAIE,MAAMD,OAAO,WAAW;QAGtC,OAAOD;IACX;AACJ;AAEO,MAAMG,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBT;IAChB,cAAc;QAACU;KAAiB;AACpC"}

package/features/model/deleteModel/DeleteModelRepository.d.ts

@@ -0,0 +1,12 @@
+import { DeleteModelRepository as RepositoryAbstraction, DeleteModelGateway } from "./abstractions.js";
+import { ModelsCache } from "../../../features/model/abstractions.js";
+declare class DeleteModelRepositoryImpl implements RepositoryAbstraction.Interface {
+    private cache;
+    private gateway;
+    constructor(cache: ModelsCache.Interface, gateway: DeleteModelGateway.Interface);
+    execute(modelId: string, confirmation: string): Promise<import("./abstractions.js").DeleteModelResult>;
+}
+export declare const DeleteModelRepository: typeof DeleteModelRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteModelRepository>;
+};
+export {};

package/features/model/deleteModel/DeleteModelRepository.js

@@ -0,0 +1,26 @@
+import { DeleteModelGateway, DeleteModelRepository } from "./abstractions.js";
+import { ModelsCache } from "../abstractions.js";
+class DeleteModelRepositoryImpl {
+    constructor(cache, gateway){
+        this.cache = cache;
+        this.gateway = gateway;
+    }
+    async execute(modelId, confirmation) {
+        const result = await this.gateway.execute(modelId, confirmation);
+        this.cache.updateItems((item)=>item.modelId === modelId ? {
+                ...item,
+                isBeingDeleted: true
+            } : item);
+        return result;
+    }
+}
+const DeleteModelRepository_DeleteModelRepository = DeleteModelRepository.createImplementation({
+    implementation: DeleteModelRepositoryImpl,
+    dependencies: [
+        ModelsCache,
+        DeleteModelGateway
+    ]
+});
+export { DeleteModelRepository_DeleteModelRepository as DeleteModelRepository };
+
+//# sourceMappingURL=DeleteModelRepository.js.map

package/features/model/deleteModel/DeleteModelRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/deleteModel/DeleteModelRepository.js","sources":["../../../../src/features/model/deleteModel/DeleteModelRepository.ts"],"sourcesContent":["import {\n    DeleteModelRepository as RepositoryAbstraction,\n    DeleteModelGateway\n} from \"./abstractions.js\";\nimport { ModelsCache } from \"~/features/model/abstractions.js\";\n\nclass DeleteModelRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private cache: ModelsCache.Interface,\n        private gateway: DeleteModelGateway.Interface\n    ) {}\n\n    async execute(modelId: string, confirmation: string) {\n        const result = await this.gateway.execute(modelId, confirmation);\n        this.cache.updateItems(item =>\n            item.modelId === modelId ? { ...item, isBeingDeleted: true } : item\n        );\n        return result;\n    }\n}\n\nexport const DeleteModelRepository = RepositoryAbstraction.createImplementation({\n    implementation: DeleteModelRepositoryImpl,\n    dependencies: [ModelsCache, DeleteModelGateway]\n});\n"],"names":["DeleteModelRepositoryImpl","cache","gateway","modelId","confirmation","result","item","DeleteModelRepository","RepositoryAbstraction","ModelsCache","DeleteModelGateway"],"mappings":";;AAMA,MAAMA;IACF,YACYC,KAA4B,EAC5BC,OAAqC,CAC/C;aAFUD,KAAK,GAALA;aACAC,OAAO,GAAPA;IACT;IAEH,MAAM,QAAQC,OAAe,EAAEC,YAAoB,EAAE;QACjD,MAAMC,SAAS,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAACF,SAASC;QACnD,IAAI,CAAC,KAAK,CAAC,WAAW,CAACE,CAAAA,OACnBA,KAAK,OAAO,KAAKH,UAAU;gBAAE,GAAGG,IAAI;gBAAE,gBAAgB;YAAK,IAAIA;QAEnE,OAAOD;IACX;AACJ;AAEO,MAAME,8CAAwBC,sBAAAA,oBAA0C,CAAC;IAC5E,gBAAgBR;IAChB,cAAc;QAACS;QAAaC;KAAmB;AACnD"}

package/features/model/deleteModel/DeleteModelUseCase.d.ts

@@ -0,0 +1,10 @@
+import { DeleteModelUseCase as UseCaseAbstraction, DeleteModelRepository } from "./abstractions.js";
+declare class DeleteModelUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: DeleteModelRepository.Interface);
+    execute(modelId: string, confirmation: string): Promise<import("./abstractions.js").DeleteModelResult>;
+}
+export declare const DeleteModelUseCase: typeof DeleteModelUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteModelUseCase>;
+};
+export {};

package/features/model/deleteModel/DeleteModelUseCase.js

@@ -0,0 +1,18 @@
+import { DeleteModelRepository, DeleteModelUseCase } from "./abstractions.js";
+class DeleteModelUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(modelId, confirmation) {
+        return this.repository.execute(modelId, confirmation);
+    }
+}
+const DeleteModelUseCase_DeleteModelUseCase = DeleteModelUseCase.createImplementation({
+    implementation: DeleteModelUseCaseImpl,
+    dependencies: [
+        DeleteModelRepository
+    ]
+});
+export { DeleteModelUseCase_DeleteModelUseCase as DeleteModelUseCase };
+
+//# sourceMappingURL=DeleteModelUseCase.js.map

package/features/model/deleteModel/DeleteModelUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/deleteModel/DeleteModelUseCase.js","sources":["../../../../src/features/model/deleteModel/DeleteModelUseCase.ts"],"sourcesContent":["import { DeleteModelUseCase as UseCaseAbstraction, DeleteModelRepository } from \"./abstractions.js\";\n\nclass DeleteModelUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: DeleteModelRepository.Interface) {}\n\n    async execute(modelId: string, confirmation: string) {\n        return this.repository.execute(modelId, confirmation);\n    }\n}\n\nexport const DeleteModelUseCase = UseCaseAbstraction.createImplementation({\n    implementation: DeleteModelUseCaseImpl,\n    dependencies: [DeleteModelRepository]\n});\n"],"names":["DeleteModelUseCaseImpl","repository","modelId","confirmation","DeleteModelUseCase","UseCaseAbstraction","DeleteModelRepository"],"mappings":";AAEA,MAAMA;IACF,YAAoBC,UAA2C,CAAE;aAA7CA,UAAU,GAAVA;IAA8C;IAElE,MAAM,QAAQC,OAAe,EAAEC,YAAoB,EAAE;QACjD,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACD,SAASC;IAC5C;AACJ;AAEO,MAAMC,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBL;IAChB,cAAc;QAACM;KAAsB;AACzC"}

package/features/model/deleteModel/abstractions.d.ts

@@ -0,0 +1,28 @@
+export interface DeleteModelResult {
+    id: string;
+    status: string;
+    deleted: number;
+    total: number;
+}
+export interface IDeleteModelGateway {
+    execute(modelId: string, confirmation: string): Promise<DeleteModelResult>;
+}
+export declare const DeleteModelGateway: import("@webiny/di").Abstraction<IDeleteModelGateway>;
+export declare namespace DeleteModelGateway {
+    type Interface = IDeleteModelGateway;
+}
+export interface IDeleteModelRepository {
+    execute(modelId: string, confirmation: string): Promise<DeleteModelResult>;
+}
+export declare const DeleteModelRepository: import("@webiny/di").Abstraction<IDeleteModelRepository>;
+export declare namespace DeleteModelRepository {
+    type Interface = IDeleteModelRepository;
+}
+export interface IDeleteModelUseCase {
+    execute(modelId: string, confirmation: string): Promise<DeleteModelResult>;
+}
+export declare const DeleteModelUseCase: import("@webiny/di").Abstraction<IDeleteModelUseCase>;
+export declare namespace DeleteModelUseCase {
+    type Interface = IDeleteModelUseCase;
+    type Result = DeleteModelResult;
+}

package/features/model/deleteModel/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const DeleteModelGateway = createAbstraction("DeleteModelGateway");
+const DeleteModelRepository = createAbstraction("DeleteModelRepository");
+const DeleteModelUseCase = createAbstraction("DeleteModelUseCase");
+export { DeleteModelGateway, DeleteModelRepository, DeleteModelUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/model/deleteModel/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/deleteModel/abstractions.js","sources":["../../../../src/features/model/deleteModel/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\n\nexport interface DeleteModelResult {\n    id: string;\n    status: string;\n    deleted: number;\n    total: number;\n}\n\nexport interface IDeleteModelGateway {\n    execute(modelId: string, confirmation: string): Promise<DeleteModelResult>;\n}\n\nexport const DeleteModelGateway = createAbstraction<IDeleteModelGateway>(\"DeleteModelGateway\");\n\nexport namespace DeleteModelGateway {\n    export type Interface = IDeleteModelGateway;\n}\n\nexport interface IDeleteModelRepository {\n    execute(modelId: string, confirmation: string): Promise<DeleteModelResult>;\n}\n\nexport const DeleteModelRepository =\n    createAbstraction<IDeleteModelRepository>(\"DeleteModelRepository\");\n\nexport namespace DeleteModelRepository {\n    export type Interface = IDeleteModelRepository;\n}\n\nexport interface IDeleteModelUseCase {\n    execute(modelId: string, confirmation: string): Promise<DeleteModelResult>;\n}\n\nexport const DeleteModelUseCase = createAbstraction<IDeleteModelUseCase>(\"DeleteModelUseCase\");\n\nexport namespace DeleteModelUseCase {\n    export type Interface = IDeleteModelUseCase;\n    export type Result = DeleteModelResult;\n}\n"],"names":["DeleteModelGateway","createAbstraction","DeleteModelRepository","DeleteModelUseCase"],"mappings":";AAaO,MAAMA,qBAAqBC,kBAAuC;AAUlE,MAAMC,wBACTD,kBAA0C;AAUvC,MAAME,qBAAqBF,kBAAuC"}

package/features/model/deleteModel/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const DeleteModelFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    useCase: import("./abstractions.js").IDeleteModelUseCase;
+}, []>;

package/features/model/deleteModel/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { DeleteModelUseCase } from "./abstractions.js";
+import { DeleteModelUseCase as external_DeleteModelUseCase_js_DeleteModelUseCase } from "./DeleteModelUseCase.js";
+import { DeleteModelRepository } from "./DeleteModelRepository.js";
+import { DeleteModelGateway } from "./DeleteModelGateway.js";
+const DeleteModelFeature = createFeature({
+    name: "CmsModel/DeleteModel",
+    register (container) {
+        container.register(external_DeleteModelUseCase_js_DeleteModelUseCase);
+        container.register(DeleteModelRepository).inSingletonScope();
+        container.register(DeleteModelGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(DeleteModelUseCase)
+        };
+    }
+});
+export { DeleteModelFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/model/deleteModel/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/deleteModel/feature.js","sources":["../../../../src/features/model/deleteModel/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { DeleteModelUseCase as UseCase } from \"./abstractions.js\";\nimport { DeleteModelUseCase } from \"./DeleteModelUseCase.js\";\nimport { DeleteModelRepository } from \"./DeleteModelRepository.js\";\nimport { DeleteModelGateway } from \"./DeleteModelGateway.js\";\n\nexport const DeleteModelFeature = createFeature({\n    name: \"CmsModel/DeleteModel\",\n    register(container) {\n        container.register(DeleteModelUseCase);\n        container.register(DeleteModelRepository).inSingletonScope();\n        container.register(DeleteModelGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["DeleteModelFeature","createFeature","container","DeleteModelUseCase","DeleteModelRepository","DeleteModelGateway","UseCase"],"mappings":";;;;;AAMO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,uBAAuB,gBAAgB;QAC1DF,UAAU,QAAQ,CAACG,oBAAoB,gBAAgB;IAC3D;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}

package/features/model/exportModels/ExportModelsGateway.d.ts

@@ -0,0 +1,11 @@
+import { CmsGraphQLClient } from "../../../features/graphQLClient/abstractions.js";
+import { ExportModelsGateway as GatewayAbstraction } from "./abstractions.js";
+declare class ExportModelsGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: CmsGraphQLClient.Interface);
+    execute(models?: string[]): Promise<any>;
+}
+export declare const ExportModelsGateway: typeof ExportModelsGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IExportModelsGateway>;
+};
+export {};

package/features/model/exportModels/ExportModelsGateway.js

@@ -0,0 +1,39 @@
+import { CmsGraphQLClient } from "../../graphQLClient/abstractions.js";
+import { ExportModelsGateway } from "./abstractions.js";
+const CMS_EXPORT_STRUCTURE_QUERY = `
+    query CmsExportStructure($models: [String!]) {
+        exportStructure(models: $models) {
+            data
+            error {
+                message
+                code
+                data
+            }
+        }
+    }
+`;
+class ExportModelsGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute(models) {
+        const response = await this.client.execute({
+            query: CMS_EXPORT_STRUCTURE_QUERY,
+            variables: {
+                models
+            }
+        });
+        const { data, error } = response.exportStructure;
+        if (error) throw new Error(error.message);
+        return data;
+    }
+}
+const ExportModelsGateway_ExportModelsGateway = ExportModelsGateway.createImplementation({
+    implementation: ExportModelsGatewayImpl,
+    dependencies: [
+        CmsGraphQLClient
+    ]
+});
+export { ExportModelsGateway_ExportModelsGateway as ExportModelsGateway };
+
+//# sourceMappingURL=ExportModelsGateway.js.map

package/features/model/exportModels/ExportModelsGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/exportModels/ExportModelsGateway.js","sources":["../../../../src/features/model/exportModels/ExportModelsGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsErrorResponse } from \"~/types.js\";\nimport { ExportModelsGateway as GatewayAbstraction } from \"./abstractions.js\";\n\ninterface ExportModelsResponse {\n    exportStructure: {\n        data: any;\n        error: CmsErrorResponse | null;\n    };\n}\n\ninterface ExportModelsVariables {\n    models?: string[];\n}\n\nconst CMS_EXPORT_STRUCTURE_QUERY = /* GraphQL */ `\n    query CmsExportStructure($models: [String!]) {\n        exportStructure(models: $models) {\n            data\n            error {\n                message\n                code\n                data\n            }\n        }\n    }\n`;\n\nclass ExportModelsGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: CmsGraphQLClient.Interface) {}\n\n    async execute(models?: string[]) {\n        const response = await this.client.execute<ExportModelsResponse, ExportModelsVariables>({\n            query: CMS_EXPORT_STRUCTURE_QUERY,\n            variables: { models }\n        });\n\n        const { data, error } = response.exportStructure;\n\n        if (error) {\n            throw new Error(error.message);\n        }\n\n        return data;\n    }\n}\n\nexport const ExportModelsGateway = GatewayAbstraction.createImplementation({\n    implementation: ExportModelsGatewayImpl,\n    dependencies: [CmsGraphQLClient]\n});\n"],"names":["CMS_EXPORT_STRUCTURE_QUERY","ExportModelsGatewayImpl","client","models","response","data","error","Error","ExportModelsGateway","GatewayAbstraction","CmsGraphQLClient"],"mappings":";;AAeA,MAAMA,6BAA2C,CAAC;;;;;;;;;;;AAWlD,CAAC;AAED,MAAMC;IACF,YAAoBC,MAAkC,CAAE;aAApCA,MAAM,GAANA;IAAqC;IAEzD,MAAM,QAAQC,MAAiB,EAAE;QAC7B,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAA8C;YACpF,OAAOJ;YACP,WAAW;gBAAEG;YAAO;QACxB;QAEA,MAAM,EAAEE,IAAI,EAAEC,KAAK,EAAE,GAAGF,SAAS,eAAe;QAEhD,IAAIE,OACA,MAAM,IAAIC,MAAMD,MAAM,OAAO;QAGjC,OAAOD;IACX;AACJ;AAEO,MAAMG,0CAAsBC,oBAAAA,oBAAuC,CAAC;IACvE,gBAAgBR;IAChB,cAAc;QAACS;KAAiB;AACpC"}

package/features/model/exportModels/ExportModelsUseCase.d.ts

@@ -0,0 +1,10 @@
+import { ExportModelsUseCase as UseCaseAbstraction, ExportModelsGateway } from "./abstractions.js";
+declare class ExportModelsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private gateway;
+    constructor(gateway: ExportModelsGateway.Interface);
+    execute(models?: string[]): Promise<any>;
+}
+export declare const ExportModelsUseCase: typeof ExportModelsUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IExportModelsUseCase>;
+};
+export {};

package/features/model/exportModels/ExportModelsUseCase.js

@@ -0,0 +1,18 @@
+import { ExportModelsGateway, ExportModelsUseCase } from "./abstractions.js";
+class ExportModelsUseCaseImpl {
+    constructor(gateway){
+        this.gateway = gateway;
+    }
+    async execute(models) {
+        return this.gateway.execute(models);
+    }
+}
+const ExportModelsUseCase_ExportModelsUseCase = ExportModelsUseCase.createImplementation({
+    implementation: ExportModelsUseCaseImpl,
+    dependencies: [
+        ExportModelsGateway
+    ]
+});
+export { ExportModelsUseCase_ExportModelsUseCase as ExportModelsUseCase };
+
+//# sourceMappingURL=ExportModelsUseCase.js.map

package/features/model/exportModels/ExportModelsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/exportModels/ExportModelsUseCase.js","sources":["../../../../src/features/model/exportModels/ExportModelsUseCase.ts"],"sourcesContent":["import { ExportModelsUseCase as UseCaseAbstraction, ExportModelsGateway } from \"./abstractions.js\";\n\nclass ExportModelsUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private gateway: ExportModelsGateway.Interface) {}\n\n    async execute(models?: string[]) {\n        return this.gateway.execute(models);\n    }\n}\n\nexport const ExportModelsUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ExportModelsUseCaseImpl,\n    dependencies: [ExportModelsGateway]\n});\n"],"names":["ExportModelsUseCaseImpl","gateway","models","ExportModelsUseCase","UseCaseAbstraction","ExportModelsGateway"],"mappings":";AAEA,MAAMA;IACF,YAAoBC,OAAsC,CAAE;aAAxCA,OAAO,GAAPA;IAAyC;IAE7D,MAAM,QAAQC,MAAiB,EAAE;QAC7B,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAACA;IAChC;AACJ;AAEO,MAAMC,0CAAsBC,oBAAAA,oBAAuC,CAAC;IACvE,gBAAgBJ;IAChB,cAAc;QAACK;KAAoB;AACvC"}

package/features/model/exportModels/abstractions.d.ts

@@ -0,0 +1,14 @@
+export interface IExportModelsGateway {
+    execute(models?: string[]): Promise<any>;
+}
+export declare const ExportModelsGateway: import("@webiny/di").Abstraction<IExportModelsGateway>;
+export declare namespace ExportModelsGateway {
+    type Interface = IExportModelsGateway;
+}
+export interface IExportModelsUseCase {
+    execute(models?: string[]): Promise<any>;
+}
+export declare const ExportModelsUseCase: import("@webiny/di").Abstraction<IExportModelsUseCase>;
+export declare namespace ExportModelsUseCase {
+    type Interface = IExportModelsUseCase;
+}

package/features/model/exportModels/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const ExportModelsGateway = createAbstraction("ExportModelsGateway");
+const ExportModelsUseCase = createAbstraction("ExportModelsUseCase");
+export { ExportModelsGateway, ExportModelsUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/model/exportModels/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/exportModels/abstractions.js","sources":["../../../../src/features/model/exportModels/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\n\nexport interface IExportModelsGateway {\n    execute(models?: string[]): Promise<any>;\n}\n\nexport const ExportModelsGateway = createAbstraction<IExportModelsGateway>(\"ExportModelsGateway\");\n\nexport namespace ExportModelsGateway {\n    export type Interface = IExportModelsGateway;\n}\n\nexport interface IExportModelsUseCase {\n    execute(models?: string[]): Promise<any>;\n}\n\nexport const ExportModelsUseCase = createAbstraction<IExportModelsUseCase>(\"ExportModelsUseCase\");\n\nexport namespace ExportModelsUseCase {\n    export type Interface = IExportModelsUseCase;\n}\n"],"names":["ExportModelsGateway","createAbstraction","ExportModelsUseCase"],"mappings":";AAMO,MAAMA,sBAAsBC,kBAAwC;AAUpE,MAAMC,sBAAsBD,kBAAwC"}

package/features/model/exportModels/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const ExportModelsFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    useCase: import("./abstractions.js").IExportModelsUseCase;
+}, []>;

package/features/model/exportModels/feature.js

@@ -0,0 +1,19 @@
+import { createFeature } from "@webiny/feature/admin";
+import { ExportModelsUseCase } from "./abstractions.js";
+import { ExportModelsUseCase as external_ExportModelsUseCase_js_ExportModelsUseCase } from "./ExportModelsUseCase.js";
+import { ExportModelsGateway } from "./ExportModelsGateway.js";
+const ExportModelsFeature = createFeature({
+    name: "CmsModel/ExportModels",
+    register (container) {
+        container.register(external_ExportModelsUseCase_js_ExportModelsUseCase);
+        container.register(ExportModelsGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(ExportModelsUseCase)
+        };
+    }
+});
+export { ExportModelsFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/model/exportModels/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/exportModels/feature.js","sources":["../../../../src/features/model/exportModels/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { ExportModelsUseCase as UseCase } from \"./abstractions.js\";\nimport { ExportModelsUseCase } from \"./ExportModelsUseCase.js\";\nimport { ExportModelsGateway } from \"./ExportModelsGateway.js\";\n\nexport const ExportModelsFeature = createFeature({\n    name: \"CmsModel/ExportModels\",\n    register(container) {\n        container.register(ExportModelsUseCase);\n        container.register(ExportModelsGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["ExportModelsFeature","createFeature","container","ExportModelsUseCase","ExportModelsGateway","UseCase"],"mappings":";;;;AAKO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,qBAAqB,gBAAgB;IAC5D;IACA,SAAQF,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACG;QAC/B;IACJ;AACJ"}

package/features/model/feature.d.ts

@@ -0,0 +1 @@
+export declare const ModelFeature: import("@webiny/feature/admin").FeatureDefinition<any, []>;

package/features/model/feature.js

@@ -0,0 +1,30 @@
+import { createFeature } from "@webiny/feature/admin";
+import { ListCache } from "@webiny/app-admin/features/listCache/index.js";
+import { ModelsCache } from "./abstractions.js";
+import { GetModelFeature } from "./getModel/feature.js";
+import { ListModelsFeature } from "./listModels/feature.js";
+import { CreateModelFeature } from "./createModel/feature.js";
+import { CloneModelFeature } from "./cloneModel/feature.js";
+import { UpdateModelFeature } from "./updateModel/feature.js";
+import { DeleteModelFeature } from "./deleteModel/feature.js";
+import { CancelDeleteModelFeature } from "./cancelDeleteModel/feature.js";
+import { ExportModelsFeature } from "./exportModels/feature.js";
+import { ImportModelsFeature } from "./importModels/feature.js";
+const ModelFeature = createFeature({
+    name: "CmsModel",
+    register (container) {
+        container.registerInstance(ModelsCache, new ListCache("modelId"));
+        GetModelFeature.register(container);
+        ListModelsFeature.register(container);
+        CreateModelFeature.register(container);
+        CloneModelFeature.register(container);
+        UpdateModelFeature.register(container);
+        DeleteModelFeature.register(container);
+        CancelDeleteModelFeature.register(container);
+        ExportModelsFeature.register(container);
+        ImportModelsFeature.register(container);
+    }
+});
+export { ModelFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/model/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/feature.js","sources":["../../../src/features/model/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { ListCache } from \"@webiny/app-admin/features/listCache/index.js\";\nimport { ModelsCache } from \"./abstractions.js\";\nimport type { CmsModel } from \"~/types.js\";\nimport { GetModelFeature } from \"./getModel/feature.js\";\nimport { ListModelsFeature } from \"./listModels/feature.js\";\nimport { CreateModelFeature } from \"./createModel/feature.js\";\nimport { CloneModelFeature } from \"./cloneModel/feature.js\";\nimport { UpdateModelFeature } from \"./updateModel/feature.js\";\nimport { DeleteModelFeature } from \"./deleteModel/feature.js\";\nimport { CancelDeleteModelFeature } from \"./cancelDeleteModel/feature.js\";\nimport { ExportModelsFeature } from \"./exportModels/feature.js\";\nimport { ImportModelsFeature } from \"./importModels/feature.js\";\n\nexport const ModelFeature = createFeature({\n    name: \"CmsModel\",\n    register(container) {\n        container.registerInstance(ModelsCache, new ListCache<CmsModel>(\"modelId\"));\n\n        GetModelFeature.register(container);\n        ListModelsFeature.register(container);\n        CreateModelFeature.register(container);\n        CloneModelFeature.register(container);\n        UpdateModelFeature.register(container);\n        DeleteModelFeature.register(container);\n        CancelDeleteModelFeature.register(container);\n        ExportModelsFeature.register(container);\n        ImportModelsFeature.register(container);\n    }\n});\n"],"names":["ModelFeature","createFeature","container","ModelsCache","ListCache","GetModelFeature","ListModelsFeature","CreateModelFeature","CloneModelFeature","UpdateModelFeature","DeleteModelFeature","CancelDeleteModelFeature","ExportModelsFeature","ImportModelsFeature"],"mappings":";;;;;;;;;;;;AAcO,MAAMA,eAAeC,cAAc;IACtC,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,gBAAgB,CAACC,aAAa,IAAIC,UAAoB;QAEhEC,gBAAgB,QAAQ,CAACH;QACzBI,kBAAkB,QAAQ,CAACJ;QAC3BK,mBAAmB,QAAQ,CAACL;QAC5BM,kBAAkB,QAAQ,CAACN;QAC3BO,mBAAmB,QAAQ,CAACP;QAC5BQ,mBAAmB,QAAQ,CAACR;QAC5BS,yBAAyB,QAAQ,CAACT;QAClCU,oBAAoB,QAAQ,CAACV;QAC7BW,oBAAoB,QAAQ,CAACX;IACjC;AACJ"}

package/features/model/getModel/GetModelGateway.d.ts

@@ -0,0 +1,12 @@
+import { CmsGraphQLClient } from "../../../features/graphQLClient/abstractions.js";
+import type { CmsModel } from "../../../types.js";
+import { GetModelGateway as GatewayAbstraction, type IGetModelParams } from "./abstractions.js";
+declare class GetModelGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: CmsGraphQLClient.Interface);
+    execute({ modelId }: IGetModelParams): Promise<CmsModel>;
+}
+export declare const GetModelGateway: typeof GetModelGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetModelGateway>;
+};
+export {};

package/features/model/getModel/GetModelGateway.js

@@ -0,0 +1,28 @@
+import { CmsGraphQLClient } from "../../graphQLClient/abstractions.js";
+import { GET_CONTENT_MODEL } from "../../../admin/graphql/contentModels.js";
+import { GetModelGateway } from "./abstractions.js";
+class GetModelGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute({ modelId }) {
+        const response = await this.client.execute({
+            query: GET_CONTENT_MODEL,
+            variables: {
+                modelId
+            }
+        });
+        const { data, error } = response.getContentModel;
+        if (!data) throw new Error(error?.message || `Could not fetch model "${modelId}"`);
+        return data;
+    }
+}
+const GetModelGateway_GetModelGateway = GetModelGateway.createImplementation({
+    implementation: GetModelGatewayImpl,
+    dependencies: [
+        CmsGraphQLClient
+    ]
+});
+export { GetModelGateway_GetModelGateway as GetModelGateway };
+
+//# sourceMappingURL=GetModelGateway.js.map

package/features/model/getModel/GetModelGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/model/getModel/GetModelGateway.js","sources":["../../../../src/features/model/getModel/GetModelGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsModel, CmsErrorResponse } from \"~/types.js\";\nimport { GET_CONTENT_MODEL } from \"~/admin/graphql/contentModels.js\";\nimport { GetModelGateway as GatewayAbstraction, type IGetModelParams } from \"./abstractions.js\";\n\ninterface GetModelResponse {\n    getContentModel: {\n        data: CmsModel | null;\n        error: CmsErrorResponse | null;\n    };\n}\n\nclass GetModelGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: CmsGraphQLClient.Interface) {}\n\n    async execute({ modelId }: IGetModelParams) {\n        const response = await this.client.execute<GetModelResponse>({\n            query: GET_CONTENT_MODEL,\n            variables: { modelId }\n        });\n\n        const { data, error } = response.getContentModel;\n\n        if (!data) {\n            throw new Error(error?.message || `Could not fetch model \"${modelId}\"`);\n        }\n\n        return data;\n    }\n}\n\nexport const GetModelGateway = GatewayAbstraction.createImplementation({\n    implementation: GetModelGatewayImpl,\n    dependencies: [CmsGraphQLClient]\n});\n"],"names":["GetModelGatewayImpl","client","modelId","response","GET_CONTENT_MODEL","data","error","Error","GetModelGateway","GatewayAbstraction","CmsGraphQLClient"],"mappings":";;;AAYA,MAAMA;IACF,YAAoBC,MAAkC,CAAE;aAApCA,MAAM,GAANA;IAAqC;IAEzD,MAAM,QAAQ,EAAEC,OAAO,EAAmB,EAAE;QACxC,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAmB;YACzD,OAAOC;YACP,WAAW;gBAAEF;YAAQ;QACzB;QAEA,MAAM,EAAEG,IAAI,EAAEC,KAAK,EAAE,GAAGH,SAAS,eAAe;QAEhD,IAAI,CAACE,MACD,MAAM,IAAIE,MAAMD,OAAO,WAAW,CAAC,uBAAuB,EAAEJ,QAAQ,CAAC,CAAC;QAG1E,OAAOG;IACX;AACJ;AAEO,MAAMG,kCAAkBC,gBAAAA,oBAAuC,CAAC;IACnE,gBAAgBT;IAChB,cAAc;QAACU;KAAiB;AACpC"}

package/features/model/getModel/GetModelRepository.d.ts

@@ -0,0 +1,14 @@
+import { GetModelRepository as RepositoryAbstraction, GetModelGateway } from "./abstractions.js";
+import { ModelsCache } from "../../../features/model/abstractions.js";
+import type { IGetModelParams } from "./abstractions.js";
+import type { CmsModel } from "../../../types.js";
+declare class GetModelRepositoryImpl implements RepositoryAbstraction.Interface {
+    private cache;
+    private gateway;
+    constructor(cache: ModelsCache.Interface, gateway: GetModelGateway.Interface);
+    execute(params: IGetModelParams): Promise<CmsModel>;
+}
+export declare const GetModelRepository: typeof GetModelRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetModelRepository>;
+};
+export {};