@webiny/tenant-manager 0.0.0-unstable.0d717d18dd

package/admin/DisableTenant/feature.d.ts

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

package/admin/DisableTenant/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { DisableTenantUseCase } from "./abstractions.js";
+import { DisableTenantUseCase as external_DisableTenantUseCase_js_DisableTenantUseCase } from "./DisableTenantUseCase.js";
+import { DisableTenantRepository } from "./DisableTenantRepository.js";
+import { DisableTenantGateway } from "./DisableTenantGateway.js";
+const DisableTenantFeature = createFeature({
+    name: "DisableTenant",
+    register (container) {
+        container.register(external_DisableTenantUseCase_js_DisableTenantUseCase);
+        container.register(DisableTenantRepository).inSingletonScope();
+        container.register(DisableTenantGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(DisableTenantUseCase)
+        };
+    }
+});
+export { DisableTenantFeature };
+
+//# sourceMappingURL=feature.js.map

package/admin/DisableTenant/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/DisableTenant/feature.js","sources":["../../../src/admin/DisableTenant/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { DisableTenantUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { DisableTenantUseCase } from \"./DisableTenantUseCase.js\";\nimport { DisableTenantRepository } from \"./DisableTenantRepository.js\";\nimport { DisableTenantGateway } from \"./DisableTenantGateway.js\";\n\nexport const DisableTenantFeature = createFeature({\n    name: \"DisableTenant\",\n    register(container) {\n        container.register(DisableTenantUseCase);\n        container.register(DisableTenantRepository).inSingletonScope();\n        container.register(DisableTenantGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCaseAbstraction)\n        };\n    }\n});\n"],"names":["DisableTenantFeature","createFeature","container","DisableTenantUseCase","DisableTenantRepository","DisableTenantGateway","UseCaseAbstraction"],"mappings":";;;;;AAMO,MAAMA,uBAAuBC,cAAc;IAC9C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,yBAAyB,gBAAgB;QAC5DF,UAAU,QAAQ,CAACG,sBAAsB,gBAAgB;IAC7D;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}

package/admin/DisableTenant/index.d.ts

@@ -0,0 +1,2 @@
+export { DisableTenantFeature } from "./feature.js";
+export { useDisableTenant } from "./useDisableTenant.js";

package/admin/DisableTenant/index.js

@@ -0,0 +1,2 @@
+export { DisableTenantFeature } from "./feature.js";
+export { useDisableTenant } from "./useDisableTenant.js";

package/admin/DisableTenant/useDisableTenant.d.ts

@@ -0,0 +1,4 @@
+import type { TenantEntry } from "../../admin/types.js";
+export declare const useDisableTenant: (tenant: TenantEntry) => {
+    disableTenant: () => Promise<void>;
+};

package/admin/DisableTenant/useDisableTenant.js

@@ -0,0 +1,18 @@
+import { useCallback } from "react";
+import { useFeature } from "@webiny/app-admin";
+import { DisableTenantFeature } from "./feature.js";
+const useDisableTenant = (tenant)=>{
+    const { useCase } = useFeature(DisableTenantFeature);
+    const disableTenant = useCallback(async ()=>{
+        await useCase.execute(tenant.entryId);
+    }, [
+        useCase,
+        tenant
+    ]);
+    return {
+        disableTenant
+    };
+};
+export { useDisableTenant };
+
+//# sourceMappingURL=useDisableTenant.js.map

package/admin/DisableTenant/useDisableTenant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/DisableTenant/useDisableTenant.js","sources":["../../../src/admin/DisableTenant/useDisableTenant.ts"],"sourcesContent":["import { useCallback } from \"react\";\nimport { useFeature } from \"@webiny/app-admin\";\nimport { DisableTenantFeature } from \"./feature.js\";\nimport type { TenantEntry } from \"~/admin/types.js\";\n\nexport const useDisableTenant = (tenant: TenantEntry) => {\n    const { useCase } = useFeature(DisableTenantFeature);\n\n    const disableTenant = useCallback(async () => {\n        await useCase.execute(tenant.entryId);\n    }, [useCase, tenant]);\n\n    return { disableTenant };\n};\n"],"names":["useDisableTenant","tenant","useCase","useFeature","DisableTenantFeature","disableTenant","useCallback"],"mappings":";;;AAKO,MAAMA,mBAAmB,CAACC;IAC7B,MAAM,EAAEC,OAAO,EAAE,GAAGC,WAAWC;IAE/B,MAAMC,gBAAgBC,YAAY;QAC9B,MAAMJ,QAAQ,OAAO,CAACD,OAAO,OAAO;IACxC,GAAG;QAACC;QAASD;KAAO;IAEpB,OAAO;QAAEI;IAAc;AAC3B"}

package/admin/EnableTenant/EnableTenantGateway.d.ts

@@ -0,0 +1,11 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/index.js";
+import { EnableTenantGateway as GatewayAbstraction } from "./abstractions.js";
+declare class EnableTenantGraphQLGateway implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: MainGraphQLClient.Interface);
+    enableTenant(tenantId: string): Promise<boolean>;
+}
+export declare const EnableTenantGateway: typeof EnableTenantGraphQLGateway & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IEnableTenantGateway>;
+};
+export {};

package/admin/EnableTenant/EnableTenantGateway.js

@@ -0,0 +1,42 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/index.js";
+import { EnableTenantGateway } from "./abstractions.js";
+const ENABLE_TENANT = `
+    mutation EnableTenant($tenantId: ID!) {
+        tenantManager {
+            enableTenant(tenantId: $tenantId) {
+                data
+                error {
+                    code
+                    message
+                    data
+                }
+            }
+        }
+    }
+`;
+class EnableTenantGraphQLGateway {
+    constructor(client){
+        this.client = client;
+    }
+    async enableTenant(tenantId) {
+        const response = await this.client.execute({
+            query: ENABLE_TENANT,
+            variables: {
+                tenantId
+            }
+        });
+        const envelope = response.tenantManager.enableTenant;
+        if (envelope.error) throw new Error(envelope.error.message);
+        if (!envelope.data) throw new Error("Unable to enable tenant");
+        return envelope.data;
+    }
+}
+const EnableTenantGateway_EnableTenantGateway = EnableTenantGateway.createImplementation({
+    implementation: EnableTenantGraphQLGateway,
+    dependencies: [
+        MainGraphQLClient
+    ]
+});
+export { EnableTenantGateway_EnableTenantGateway as EnableTenantGateway };
+
+//# sourceMappingURL=EnableTenantGateway.js.map

package/admin/EnableTenant/EnableTenantGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/EnableTenant/EnableTenantGateway.js","sources":["../../../src/admin/EnableTenant/EnableTenantGateway.ts"],"sourcesContent":["import { MainGraphQLClient } from \"@webiny/app/features/mainGraphQLClient/index.js\";\nimport { EnableTenantGateway as GatewayAbstraction } from \"./abstractions.js\";\n\nconst ENABLE_TENANT = /* GraphQL */ `\n    mutation EnableTenant($tenantId: ID!) {\n        tenantManager {\n            enableTenant(tenantId: $tenantId) {\n                data\n                error {\n                    code\n                    message\n                    data\n                }\n            }\n        }\n    }\n`;\n\ntype EnableTenantResponse = {\n    tenantManager: {\n        enableTenant:\n            | {\n                  data: boolean;\n                  error: null;\n              }\n            | {\n                  data: null;\n                  error: {\n                      code: string;\n                      message: string;\n                      data: Record<string, any>;\n                  };\n              };\n    };\n};\n\nclass EnableTenantGraphQLGateway implements GatewayAbstraction.Interface {\n    constructor(private client: MainGraphQLClient.Interface) {}\n\n    async enableTenant(tenantId: string): Promise<boolean> {\n        const response = await this.client.execute<EnableTenantResponse>({\n            query: ENABLE_TENANT,\n            variables: { tenantId }\n        });\n\n        const envelope = response.tenantManager.enableTenant;\n        if (envelope.error) {\n            throw new Error(envelope.error.message);\n        }\n\n        if (!envelope.data) {\n            throw new Error(\"Unable to enable tenant\");\n        }\n\n        return envelope.data;\n    }\n}\n\nexport const EnableTenantGateway = GatewayAbstraction.createImplementation({\n    implementation: EnableTenantGraphQLGateway,\n    dependencies: [MainGraphQLClient]\n});\n"],"names":["ENABLE_TENANT","EnableTenantGraphQLGateway","client","tenantId","response","envelope","Error","EnableTenantGateway","GatewayAbstraction","MainGraphQLClient"],"mappings":";;AAGA,MAAMA,gBAA8B,CAAC;;;;;;;;;;;;;AAarC,CAAC;AAoBD,MAAMC;IACF,YAAoBC,MAAmC,CAAE;aAArCA,MAAM,GAANA;IAAsC;IAE1D,MAAM,aAAaC,QAAgB,EAAoB;QACnD,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAuB;YAC7D,OAAOJ;YACP,WAAW;gBAAEG;YAAS;QAC1B;QAEA,MAAME,WAAWD,SAAS,aAAa,CAAC,YAAY;QACpD,IAAIC,SAAS,KAAK,EACd,MAAM,IAAIC,MAAMD,SAAS,KAAK,CAAC,OAAO;QAG1C,IAAI,CAACA,SAAS,IAAI,EACd,MAAM,IAAIC,MAAM;QAGpB,OAAOD,SAAS,IAAI;IACxB;AACJ;AAEO,MAAME,0CAAsBC,oBAAAA,oBAAuC,CAAC;IACvE,gBAAgBP;IAChB,cAAc;QAACQ;KAAkB;AACrC"}

package/admin/EnableTenant/EnableTenantRepository.d.ts

@@ -0,0 +1,12 @@
+import { EnableTenantRepository as RepositoryAbstraction, EnableTenantGateway } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "@webiny/app-headless-cms/features/contentEntry/abstractions.js";
+declare class EnableTenantRepositoryImpl implements RepositoryAbstraction.Interface {
+    private gateway;
+    private cacheProvider;
+    constructor(gateway: EnableTenantGateway.Interface, cacheProvider: ContentEntriesCacheProvider.Interface);
+    execute(tenantId: string): Promise<void>;
+}
+export declare const EnableTenantRepository: typeof EnableTenantRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IEnableTenantRepository>;
+};
+export {};

package/admin/EnableTenant/EnableTenantRepository.js

@@ -0,0 +1,33 @@
+import { EnableTenantGateway, EnableTenantRepository } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "@webiny/app-headless-cms/features/contentEntry/abstractions.js";
+import { TENANT_MODEL_ID } from "../../shared/constants.js";
+class EnableTenantRepositoryImpl {
+    constructor(gateway, cacheProvider){
+        this.gateway = gateway;
+        this.cacheProvider = cacheProvider;
+    }
+    async execute(tenantId) {
+        await this.gateway.enableTenant(tenantId);
+        const cache = this.cacheProvider.get(TENANT_MODEL_ID);
+        cache.updateItems((item)=>{
+            if (item.entryId === tenantId) return {
+                ...item,
+                values: {
+                    ...item.values,
+                    status: "enabled"
+                }
+            };
+            return item;
+        });
+    }
+}
+const EnableTenantRepository_EnableTenantRepository = EnableTenantRepository.createImplementation({
+    implementation: EnableTenantRepositoryImpl,
+    dependencies: [
+        EnableTenantGateway,
+        ContentEntriesCacheProvider
+    ]
+});
+export { EnableTenantRepository_EnableTenantRepository as EnableTenantRepository };
+
+//# sourceMappingURL=EnableTenantRepository.js.map

package/admin/EnableTenant/EnableTenantRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/EnableTenant/EnableTenantRepository.js","sources":["../../../src/admin/EnableTenant/EnableTenantRepository.ts"],"sourcesContent":["import {\n    EnableTenantRepository as RepositoryAbstraction,\n    EnableTenantGateway\n} from \"./abstractions.js\";\nimport { ContentEntriesCacheProvider } from \"@webiny/app-headless-cms/features/contentEntry/abstractions.js\";\nimport { TENANT_MODEL_ID } from \"~/shared/constants.js\";\n\nclass EnableTenantRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private gateway: EnableTenantGateway.Interface,\n        private cacheProvider: ContentEntriesCacheProvider.Interface\n    ) {}\n\n    async execute(tenantId: string): Promise<void> {\n        await this.gateway.enableTenant(tenantId);\n\n        const cache = this.cacheProvider.get(TENANT_MODEL_ID);\n        cache.updateItems(item => {\n            if (item.entryId === tenantId) {\n                return { ...item, values: { ...item.values, status: \"enabled\" } };\n            }\n            return item;\n        });\n    }\n}\n\nexport const EnableTenantRepository = RepositoryAbstraction.createImplementation({\n    implementation: EnableTenantRepositoryImpl,\n    dependencies: [EnableTenantGateway, ContentEntriesCacheProvider]\n});\n"],"names":["EnableTenantRepositoryImpl","gateway","cacheProvider","tenantId","cache","TENANT_MODEL_ID","item","EnableTenantRepository","RepositoryAbstraction","EnableTenantGateway","ContentEntriesCacheProvider"],"mappings":";;;AAOA,MAAMA;IACF,YACYC,OAAsC,EACtCC,aAAoD,CAC9D;aAFUD,OAAO,GAAPA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,QAAQC,QAAgB,EAAiB;QAC3C,MAAM,IAAI,CAAC,OAAO,CAAC,YAAY,CAACA;QAEhC,MAAMC,QAAQ,IAAI,CAAC,aAAa,CAAC,GAAG,CAACC;QACrCD,MAAM,WAAW,CAACE,CAAAA;YACd,IAAIA,KAAK,OAAO,KAAKH,UACjB,OAAO;gBAAE,GAAGG,IAAI;gBAAE,QAAQ;oBAAE,GAAGA,KAAK,MAAM;oBAAE,QAAQ;gBAAU;YAAE;YAEpE,OAAOA;QACX;IACJ;AACJ;AAEO,MAAMC,gDAAyBC,uBAAAA,oBAA0C,CAAC;IAC7E,gBAAgBR;IAChB,cAAc;QAACS;QAAqBC;KAA4B;AACpE"}

package/admin/EnableTenant/EnableTenantUseCase.d.ts

@@ -0,0 +1,10 @@
+import { EnableTenantUseCase as UseCaseAbstraction, EnableTenantRepository } from "./abstractions.js";
+declare class EnableTenantUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: EnableTenantRepository.Interface);
+    execute(tenantId: string): Promise<void>;
+}
+export declare const EnableTenantUseCase: typeof EnableTenantUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IEnableTenantUseCase>;
+};
+export {};

package/admin/EnableTenant/EnableTenantUseCase.js

@@ -0,0 +1,18 @@
+import { EnableTenantRepository, EnableTenantUseCase } from "./abstractions.js";
+class EnableTenantUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(tenantId) {
+        return this.repository.execute(tenantId);
+    }
+}
+const EnableTenantUseCase_EnableTenantUseCase = EnableTenantUseCase.createImplementation({
+    implementation: EnableTenantUseCaseImpl,
+    dependencies: [
+        EnableTenantRepository
+    ]
+});
+export { EnableTenantUseCase_EnableTenantUseCase as EnableTenantUseCase };
+
+//# sourceMappingURL=EnableTenantUseCase.js.map

package/admin/EnableTenant/EnableTenantUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/EnableTenant/EnableTenantUseCase.js","sources":["../../../src/admin/EnableTenant/EnableTenantUseCase.ts"],"sourcesContent":["import {\n    EnableTenantUseCase as UseCaseAbstraction,\n    EnableTenantRepository\n} from \"./abstractions.js\";\n\nclass EnableTenantUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: EnableTenantRepository.Interface) {}\n\n    async execute(tenantId: string): Promise<void> {\n        return this.repository.execute(tenantId);\n    }\n}\n\nexport const EnableTenantUseCase = UseCaseAbstraction.createImplementation({\n    implementation: EnableTenantUseCaseImpl,\n    dependencies: [EnableTenantRepository]\n});\n"],"names":["EnableTenantUseCaseImpl","repository","tenantId","EnableTenantUseCase","UseCaseAbstraction","EnableTenantRepository"],"mappings":";AAKA,MAAMA;IACF,YAAoBC,UAA4C,CAAE;aAA9CA,UAAU,GAAVA;IAA+C;IAEnE,MAAM,QAAQC,QAAgB,EAAiB;QAC3C,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,0CAAsBC,oBAAAA,oBAAuC,CAAC;IACvE,gBAAgBJ;IAChB,cAAc;QAACK;KAAuB;AAC1C"}

package/admin/EnableTenant/abstractions.d.ts

@@ -0,0 +1,21 @@
+export interface IEnableTenantUseCase {
+    execute(tenantId: string): Promise<void>;
+}
+export declare const EnableTenantUseCase: import("@webiny/di").Abstraction<IEnableTenantUseCase>;
+export declare namespace EnableTenantUseCase {
+    type Interface = IEnableTenantUseCase;
+}
+export interface IEnableTenantRepository {
+    execute(tenantId: string): Promise<void>;
+}
+export declare const EnableTenantRepository: import("@webiny/di").Abstraction<IEnableTenantRepository>;
+export declare namespace EnableTenantRepository {
+    type Interface = IEnableTenantRepository;
+}
+export interface IEnableTenantGateway {
+    enableTenant(tenantId: string): Promise<boolean>;
+}
+export declare const EnableTenantGateway: import("@webiny/di").Abstraction<IEnableTenantGateway>;
+export declare namespace EnableTenantGateway {
+    type Interface = IEnableTenantGateway;
+}

package/admin/EnableTenant/abstractions.js

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

package/admin/EnableTenant/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/EnableTenant/abstractions.js","sources":["../../../src/admin/EnableTenant/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\n\n// UseCase abstraction - only execute method\nexport interface IEnableTenantUseCase {\n    execute(tenantId: string): Promise<void>;\n}\n\nexport const EnableTenantUseCase = createAbstraction<IEnableTenantUseCase>(\"EnableTenantUseCase\");\n\nexport namespace EnableTenantUseCase {\n    export type Interface = IEnableTenantUseCase;\n}\n\n// Repository abstraction - delegates to gateway\nexport interface IEnableTenantRepository {\n    execute(tenantId: string): Promise<void>;\n}\n\nexport const EnableTenantRepository =\n    createAbstraction<IEnableTenantRepository>(\"EnableTenantRepository\");\n\nexport namespace EnableTenantRepository {\n    export type Interface = IEnableTenantRepository;\n}\n\n// Gateway abstraction - GraphQL call\nexport interface IEnableTenantGateway {\n    enableTenant(tenantId: string): Promise<boolean>;\n}\n\nexport const EnableTenantGateway = createAbstraction<IEnableTenantGateway>(\"EnableTenantGateway\");\n\nexport namespace EnableTenantGateway {\n    export type Interface = IEnableTenantGateway;\n}\n"],"names":["EnableTenantUseCase","createAbstraction","EnableTenantRepository","EnableTenantGateway"],"mappings":";AAOO,MAAMA,sBAAsBC,kBAAwC;AAWpE,MAAMC,yBACTD,kBAA2C;AAWxC,MAAME,sBAAsBF,kBAAwC"}

package/admin/EnableTenant/feature.d.ts

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

package/admin/EnableTenant/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { EnableTenantUseCase } from "./abstractions.js";
+import { EnableTenantUseCase as external_EnableTenantUseCase_js_EnableTenantUseCase } from "./EnableTenantUseCase.js";
+import { EnableTenantRepository } from "./EnableTenantRepository.js";
+import { EnableTenantGateway } from "./EnableTenantGateway.js";
+const EnableTenantFeature = createFeature({
+    name: "EnableTenant",
+    register (container) {
+        container.register(external_EnableTenantUseCase_js_EnableTenantUseCase);
+        container.register(EnableTenantRepository).inSingletonScope();
+        container.register(EnableTenantGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(EnableTenantUseCase)
+        };
+    }
+});
+export { EnableTenantFeature };
+
+//# sourceMappingURL=feature.js.map

package/admin/EnableTenant/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/EnableTenant/feature.js","sources":["../../../src/admin/EnableTenant/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { EnableTenantUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { EnableTenantUseCase } from \"./EnableTenantUseCase.js\";\nimport { EnableTenantRepository } from \"./EnableTenantRepository.js\";\nimport { EnableTenantGateway } from \"./EnableTenantGateway.js\";\n\nexport const EnableTenantFeature = createFeature({\n    name: \"EnableTenant\",\n    register(container) {\n        container.register(EnableTenantUseCase);\n        container.register(EnableTenantRepository).inSingletonScope();\n        container.register(EnableTenantGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCaseAbstraction)\n        };\n    }\n});\n"],"names":["EnableTenantFeature","createFeature","container","EnableTenantUseCase","EnableTenantRepository","EnableTenantGateway","UseCaseAbstraction"],"mappings":";;;;;AAMO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,wBAAwB,gBAAgB;QAC3DF,UAAU,QAAQ,CAACG,qBAAqB,gBAAgB;IAC5D;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}

package/admin/EnableTenant/index.d.ts

@@ -0,0 +1,2 @@
+export { EnableTenantFeature } from "./feature.js";
+export { useEnableTenant } from "./useEnableTenant.js";

package/admin/EnableTenant/index.js

@@ -0,0 +1,2 @@
+export { EnableTenantFeature } from "./feature.js";
+export { useEnableTenant } from "./useEnableTenant.js";

package/admin/EnableTenant/useEnableTenant.d.ts

@@ -0,0 +1,4 @@
+export declare const useEnableTenant: () => {
+    enableTenant: (tenantId: string) => Promise<void>;
+    loading: boolean;
+};

package/admin/EnableTenant/useEnableTenant.js

@@ -0,0 +1,24 @@
+import { useCallback, useState } from "react";
+import { useFeature } from "@webiny/app-admin";
+import { EnableTenantFeature } from "./feature.js";
+const useEnableTenant = ()=>{
+    const { useCase } = useFeature(EnableTenantFeature);
+    const [loading, setLoading] = useState(false);
+    const enableTenant = useCallback(async (tenantId)=>{
+        setLoading(true);
+        try {
+            await useCase.execute(tenantId);
+        } finally{
+            setLoading(false);
+        }
+    }, [
+        useCase
+    ]);
+    return {
+        enableTenant,
+        loading
+    };
+};
+export { useEnableTenant };
+
+//# sourceMappingURL=useEnableTenant.js.map

package/admin/EnableTenant/useEnableTenant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/EnableTenant/useEnableTenant.js","sources":["../../../src/admin/EnableTenant/useEnableTenant.ts"],"sourcesContent":["import { useState, useCallback } from \"react\";\nimport { useFeature } from \"@webiny/app-admin\";\nimport { EnableTenantFeature } from \"./feature.js\";\n\nexport const useEnableTenant = () => {\n    const { useCase } = useFeature(EnableTenantFeature);\n    const [loading, setLoading] = useState(false);\n\n    const enableTenant = useCallback(\n        async (tenantId: string) => {\n            setLoading(true);\n\n            try {\n                await useCase.execute(tenantId);\n            } finally {\n                setLoading(false);\n            }\n        },\n        [useCase]\n    );\n\n    return { enableTenant, loading };\n};\n"],"names":["useEnableTenant","useCase","useFeature","EnableTenantFeature","loading","setLoading","useState","enableTenant","useCallback","tenantId"],"mappings":";;;AAIO,MAAMA,kBAAkB;IAC3B,MAAM,EAAEC,OAAO,EAAE,GAAGC,WAAWC;IAC/B,MAAM,CAACC,SAASC,WAAW,GAAGC,SAAS;IAEvC,MAAMC,eAAeC,YACjB,OAAOC;QACHJ,WAAW;QAEX,IAAI;YACA,MAAMJ,QAAQ,OAAO,CAACQ;QAC1B,SAAU;YACNJ,WAAW;QACf;IACJ,GACA;QAACJ;KAAQ;IAGb,OAAO;QAAEM;QAAcH;IAAQ;AACnC"}

package/admin/Extension.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const Extension: () => React.JSX.Element;

package/admin/Extension.js

@@ -0,0 +1,49 @@
+import react from "react";
+import { AdminConfig, HasPermission, RegisterFeature, useRouter } from "@webiny/app-admin";
+import { Routes } from "@webiny/app-headless-cms";
+import { ReactComponent } from "@webiny/icons/business.svg";
+import { TenantEntryList } from "./TenantEntryList.js";
+import { CurrentTenantProvider } from "./CurrentTenantProvider.js";
+import { CurrentTenantFeature } from "./CurrentTenant/feature.js";
+import { DisableTenantFeature } from "./DisableTenant/index.js";
+import { EnableTenantFeature } from "./EnableTenant/index.js";
+import { TenantSelector } from "./TenantSelector.js";
+import { IsRootTenant } from "./IsRootTenant.js";
+import { TENANT_MODEL_ID } from "../shared/constants.js";
+import { SecurityPermission } from "./SecurityPermission.js";
+import { TmPermissionsFeature } from "./features/permissions/feature.js";
+import { InstallTenantFeature } from "./InstallTenant/index.js";
+const { Menu: Menu } = AdminConfig;
+const Extension = ()=>{
+    const { getLink } = useRouter();
+    const link = getLink(Routes.ContentEntries.List, {
+        modelId: TENANT_MODEL_ID
+    });
+    const icon = /*#__PURE__*/ react.createElement(Menu.Link.Icon, {
+        element: /*#__PURE__*/ react.createElement(ReactComponent, null),
+        label: "Tenant"
+    });
+    return /*#__PURE__*/ react.createElement(react.Fragment, null, /*#__PURE__*/ react.createElement(RegisterFeature, {
+        feature: CurrentTenantFeature
+    }), /*#__PURE__*/ react.createElement(RegisterFeature, {
+        feature: TmPermissionsFeature
+    }), /*#__PURE__*/ react.createElement(RegisterFeature, {
+        feature: InstallTenantFeature
+    }), /*#__PURE__*/ react.createElement(CurrentTenantProvider, null), /*#__PURE__*/ react.createElement(TenantSelector, null), /*#__PURE__*/ react.createElement(TenantEntryList, null), /*#__PURE__*/ react.createElement(SecurityPermission, null), /*#__PURE__*/ react.createElement(AdminConfig, null, /*#__PURE__*/ react.createElement(IsRootTenant, null, /*#__PURE__*/ react.createElement(RegisterFeature, {
+        feature: DisableTenantFeature
+    }), /*#__PURE__*/ react.createElement(RegisterFeature, {
+        feature: EnableTenantFeature
+    }), /*#__PURE__*/ react.createElement(HasPermission, {
+        name: "tm.tenant"
+    }, /*#__PURE__*/ react.createElement(Menu, {
+        name: "tenantManager",
+        element: /*#__PURE__*/ react.createElement(Menu.Link, {
+            text: "Tenant Manager",
+            icon: icon,
+            to: link
+        })
+    })))));
+};
+export { Extension };
+
+//# sourceMappingURL=Extension.js.map

package/admin/Extension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/Extension.js","sources":["../../src/admin/Extension.tsx"],"sourcesContent":["import React from \"react\";\nimport { AdminConfig, HasPermission, RegisterFeature } from \"@webiny/app-admin\";\nimport { useRouter } from \"@webiny/app-admin\";\nimport { Routes } from \"@webiny/app-headless-cms\";\nimport { ReactComponent as TenantIcon } from \"@webiny/icons/business.svg\";\n\nimport { TenantEntryList } from \"./TenantEntryList.js\";\nimport { CurrentTenantProvider } from \"./CurrentTenantProvider.js\";\nimport { CurrentTenantFeature } from \"./CurrentTenant/feature.js\";\nimport { DisableTenantFeature } from \"./DisableTenant/index.js\";\nimport { EnableTenantFeature } from \"./EnableTenant/index.js\";\nimport { TenantSelector } from \"./TenantSelector.js\";\nimport { IsRootTenant } from \"./IsRootTenant.js\";\nimport { TENANT_MODEL_ID } from \"~/shared/constants.js\";\nimport { SecurityPermission } from \"./SecurityPermission.js\";\nimport { TmPermissionsFeature } from \"./features/permissions/feature.js\";\nimport { InstallTenantFeature } from \"./InstallTenant/index.js\";\n\nconst { Menu } = AdminConfig;\n\nexport const Extension = () => {\n    const { getLink } = useRouter();\n\n    const link = getLink(Routes.ContentEntries.List, { modelId: TENANT_MODEL_ID });\n\n    const icon = <Menu.Link.Icon element={<TenantIcon />} label={\"Tenant\"} />;\n\n    return (\n        <>\n            <RegisterFeature feature={CurrentTenantFeature} />\n            <RegisterFeature feature={TmPermissionsFeature} />\n            <RegisterFeature feature={InstallTenantFeature} />\n            <CurrentTenantProvider />\n            <TenantSelector />\n            <TenantEntryList />\n            <SecurityPermission />\n            <AdminConfig>\n                <IsRootTenant>\n                    <RegisterFeature feature={DisableTenantFeature} />\n                    <RegisterFeature feature={EnableTenantFeature} />\n                    <HasPermission name={\"tm.tenant\"}>\n                        <Menu\n                            name=\"tenantManager\"\n                            element={<Menu.Link text=\"Tenant Manager\" icon={icon} to={link} />}\n                        />\n                    </HasPermission>\n                </IsRootTenant>\n            </AdminConfig>\n        </>\n    );\n};\n"],"names":["Menu","AdminConfig","Extension","getLink","useRouter","link","Routes","TENANT_MODEL_ID","icon","TenantIcon","RegisterFeature","CurrentTenantFeature","TmPermissionsFeature","InstallTenantFeature","CurrentTenantProvider","TenantSelector","TenantEntryList","SecurityPermission","IsRootTenant","DisableTenantFeature","EnableTenantFeature","HasPermission"],"mappings":";;;;;;;;;;;;;;;AAkBA,MAAM,EAAEA,MAAAA,IAAI,EAAE,GAAGC;AAEV,MAAMC,YAAY;IACrB,MAAM,EAAEC,OAAO,EAAE,GAAGC;IAEpB,MAAMC,OAAOF,QAAQG,OAAO,cAAc,CAAC,IAAI,EAAE;QAAE,SAASC;IAAgB;IAE5E,MAAMC,OAAO,WAAPA,GAAO,oBAACR,KAAK,IAAI,CAAC,IAAI;QAAC,uBAAS,oBAACS,gBAAUA;QAAK,OAAO;;IAE7D,OAAO,WAAP,GACI,wDACI,oBAACC,iBAAeA;QAAC,SAASC;sBAC1B,oBAACD,iBAAeA;QAAC,SAASE;sBAC1B,oBAACF,iBAAeA;QAAC,SAASG;sBAC1B,oBAACC,uBAAqBA,OAAAA,WAAAA,GACtB,oBAACC,gBAAcA,OAAAA,WAAAA,GACf,oBAACC,iBAAeA,OAAAA,WAAAA,GAChB,oBAACC,oBAAkBA,OAAAA,WAAAA,GACnB,oBAAChB,aAAWA,MAAAA,WAAAA,GACR,oBAACiB,cAAYA,MAAAA,WAAAA,GACT,oBAACR,iBAAeA;QAAC,SAASS;sBAC1B,oBAACT,iBAAeA;QAAC,SAASU;sBAC1B,oBAACC,eAAaA;QAAC,MAAM;qBACjB,oBAACrB,MAAIA;QACD,MAAK;QACL,uBAAS,oBAACA,KAAK,IAAI;YAAC,MAAK;YAAiB,MAAMQ;YAAM,IAAIH;;;AAOtF"}

package/admin/InstallTenant/InstallTenantGateway.d.ts

@@ -0,0 +1,11 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/index.js";
+import { InstallTenantGateway as GatewayAbstraction } from "./abstractions.js";
+declare class InstallTenantGraphQLGateway implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: MainGraphQLClient.Interface);
+    installTenant(tenantId: string): Promise<boolean>;
+}
+export declare const InstallTenantGateway: typeof InstallTenantGraphQLGateway & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IInstallTenantGateway>;
+};
+export {};

package/admin/InstallTenant/InstallTenantGateway.js

@@ -0,0 +1,42 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/index.js";
+import { InstallTenantGateway } from "./abstractions.js";
+const INSTALL_TENANT = `
+    mutation InstallTenant($tenantId: ID!) {
+        tenantManager {
+            installTenant(tenantId: $tenantId) {
+                data
+                error {
+                    code
+                    message
+                    data
+                }
+            }
+        }
+    }
+`;
+class InstallTenantGraphQLGateway {
+    constructor(client){
+        this.client = client;
+    }
+    async installTenant(tenantId) {
+        const response = await this.client.execute({
+            query: INSTALL_TENANT,
+            variables: {
+                tenantId
+            }
+        });
+        const envelope = response.tenantManager.installTenant;
+        if (envelope.error) throw new Error(envelope.error.message);
+        if (!envelope.data) throw new Error("Unable to install tenant");
+        return envelope.data;
+    }
+}
+const InstallTenantGateway_InstallTenantGateway = InstallTenantGateway.createImplementation({
+    implementation: InstallTenantGraphQLGateway,
+    dependencies: [
+        MainGraphQLClient
+    ]
+});
+export { InstallTenantGateway_InstallTenantGateway as InstallTenantGateway };
+
+//# sourceMappingURL=InstallTenantGateway.js.map

package/admin/InstallTenant/InstallTenantGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/InstallTenant/InstallTenantGateway.js","sources":["../../../src/admin/InstallTenant/InstallTenantGateway.ts"],"sourcesContent":["import { MainGraphQLClient } from \"@webiny/app/features/mainGraphQLClient/index.js\";\nimport { InstallTenantGateway as GatewayAbstraction } from \"./abstractions.js\";\n\nconst INSTALL_TENANT = /* GraphQL */ `\n    mutation InstallTenant($tenantId: ID!) {\n        tenantManager {\n            installTenant(tenantId: $tenantId) {\n                data\n                error {\n                    code\n                    message\n                    data\n                }\n            }\n        }\n    }\n`;\n\ntype InstallTenantResponse = {\n    tenantManager: {\n        installTenant:\n            | {\n                  data: boolean;\n                  error: null;\n              }\n            | {\n                  data: null;\n                  error: {\n                      code: string;\n                      message: string;\n                      data: Record<string, any>;\n                  };\n              };\n    };\n};\n\nclass InstallTenantGraphQLGateway implements GatewayAbstraction.Interface {\n    constructor(private client: MainGraphQLClient.Interface) {}\n\n    async installTenant(tenantId: string): Promise<boolean> {\n        const response = await this.client.execute<InstallTenantResponse>({\n            query: INSTALL_TENANT,\n            variables: { tenantId }\n        });\n\n        const envelope = response.tenantManager.installTenant;\n        if (envelope.error) {\n            throw new Error(envelope.error.message);\n        }\n\n        if (!envelope.data) {\n            throw new Error(\"Unable to install tenant\");\n        }\n\n        return envelope.data;\n    }\n}\n\nexport const InstallTenantGateway = GatewayAbstraction.createImplementation({\n    implementation: InstallTenantGraphQLGateway,\n    dependencies: [MainGraphQLClient]\n});\n"],"names":["INSTALL_TENANT","InstallTenantGraphQLGateway","client","tenantId","response","envelope","Error","InstallTenantGateway","GatewayAbstraction","MainGraphQLClient"],"mappings":";;AAGA,MAAMA,iBAA+B,CAAC;;;;;;;;;;;;;AAatC,CAAC;AAoBD,MAAMC;IACF,YAAoBC,MAAmC,CAAE;aAArCA,MAAM,GAANA;IAAsC;IAE1D,MAAM,cAAcC,QAAgB,EAAoB;QACpD,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAwB;YAC9D,OAAOJ;YACP,WAAW;gBAAEG;YAAS;QAC1B;QAEA,MAAME,WAAWD,SAAS,aAAa,CAAC,aAAa;QACrD,IAAIC,SAAS,KAAK,EACd,MAAM,IAAIC,MAAMD,SAAS,KAAK,CAAC,OAAO;QAG1C,IAAI,CAACA,SAAS,IAAI,EACd,MAAM,IAAIC,MAAM;QAGpB,OAAOD,SAAS,IAAI;IACxB;AACJ;AAEO,MAAME,4CAAuBC,qBAAAA,oBAAuC,CAAC;IACxE,gBAAgBP;IAChB,cAAc;QAACQ;KAAkB;AACrC"}

package/admin/InstallTenant/InstallTenantRepository.d.ts

@@ -0,0 +1,12 @@
+import { InstallTenantRepository as RepositoryAbstraction, InstallTenantGateway } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "@webiny/app-headless-cms/features/contentEntry/abstractions.js";
+declare class InstallTenantRepositoryImpl implements RepositoryAbstraction.Interface {
+    private gateway;
+    private cacheProvider;
+    constructor(gateway: InstallTenantGateway.Interface, cacheProvider: ContentEntriesCacheProvider.Interface);
+    execute(tenantId: string): Promise<void>;
+}
+export declare const InstallTenantRepository: typeof InstallTenantRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IInstallTenantRepository>;
+};
+export {};

package/admin/InstallTenant/InstallTenantRepository.js

@@ -0,0 +1,34 @@
+import { InstallTenantGateway, InstallTenantRepository } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "@webiny/app-headless-cms/features/contentEntry/abstractions.js";
+import { TENANT_MODEL_ID } from "../../shared/constants.js";
+class InstallTenantRepositoryImpl {
+    constructor(gateway, cacheProvider){
+        this.gateway = gateway;
+        this.cacheProvider = cacheProvider;
+    }
+    async execute(tenantId) {
+        await this.gateway.installTenant(tenantId);
+        const cache = this.cacheProvider.get(TENANT_MODEL_ID);
+        cache.updateItems((item)=>{
+            if (item.entryId === tenantId) return {
+                ...item,
+                values: {
+                    ...item.values,
+                    status: "enabled",
+                    isInstalled: true
+                }
+            };
+            return item;
+        });
+    }
+}
+const InstallTenantRepository_InstallTenantRepository = InstallTenantRepository.createImplementation({
+    implementation: InstallTenantRepositoryImpl,
+    dependencies: [
+        InstallTenantGateway,
+        ContentEntriesCacheProvider
+    ]
+});
+export { InstallTenantRepository_InstallTenantRepository as InstallTenantRepository };
+
+//# sourceMappingURL=InstallTenantRepository.js.map

package/admin/InstallTenant/InstallTenantRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/InstallTenant/InstallTenantRepository.js","sources":["../../../src/admin/InstallTenant/InstallTenantRepository.ts"],"sourcesContent":["import {\n    InstallTenantRepository as RepositoryAbstraction,\n    InstallTenantGateway\n} from \"./abstractions.js\";\nimport { ContentEntriesCacheProvider } from \"@webiny/app-headless-cms/features/contentEntry/abstractions.js\";\nimport { TENANT_MODEL_ID } from \"~/shared/constants.js\";\n\nclass InstallTenantRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private gateway: InstallTenantGateway.Interface,\n        private cacheProvider: ContentEntriesCacheProvider.Interface\n    ) {}\n\n    async execute(tenantId: string): Promise<void> {\n        await this.gateway.installTenant(tenantId);\n\n        const cache = this.cacheProvider.get(TENANT_MODEL_ID);\n        cache.updateItems(item => {\n            if (item.entryId === tenantId) {\n                return {\n                    ...item,\n                    values: { ...item.values, status: \"enabled\", isInstalled: true }\n                };\n            }\n            return item;\n        });\n    }\n}\n\nexport const InstallTenantRepository = RepositoryAbstraction.createImplementation({\n    implementation: InstallTenantRepositoryImpl,\n    dependencies: [InstallTenantGateway, ContentEntriesCacheProvider]\n});\n"],"names":["InstallTenantRepositoryImpl","gateway","cacheProvider","tenantId","cache","TENANT_MODEL_ID","item","InstallTenantRepository","RepositoryAbstraction","InstallTenantGateway","ContentEntriesCacheProvider"],"mappings":";;;AAOA,MAAMA;IACF,YACYC,OAAuC,EACvCC,aAAoD,CAC9D;aAFUD,OAAO,GAAPA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,QAAQC,QAAgB,EAAiB;QAC3C,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAACA;QAEjC,MAAMC,QAAQ,IAAI,CAAC,aAAa,CAAC,GAAG,CAACC;QACrCD,MAAM,WAAW,CAACE,CAAAA;YACd,IAAIA,KAAK,OAAO,KAAKH,UACjB,OAAO;gBACH,GAAGG,IAAI;gBACP,QAAQ;oBAAE,GAAGA,KAAK,MAAM;oBAAE,QAAQ;oBAAW,aAAa;gBAAK;YACnE;YAEJ,OAAOA;QACX;IACJ;AACJ;AAEO,MAAMC,kDAA0BC,wBAAAA,oBAA0C,CAAC;IAC9E,gBAAgBR;IAChB,cAAc;QAACS;QAAsBC;KAA4B;AACrE"}

package/admin/InstallTenant/InstallTenantUseCase.d.ts

@@ -0,0 +1,10 @@
+import { InstallTenantUseCase as UseCaseAbstraction, InstallTenantRepository } from "./abstractions.js";
+declare class InstallTenantUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: InstallTenantRepository.Interface);
+    execute(tenantId: string): Promise<void>;
+}
+export declare const InstallTenantUseCase: typeof InstallTenantUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IInstallTenantUseCase>;
+};
+export {};

package/admin/InstallTenant/InstallTenantUseCase.js

@@ -0,0 +1,18 @@
+import { InstallTenantRepository, InstallTenantUseCase } from "./abstractions.js";
+class InstallTenantUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(tenantId) {
+        return this.repository.execute(tenantId);
+    }
+}
+const InstallTenantUseCase_InstallTenantUseCase = InstallTenantUseCase.createImplementation({
+    implementation: InstallTenantUseCaseImpl,
+    dependencies: [
+        InstallTenantRepository
+    ]
+});
+export { InstallTenantUseCase_InstallTenantUseCase as InstallTenantUseCase };
+
+//# sourceMappingURL=InstallTenantUseCase.js.map

package/admin/InstallTenant/InstallTenantUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/InstallTenant/InstallTenantUseCase.js","sources":["../../../src/admin/InstallTenant/InstallTenantUseCase.ts"],"sourcesContent":["import {\n    InstallTenantUseCase as UseCaseAbstraction,\n    InstallTenantRepository\n} from \"./abstractions.js\";\n\nclass InstallTenantUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: InstallTenantRepository.Interface) {}\n\n    async execute(tenantId: string): Promise<void> {\n        return this.repository.execute(tenantId);\n    }\n}\n\nexport const InstallTenantUseCase = UseCaseAbstraction.createImplementation({\n    implementation: InstallTenantUseCaseImpl,\n    dependencies: [InstallTenantRepository]\n});\n"],"names":["InstallTenantUseCaseImpl","repository","tenantId","InstallTenantUseCase","UseCaseAbstraction","InstallTenantRepository"],"mappings":";AAKA,MAAMA;IACF,YAAoBC,UAA6C,CAAE;aAA/CA,UAAU,GAAVA;IAAgD;IAEpE,MAAM,QAAQC,QAAgB,EAAiB;QAC3C,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,4CAAuBC,qBAAAA,oBAAuC,CAAC;IACxE,gBAAgBJ;IAChB,cAAc;QAACK;KAAwB;AAC3C"}

package/admin/InstallTenant/abstractions.d.ts

@@ -0,0 +1,21 @@
+export interface IInstallTenantUseCase {
+    execute(tenantId: string): Promise<void>;
+}
+export declare const InstallTenantUseCase: import("@webiny/di").Abstraction<IInstallTenantUseCase>;
+export declare namespace InstallTenantUseCase {
+    type Interface = IInstallTenantUseCase;
+}
+export interface IInstallTenantRepository {
+    execute(tenantId: string): Promise<void>;
+}
+export declare const InstallTenantRepository: import("@webiny/di").Abstraction<IInstallTenantRepository>;
+export declare namespace InstallTenantRepository {
+    type Interface = IInstallTenantRepository;
+}
+export interface IInstallTenantGateway {
+    installTenant(tenantId: string): Promise<boolean>;
+}
+export declare const InstallTenantGateway: import("@webiny/di").Abstraction<IInstallTenantGateway>;
+export declare namespace InstallTenantGateway {
+    type Interface = IInstallTenantGateway;
+}

package/admin/InstallTenant/abstractions.js

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

package/admin/InstallTenant/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/InstallTenant/abstractions.js","sources":["../../../src/admin/InstallTenant/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\n\nexport interface IInstallTenantUseCase {\n    execute(tenantId: string): Promise<void>;\n}\n\nexport const InstallTenantUseCase =\n    createAbstraction<IInstallTenantUseCase>(\"InstallTenantUseCase\");\n\nexport namespace InstallTenantUseCase {\n    export type Interface = IInstallTenantUseCase;\n}\n\nexport interface IInstallTenantRepository {\n    execute(tenantId: string): Promise<void>;\n}\n\nexport const InstallTenantRepository =\n    createAbstraction<IInstallTenantRepository>(\"InstallTenantRepository\");\n\nexport namespace InstallTenantRepository {\n    export type Interface = IInstallTenantRepository;\n}\n\nexport interface IInstallTenantGateway {\n    installTenant(tenantId: string): Promise<boolean>;\n}\n\nexport const InstallTenantGateway =\n    createAbstraction<IInstallTenantGateway>(\"InstallTenantGateway\");\n\nexport namespace InstallTenantGateway {\n    export type Interface = IInstallTenantGateway;\n}\n"],"names":["InstallTenantUseCase","createAbstraction","InstallTenantRepository","InstallTenantGateway"],"mappings":";AAMO,MAAMA,uBACTC,kBAAyC;AAUtC,MAAMC,0BACTD,kBAA4C;AAUzC,MAAME,uBACTF,kBAAyC"}

package/admin/InstallTenant/feature.d.ts

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