@webiny/api-core 0.0.0-unstable.3c5210ad37

package/features/tenancy/TenantContext/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","TenantContext"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Tenant } from \"~/types/tenancy.js\";\n\nexport interface ITenantContext {\n    setTenant(tenant: Tenant): void;\n    getTenant(): Tenant;\n    withRootTenant<T>(cb: () => T): Promise<T>;\n    withEachTenant<TReturn>(\n        tenants: Tenant[],\n        cb: (tenant: Tenant) => Promise<TReturn>\n    ): Promise<TReturn[]>;\n    withTenant<TReturn>(tenant: Tenant, cb: (tenant: Tenant) => Promise<TReturn>): Promise<TReturn>;\n}\n\nexport const TenantContext = createAbstraction<ITenantContext>(\"TenantContext\");\n\nexport namespace TenantContext {\n    export type Interface = ITenantContext;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAcvD,OAAO,MAAMC,aAAa,GAAGD,iBAAiB,CAAiB,eAAe,CAAC","ignoreList":[]}

package/features/tenancy/TenantContext/errors.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from "@webiny/feature/api";
+export declare class TenantIsDisabledError extends BaseError {
+    readonly code: "Tenancy/TenantDisabled";
+    constructor();
+}

package/features/tenancy/TenantContext/errors.js

@@ -0,0 +1,11 @@
+import { BaseError } from "@webiny/feature/api";
+export class TenantIsDisabledError extends BaseError {
+  code = "Tenancy/TenantDisabled";
+  constructor() {
+    super({
+      message: "Tenant is disabled!"
+    });
+  }
+}
+
+//# sourceMappingURL=errors.js.map

package/features/tenancy/TenantContext/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BaseError","TenantIsDisabledError","code","constructor","message"],"sources":["errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\nexport class TenantIsDisabledError extends BaseError {\n    override readonly code = \"Tenancy/TenantDisabled\" as const;\n\n    constructor() {\n        super({ message: \"Tenant is disabled!\" });\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ,qBAAqB;AAE/C,OAAO,MAAMC,qBAAqB,SAASD,SAAS,CAAC;EAC/BE,IAAI,GAAG,wBAAwB;EAEjDC,WAAWA,CAAA,EAAG;IACV,KAAK,CAAC;MAAEC,OAAO,EAAE;IAAsB,CAAC,CAAC;EAC7C;AACJ","ignoreList":[]}

package/features/tenancy/TenantContext/feature.d.ts

@@ -0,0 +1 @@
+export declare const TenantContextFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/tenancy/TenantContext/feature.js

@@ -0,0 +1,10 @@
+import { createFeature } from "@webiny/feature/api";
+import { TenantContext } from "./TenantContext.js";
+export const TenantContextFeature = createFeature({
+  name: "TenantContextFeature",
+  register(container) {
+    container.register(TenantContext).inSingletonScope();
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/tenancy/TenantContext/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","TenantContext","TenantContextFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { TenantContext } from \"./TenantContext.js\";\n\nexport const TenantContextFeature = createFeature({\n    name: \"TenantContextFeature\",\n    register(container) {\n        container.register(TenantContext).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,aAAa;AAEtB,OAAO,MAAMC,oBAAoB,GAAGF,aAAa,CAAC;EAC9CG,IAAI,EAAE,sBAAsB;EAC5BC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,aAAa,CAAC,CAACK,gBAAgB,CAAC,CAAC;EACxD;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/tenancy/TenantContext/index.d.ts

@@ -0,0 +1 @@
+export { TenantContext } from "./abstractions.js";

package/features/tenancy/TenantContext/index.js

@@ -0,0 +1,3 @@
+export { TenantContext } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

package/features/tenancy/TenantContext/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TenantContext"],"sources":["index.ts"],"sourcesContent":["export { TenantContext } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,aAAa","ignoreList":[]}

package/features/tenancy/UpdateTenant/UpdateTenantGateway.d.ts

@@ -0,0 +1,10 @@
+import { UpdateTenantGateway as GatewayAbstraction } from "./abstractions.js";
+import { type Tenant } from "../../../types/tenancy.js";
+import { TenancyStorageOperations } from "../../../features/tenancy/shared/storageOperations.js";
+declare class UpdateTenantGatewayImpl implements GatewayAbstraction.Interface {
+    private storageOperations;
+    constructor(storageOperations: TenancyStorageOperations.Interface);
+    updateTenant(data: Tenant): Promise<Tenant>;
+}
+export declare const UpdateTenantGateway: import("@webiny/di").Implementation<typeof UpdateTenantGatewayImpl>;
+export {};

package/features/tenancy/UpdateTenant/UpdateTenantGateway.js

@@ -0,0 +1,18 @@
+import { createImplementation } from "@webiny/feature/api";
+import { UpdateTenantGateway as GatewayAbstraction } from "./abstractions.js";
+import { TenancyStorageOperations } from "../shared/storageOperations.js";
+class UpdateTenantGatewayImpl {
+  constructor(storageOperations) {
+    this.storageOperations = storageOperations;
+  }
+  async updateTenant(data) {
+    return await this.storageOperations.updateTenant(data);
+  }
+}
+export const UpdateTenantGateway = createImplementation({
+  abstraction: GatewayAbstraction,
+  implementation: UpdateTenantGatewayImpl,
+  dependencies: [TenancyStorageOperations]
+});
+
+//# sourceMappingURL=UpdateTenantGateway.js.map

package/features/tenancy/UpdateTenant/UpdateTenantGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","UpdateTenantGateway","GatewayAbstraction","TenancyStorageOperations","UpdateTenantGatewayImpl","constructor","storageOperations","updateTenant","data","abstraction","implementation","dependencies"],"sources":["UpdateTenantGateway.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { UpdateTenantGateway as GatewayAbstraction } from \"./abstractions.js\";\nimport { type Tenant } from \"~/types/tenancy.js\";\nimport { TenancyStorageOperations } from \"~/features/tenancy/shared/storageOperations.js\";\n\nclass UpdateTenantGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private storageOperations: TenancyStorageOperations.Interface) {}\n\n    async updateTenant(data: Tenant) {\n        return await this.storageOperations.updateTenant(data);\n    }\n}\n\nexport const UpdateTenantGateway = createImplementation({\n    abstraction: GatewayAbstraction,\n    implementation: UpdateTenantGatewayImpl,\n    dependencies: [TenancyStorageOperations]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,mBAAmB,IAAIC,kBAAkB;AAElD,SAASC,wBAAwB;AAEjC,MAAMC,uBAAuB,CAAyC;EAClEC,WAAWA,CAASC,iBAAqD,EAAE;IAAA,KAAvDA,iBAAqD,GAArDA,iBAAqD;EAAG;EAE5E,MAAMC,YAAYA,CAACC,IAAY,EAAE;IAC7B,OAAO,MAAM,IAAI,CAACF,iBAAiB,CAACC,YAAY,CAACC,IAAI,CAAC;EAC1D;AACJ;AAEA,OAAO,MAAMP,mBAAmB,GAAGD,oBAAoB,CAAC;EACpDS,WAAW,EAAEP,kBAAkB;EAC/BQ,cAAc,EAAEN,uBAAuB;EACvCO,YAAY,EAAE,CAACR,wBAAwB;AAC3C,CAAC,CAAC","ignoreList":[]}

package/features/tenancy/UpdateTenant/UpdateTenantRepository.d.ts

@@ -0,0 +1,12 @@
+import { UpdateTenantRepository as RepositoryAbstraction } from "./abstractions.js";
+import { UpdateTenantGateway } from "./abstractions.js";
+import { TenantCache } from "../shared/abstractions.js";
+import type { Tenant } from "../../../types/tenancy.js";
+declare class UpdateTenantRepositoryImpl implements RepositoryAbstraction.Interface {
+    private gateway;
+    private cache;
+    constructor(gateway: UpdateTenantGateway.Interface, cache: TenantCache.Interface);
+    update(tenant: Tenant): Promise<Tenant>;
+}
+export declare const UpdateTenantRepository: import("@webiny/di").Implementation<typeof UpdateTenantRepositoryImpl>;
+export {};

package/features/tenancy/UpdateTenant/UpdateTenantRepository.js

@@ -0,0 +1,23 @@
+import { createImplementation } from "@webiny/feature/api";
+import { UpdateTenantRepository as RepositoryAbstraction } from "./abstractions.js";
+import { UpdateTenantGateway } from "./abstractions.js";
+import { TenantCache } from "../shared/abstractions.js";
+class UpdateTenantRepositoryImpl {
+  constructor(gateway, cache) {
+    this.gateway = gateway;
+    this.cache = cache;
+  }
+  async update(tenant) {
+    const updated = await this.gateway.updateTenant(tenant);
+    this.cache.clear(updated.id);
+    this.cache.prime(updated.id, updated);
+    return updated;
+  }
+}
+export const UpdateTenantRepository = createImplementation({
+  abstraction: RepositoryAbstraction,
+  implementation: UpdateTenantRepositoryImpl,
+  dependencies: [UpdateTenantGateway, TenantCache]
+});
+
+//# sourceMappingURL=UpdateTenantRepository.js.map

package/features/tenancy/UpdateTenant/UpdateTenantRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","UpdateTenantRepository","RepositoryAbstraction","UpdateTenantGateway","TenantCache","UpdateTenantRepositoryImpl","constructor","gateway","cache","update","tenant","updated","updateTenant","clear","id","prime","abstraction","implementation","dependencies"],"sources":["UpdateTenantRepository.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { UpdateTenantRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { UpdateTenantGateway } from \"./abstractions.js\";\nimport { TenantCache } from \"../shared/abstractions.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\n\nclass UpdateTenantRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private gateway: UpdateTenantGateway.Interface,\n        private cache: TenantCache.Interface\n    ) {}\n\n    async update(tenant: Tenant) {\n        const updated = await this.gateway.updateTenant(tenant);\n        this.cache.clear(updated.id);\n        this.cache.prime(updated.id, updated);\n        return updated;\n    }\n}\n\nexport const UpdateTenantRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: UpdateTenantRepositoryImpl,\n    dependencies: [UpdateTenantGateway, TenantCache]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,sBAAsB,IAAIC,qBAAqB;AACxD,SAASC,mBAAmB;AAC5B,SAASC,WAAW;AAGpB,MAAMC,0BAA0B,CAA4C;EACxEC,WAAWA,CACCC,OAAsC,EACtCC,KAA4B,EACtC;IAAA,KAFUD,OAAsC,GAAtCA,OAAsC;IAAA,KACtCC,KAA4B,GAA5BA,KAA4B;EACrC;EAEH,MAAMC,MAAMA,CAACC,MAAc,EAAE;IACzB,MAAMC,OAAO,GAAG,MAAM,IAAI,CAACJ,OAAO,CAACK,YAAY,CAACF,MAAM,CAAC;IACvD,IAAI,CAACF,KAAK,CAACK,KAAK,CAACF,OAAO,CAACG,EAAE,CAAC;IAC5B,IAAI,CAACN,KAAK,CAACO,KAAK,CAACJ,OAAO,CAACG,EAAE,EAAEH,OAAO,CAAC;IACrC,OAAOA,OAAO;EAClB;AACJ;AAEA,OAAO,MAAMV,sBAAsB,GAAGD,oBAAoB,CAAC;EACvDgB,WAAW,EAAEd,qBAAqB;EAClCe,cAAc,EAAEZ,0BAA0B;EAC1Ca,YAAY,EAAE,CAACf,mBAAmB,EAAEC,WAAW;AACnD,CAAC,CAAC","ignoreList":[]}

package/features/tenancy/UpdateTenant/UpdateTenantUseCase.d.ts

@@ -0,0 +1,17 @@
+import { EventPublisher } from "../../../features/eventPublisher/index.js";
+import { Result } from "@webiny/feature/api";
+import { UpdateTenantUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { UpdateTenantRepository } from "./abstractions.js";
+import type { Tenant } from "../../../types/tenancy.js";
+import { GetTenantByIdUseCase } from "../../../features/tenancy/GetTenantById/index.js";
+declare class UpdateTenantUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getTenantById;
+    private eventPublisher;
+    private repository;
+    constructor(getTenantById: GetTenantByIdUseCase.Interface, eventPublisher: EventPublisher.Interface, repository: UpdateTenantRepository.Interface);
+    execute(id: string, data: Partial<Tenant>): Promise<({
+        _error: import("../GetTenantById/abstractions.js").GetTenantByIdError;
+    } & Result<Tenant, import("../GetTenantById/abstractions.js").GetTenantByIdError>) | Result<Tenant, never>>;
+}
+export declare const UpdateTenantUseCase: import("@webiny/di").Implementation<typeof UpdateTenantUseCaseImpl>;
+export {};

package/features/tenancy/UpdateTenant/UpdateTenantUseCase.js

@@ -0,0 +1,44 @@
+import { EventPublisher } from "../../eventPublisher/index.js";
+import { createImplementation } from "@webiny/feature/api";
+import { Result } from "@webiny/feature/api";
+import { UpdateTenantUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { UpdateTenantRepository } from "./abstractions.js";
+import { TenantBeforeUpdateEvent, TenantAfterUpdateEvent } from "./events.js";
+import { GetTenantByIdUseCase } from "../GetTenantById/index.js";
+class UpdateTenantUseCaseImpl {
+  constructor(getTenantById, eventPublisher, repository) {
+    this.getTenantById = getTenantById;
+    this.eventPublisher = eventPublisher;
+    this.repository = repository;
+  }
+  async execute(id, data) {
+    const result = await this.getTenantById.execute(id);
+    if (result.isFail()) {
+      return result;
+    }
+    const tenant = result.value;
+    const updateData = {
+      ...data,
+      savedOn: new Date().toISOString()
+    };
+    await this.eventPublisher.publish(new TenantBeforeUpdateEvent({
+      tenant,
+      inputData: data,
+      updateData
+    }));
+    Object.assign(tenant, updateData);
+    const updatedTenant = await this.repository.update(tenant);
+    await this.eventPublisher.publish(new TenantAfterUpdateEvent({
+      tenant: updatedTenant,
+      inputData: data
+    }));
+    return Result.ok(updatedTenant);
+  }
+}
+export const UpdateTenantUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: UpdateTenantUseCaseImpl,
+  dependencies: [GetTenantByIdUseCase, EventPublisher, UpdateTenantRepository]
+});
+
+//# sourceMappingURL=UpdateTenantUseCase.js.map

package/features/tenancy/UpdateTenant/UpdateTenantUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EventPublisher","createImplementation","Result","UpdateTenantUseCase","UseCaseAbstraction","UpdateTenantRepository","TenantBeforeUpdateEvent","TenantAfterUpdateEvent","GetTenantByIdUseCase","UpdateTenantUseCaseImpl","constructor","getTenantById","eventPublisher","repository","execute","id","data","result","isFail","tenant","value","updateData","savedOn","Date","toISOString","publish","inputData","Object","assign","updatedTenant","update","ok","abstraction","implementation","dependencies"],"sources":["UpdateTenantUseCase.ts"],"sourcesContent":["import { EventPublisher } from \"~/features/eventPublisher/index.js\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport { UpdateTenantUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { UpdateTenantRepository } from \"./abstractions.js\";\nimport { TenantBeforeUpdateEvent, TenantAfterUpdateEvent } from \"./events.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\nimport { GetTenantByIdUseCase } from \"~/features/tenancy/GetTenantById/index.js\";\n\nclass UpdateTenantUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private getTenantById: GetTenantByIdUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface,\n        private repository: UpdateTenantRepository.Interface\n    ) {}\n\n    async execute(id: string, data: Partial<Tenant>) {\n        const result = await this.getTenantById.execute(id);\n\n        if (result.isFail()) {\n            return result;\n        }\n        const tenant = result.value;\n\n        const updateData = { ...data, savedOn: new Date().toISOString() };\n\n        await this.eventPublisher.publish(\n            new TenantBeforeUpdateEvent({ tenant, inputData: data, updateData })\n        );\n\n        Object.assign(tenant, updateData);\n        const updatedTenant = await this.repository.update(tenant);\n\n        await this.eventPublisher.publish(\n            new TenantAfterUpdateEvent({ tenant: updatedTenant, inputData: data })\n        );\n\n        return Result.ok(updatedTenant);\n    }\n}\n\nexport const UpdateTenantUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: UpdateTenantUseCaseImpl,\n    dependencies: [GetTenantByIdUseCase, EventPublisher, UpdateTenantRepository]\n});\n"],"mappings":"AAAA,SAASA,cAAc;AACvB,SAASC,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,mBAAmB,IAAIC,kBAAkB;AAClD,SAASC,sBAAsB;AAC/B,SAASC,uBAAuB,EAAEC,sBAAsB;AAExD,SAASC,oBAAoB;AAE7B,MAAMC,uBAAuB,CAAyC;EAClEC,WAAWA,CACCC,aAA6C,EAC7CC,cAAwC,EACxCC,UAA4C,EACtD;IAAA,KAHUF,aAA6C,GAA7CA,aAA6C;IAAA,KAC7CC,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,UAA4C,GAA5CA,UAA4C;EACrD;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAEC,IAAqB,EAAE;IAC7C,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACN,aAAa,CAACG,OAAO,CAACC,EAAE,CAAC;IAEnD,IAAIE,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOD,MAAM;IACjB;IACA,MAAME,MAAM,GAAGF,MAAM,CAACG,KAAK;IAE3B,MAAMC,UAAU,GAAG;MAAE,GAAGL,IAAI;MAAEM,OAAO,EAAE,IAAIC,IAAI,CAAC,CAAC,CAACC,WAAW,CAAC;IAAE,CAAC;IAEjE,MAAM,IAAI,CAACZ,cAAc,CAACa,OAAO,CAC7B,IAAInB,uBAAuB,CAAC;MAAEa,MAAM;MAAEO,SAAS,EAAEV,IAAI;MAAEK;IAAW,CAAC,CACvE,CAAC;IAEDM,MAAM,CAACC,MAAM,CAACT,MAAM,EAAEE,UAAU,CAAC;IACjC,MAAMQ,aAAa,GAAG,MAAM,IAAI,CAAChB,UAAU,CAACiB,MAAM,CAACX,MAAM,CAAC;IAE1D,MAAM,IAAI,CAACP,cAAc,CAACa,OAAO,CAC7B,IAAIlB,sBAAsB,CAAC;MAAEY,MAAM,EAAEU,aAAa;MAAEH,SAAS,EAAEV;IAAK,CAAC,CACzE,CAAC;IAED,OAAOd,MAAM,CAAC6B,EAAE,CAACF,aAAa,CAAC;EACnC;AACJ;AAEA,OAAO,MAAM1B,mBAAmB,GAAGF,oBAAoB,CAAC;EACpD+B,WAAW,EAAE5B,kBAAkB;EAC/B6B,cAAc,EAAExB,uBAAuB;EACvCyB,YAAY,EAAE,CAAC1B,oBAAoB,EAAER,cAAc,EAAEK,sBAAsB;AAC/E,CAAC,CAAC","ignoreList":[]}

package/features/tenancy/UpdateTenant/abstractions.d.ts

@@ -0,0 +1,41 @@
+import { type Result } from "@webiny/feature/api";
+import type { IEventHandler, DomainEvent } from "../../../features/eventPublisher/index.js";
+import type { Tenant } from "../../../types/tenancy.js";
+import type { TenantBeforeUpdatePayload, TenantAfterUpdatePayload } from "./events.js";
+export type UpdateTenantError = {
+    type: "NOT_FOUND";
+} | {
+    type: "UNKNOWN";
+    cause: Error;
+};
+export interface IUpdateTenantUseCase {
+    execute(id: string, data: Partial<Tenant>): Promise<Result<Tenant, UpdateTenantError>>;
+}
+export declare const UpdateTenantUseCase: import("@webiny/di").Abstraction<IUpdateTenantUseCase>;
+export declare namespace UpdateTenantUseCase {
+    type Interface = IUpdateTenantUseCase;
+}
+export interface IUpdateTenantRepository {
+    update(tenant: Tenant): Promise<Tenant>;
+}
+export declare const UpdateTenantRepository: import("@webiny/di").Abstraction<IUpdateTenantRepository>;
+export declare namespace UpdateTenantRepository {
+    type Interface = IUpdateTenantRepository;
+}
+export interface IUpdateTenantGateway {
+    updateTenant(data: Tenant): Promise<Tenant>;
+}
+export declare const UpdateTenantGateway: import("@webiny/di").Abstraction<IUpdateTenantGateway>;
+export declare namespace UpdateTenantGateway {
+    type Interface = IUpdateTenantGateway;
+}
+export declare const TenantBeforeUpdateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TenantBeforeUpdatePayload>>>;
+export declare namespace TenantBeforeUpdateHandler {
+    type Interface = IEventHandler<DomainEvent<TenantBeforeUpdatePayload>>;
+    type Event = DomainEvent<TenantBeforeUpdatePayload>;
+}
+export declare const TenantAfterUpdateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TenantAfterUpdatePayload>>>;
+export declare namespace TenantAfterUpdateHandler {
+    type Interface = IEventHandler<DomainEvent<TenantAfterUpdatePayload>>;
+    type Event = DomainEvent<TenantAfterUpdatePayload>;
+}

package/features/tenancy/UpdateTenant/abstractions.js

@@ -0,0 +1,8 @@
+import { createAbstraction } from "@webiny/feature/api";
+export const UpdateTenantUseCase = createAbstraction("UpdateTenantUseCase");
+export const UpdateTenantRepository = createAbstraction("UpdateTenantRepository");
+export const UpdateTenantGateway = createAbstraction("UpdateTenantGateway");
+export const TenantBeforeUpdateHandler = createAbstraction("TenantBeforeUpdateHandler");
+export const TenantAfterUpdateHandler = createAbstraction("TenantAfterUpdateHandler");
+
+//# sourceMappingURL=abstractions.js.map

package/features/tenancy/UpdateTenant/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","UpdateTenantUseCase","UpdateTenantRepository","UpdateTenantGateway","TenantBeforeUpdateHandler","TenantAfterUpdateHandler"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { IEventHandler, DomainEvent } from \"~/features/eventPublisher/index.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\nimport type { TenantBeforeUpdatePayload, TenantAfterUpdatePayload } from \"./events.js\";\n\nexport type UpdateTenantError = { type: \"NOT_FOUND\" } | { type: \"UNKNOWN\"; cause: Error };\n\nexport interface IUpdateTenantUseCase {\n    execute(id: string, data: Partial<Tenant>): Promise<Result<Tenant, UpdateTenantError>>;\n}\n\nexport const UpdateTenantUseCase = createAbstraction<IUpdateTenantUseCase>(\"UpdateTenantUseCase\");\n\nexport namespace UpdateTenantUseCase {\n    export type Interface = IUpdateTenantUseCase;\n}\n\nexport interface IUpdateTenantRepository {\n    update(tenant: Tenant): Promise<Tenant>;\n}\n\nexport const UpdateTenantRepository =\n    createAbstraction<IUpdateTenantRepository>(\"UpdateTenantRepository\");\n\nexport namespace UpdateTenantRepository {\n    export type Interface = IUpdateTenantRepository;\n}\n\nexport interface IUpdateTenantGateway {\n    updateTenant(data: Tenant): Promise<Tenant>;\n}\n\nexport const UpdateTenantGateway = createAbstraction<IUpdateTenantGateway>(\"UpdateTenantGateway\");\n\nexport namespace UpdateTenantGateway {\n    export type Interface = IUpdateTenantGateway;\n}\n\nexport const TenantBeforeUpdateHandler = createAbstraction<\n    IEventHandler<DomainEvent<TenantBeforeUpdatePayload>>\n>(\"TenantBeforeUpdateHandler\");\n\nexport namespace TenantBeforeUpdateHandler {\n    export type Interface = IEventHandler<DomainEvent<TenantBeforeUpdatePayload>>;\n    export type Event = DomainEvent<TenantBeforeUpdatePayload>;\n}\n\nexport const TenantAfterUpdateHandler = createAbstraction<\n    IEventHandler<DomainEvent<TenantAfterUpdatePayload>>\n>(\"TenantAfterUpdateHandler\");\n\nexport namespace TenantAfterUpdateHandler {\n    export type Interface = IEventHandler<DomainEvent<TenantAfterUpdatePayload>>;\n    export type Event = DomainEvent<TenantAfterUpdatePayload>;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAqB,qBAAqB;AAWpE,OAAO,MAAMC,mBAAmB,GAAGD,iBAAiB,CAAuB,qBAAqB,CAAC;AAUjG,OAAO,MAAME,sBAAsB,GAC/BF,iBAAiB,CAA0B,wBAAwB,CAAC;AAUxE,OAAO,MAAMG,mBAAmB,GAAGH,iBAAiB,CAAuB,qBAAqB,CAAC;AAMjG,OAAO,MAAMI,yBAAyB,GAAGJ,iBAAiB,CAExD,2BAA2B,CAAC;AAO9B,OAAO,MAAMK,wBAAwB,GAAGL,iBAAiB,CAEvD,0BAA0B,CAAC","ignoreList":[]}

package/features/tenancy/UpdateTenant/events.d.ts

@@ -0,0 +1,19 @@
+import { DomainEvent } from "../../../features/eventPublisher/index.js";
+import type { Tenant } from "../../../types/tenancy.js";
+export interface TenantBeforeUpdatePayload {
+    tenant: Tenant;
+    inputData: Record<string, any>;
+    updateData: Partial<Tenant>;
+}
+export interface TenantAfterUpdatePayload {
+    tenant: Tenant;
+    inputData: Record<string, any>;
+}
+export declare class TenantBeforeUpdateEvent extends DomainEvent<TenantBeforeUpdatePayload> {
+    eventType: "tenant.beforeUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("~/features/eventPublisher/index.js").IEventHandler<DomainEvent<TenantBeforeUpdatePayload>>>;
+}
+export declare class TenantAfterUpdateEvent extends DomainEvent<TenantAfterUpdatePayload> {
+    eventType: "tenant.afterUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("~/features/eventPublisher/index.js").IEventHandler<DomainEvent<TenantAfterUpdatePayload>>>;
+}

package/features/tenancy/UpdateTenant/events.js

@@ -0,0 +1,16 @@
+import { DomainEvent } from "../../eventPublisher/index.js";
+import { TenantBeforeUpdateHandler, TenantAfterUpdateHandler } from "./abstractions.js";
+export class TenantBeforeUpdateEvent extends DomainEvent {
+  eventType = "tenant.beforeUpdate";
+  getHandlerAbstraction() {
+    return TenantBeforeUpdateHandler;
+  }
+}
+export class TenantAfterUpdateEvent extends DomainEvent {
+  eventType = "tenant.afterUpdate";
+  getHandlerAbstraction() {
+    return TenantAfterUpdateHandler;
+  }
+}
+
+//# sourceMappingURL=events.js.map

package/features/tenancy/UpdateTenant/events.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DomainEvent","TenantBeforeUpdateHandler","TenantAfterUpdateHandler","TenantBeforeUpdateEvent","eventType","getHandlerAbstraction","TenantAfterUpdateEvent"],"sources":["events.ts"],"sourcesContent":["import { DomainEvent } from \"~/features/eventPublisher/index.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\nimport { TenantBeforeUpdateHandler, TenantAfterUpdateHandler } from \"./abstractions.js\";\n\nexport interface TenantBeforeUpdatePayload {\n    tenant: Tenant;\n    inputData: Record<string, any>;\n    updateData: Partial<Tenant>;\n}\n\nexport interface TenantAfterUpdatePayload {\n    tenant: Tenant;\n    inputData: Record<string, any>;\n}\n\nexport class TenantBeforeUpdateEvent extends DomainEvent<TenantBeforeUpdatePayload> {\n    eventType = \"tenant.beforeUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return TenantBeforeUpdateHandler;\n    }\n}\n\nexport class TenantAfterUpdateEvent extends DomainEvent<TenantAfterUpdatePayload> {\n    eventType = \"tenant.afterUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return TenantAfterUpdateHandler;\n    }\n}\n"],"mappings":"AAAA,SAASA,WAAW;AAEpB,SAASC,yBAAyB,EAAEC,wBAAwB;AAa5D,OAAO,MAAMC,uBAAuB,SAASH,WAAW,CAA4B;EAChFI,SAAS,GAAG,qBAAqB;EAEjCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOJ,yBAAyB;EACpC;AACJ;AAEA,OAAO,MAAMK,sBAAsB,SAASN,WAAW,CAA2B;EAC9EI,SAAS,GAAG,oBAAoB;EAEhCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOH,wBAAwB;EACnC;AACJ","ignoreList":[]}

package/features/tenancy/UpdateTenant/feature.d.ts

@@ -0,0 +1 @@
+export declare const UpdateTenantFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/tenancy/UpdateTenant/feature.js

@@ -0,0 +1,14 @@
+import { createFeature } from "@webiny/feature/api";
+import { UpdateTenantUseCase } from "./UpdateTenantUseCase.js";
+import { UpdateTenantRepository } from "./UpdateTenantRepository.js";
+import { UpdateTenantGateway } from "./UpdateTenantGateway.js";
+export const UpdateTenantFeature = createFeature({
+  name: "UpdateTenant",
+  register(container) {
+    container.register(UpdateTenantUseCase);
+    container.register(UpdateTenantRepository).inSingletonScope();
+    container.register(UpdateTenantGateway).inSingletonScope();
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/tenancy/UpdateTenant/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","UpdateTenantUseCase","UpdateTenantRepository","UpdateTenantGateway","UpdateTenantFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { UpdateTenantUseCase } from \"./UpdateTenantUseCase.js\";\nimport { UpdateTenantRepository } from \"./UpdateTenantRepository.js\";\nimport { UpdateTenantGateway } from \"./UpdateTenantGateway.js\";\n\nexport const UpdateTenantFeature = createFeature({\n    name: \"UpdateTenant\",\n    register(container: Container) {\n        container.register(UpdateTenantUseCase);\n        container.register(UpdateTenantRepository).inSingletonScope();\n        container.register(UpdateTenantGateway).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,mBAAmB;AAC5B,SAASC,sBAAsB;AAC/B,SAASC,mBAAmB;AAE5B,OAAO,MAAMC,mBAAmB,GAAGJ,aAAa,CAAC;EAC7CK,IAAI,EAAE,cAAc;EACpBC,QAAQA,CAACC,SAAoB,EAAE;IAC3BA,SAAS,CAACD,QAAQ,CAACL,mBAAmB,CAAC;IACvCM,SAAS,CAACD,QAAQ,CAACJ,sBAAsB,CAAC,CAACM,gBAAgB,CAAC,CAAC;IAC7DD,SAAS,CAACD,QAAQ,CAACH,mBAAmB,CAAC,CAACK,gBAAgB,CAAC,CAAC;EAC9D;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/tenancy/UpdateTenant/index.d.ts

@@ -0,0 +1,3 @@
+export { UpdateTenantFeature } from "./feature.js";
+export { UpdateTenantUseCase, UpdateTenantRepository, UpdateTenantGateway, TenantBeforeUpdateHandler, TenantAfterUpdateHandler } from "./abstractions.js";
+export { TenantBeforeUpdateEvent, TenantAfterUpdateEvent } from "./events.js";

package/features/tenancy/UpdateTenant/index.js

@@ -0,0 +1,5 @@
+export { UpdateTenantFeature } from "./feature.js";
+export { UpdateTenantUseCase, UpdateTenantRepository, UpdateTenantGateway, TenantBeforeUpdateHandler, TenantAfterUpdateHandler } from "./abstractions.js";
+export { TenantBeforeUpdateEvent, TenantAfterUpdateEvent } from "./events.js";
+
+//# sourceMappingURL=index.js.map

package/features/tenancy/UpdateTenant/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["UpdateTenantFeature","UpdateTenantUseCase","UpdateTenantRepository","UpdateTenantGateway","TenantBeforeUpdateHandler","TenantAfterUpdateHandler","TenantBeforeUpdateEvent","TenantAfterUpdateEvent"],"sources":["index.ts"],"sourcesContent":["export { UpdateTenantFeature } from \"./feature.js\";\nexport {\n    UpdateTenantUseCase,\n    UpdateTenantRepository,\n    UpdateTenantGateway,\n    TenantBeforeUpdateHandler,\n    TenantAfterUpdateHandler\n} from \"./abstractions.js\";\nexport { TenantBeforeUpdateEvent, TenantAfterUpdateEvent } from \"./events.js\";\n"],"mappings":"AAAA,SAASA,mBAAmB;AAC5B,SACIC,mBAAmB,EACnBC,sBAAsB,EACtBC,mBAAmB,EACnBC,yBAAyB,EACzBC,wBAAwB;AAE5B,SAASC,uBAAuB,EAAEC,sBAAsB","ignoreList":[]}

package/features/tenancy/shared/TenantCache.d.ts

@@ -0,0 +1,13 @@
+import type { TenantCache as CacheAbstraction } from "./abstractions.js";
+import type { Tenant } from "../../../types/tenancy.js";
+export interface TenantCacheBatchLoader {
+    (ids: readonly string[]): Promise<Tenant[]>;
+}
+export declare class TenantCache implements CacheAbstraction.Interface {
+    private loader;
+    constructor(batchLoadFn: TenantCacheBatchLoader);
+    get(id: string): Promise<Tenant>;
+    getMany(ids: readonly string[]): Promise<Tenant[]>;
+    clear(id: string): void;
+    prime(id: string, tenant: Tenant | undefined): void;
+}

package/features/tenancy/shared/TenantCache.js

@@ -0,0 +1,20 @@
+import DataLoader from "dataloader";
+export class TenantCache {
+  constructor(batchLoadFn) {
+    this.loader = new DataLoader(batchLoadFn);
+  }
+  async get(id) {
+    return await this.loader.load(id);
+  }
+  async getMany(ids) {
+    return await this.loader.loadMany(ids);
+  }
+  clear(id) {
+    this.loader.clear(id);
+  }
+  prime(id, tenant) {
+    this.loader.prime(id, tenant);
+  }
+}
+
+//# sourceMappingURL=TenantCache.js.map

package/features/tenancy/shared/TenantCache.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DataLoader","TenantCache","constructor","batchLoadFn","loader","get","id","load","getMany","ids","loadMany","clear","prime","tenant"],"sources":["TenantCache.ts"],"sourcesContent":["import DataLoader from \"dataloader\";\nimport type { TenantCache as CacheAbstraction } from \"./abstractions.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\n\nexport interface TenantCacheBatchLoader {\n    (ids: readonly string[]): Promise<Tenant[]>;\n}\n\nexport class TenantCache implements CacheAbstraction.Interface {\n    private loader: DataLoader<string, Tenant>;\n\n    constructor(batchLoadFn: TenantCacheBatchLoader) {\n        this.loader = new DataLoader<string, Tenant>(batchLoadFn);\n    }\n\n    async get(id: string): Promise<Tenant> {\n        return (await this.loader.load(id)) as Tenant;\n    }\n\n    async getMany(ids: readonly string[]): Promise<Tenant[]> {\n        return (await this.loader.loadMany(ids)) as Tenant[];\n    }\n\n    clear(id: string): void {\n        this.loader.clear(id);\n    }\n\n    prime(id: string, tenant: Tenant | undefined): void {\n        this.loader.prime(id, tenant as Tenant);\n    }\n}\n"],"mappings":"AAAA,OAAOA,UAAU,MAAM,YAAY;AAQnC,OAAO,MAAMC,WAAW,CAAuC;EAG3DC,WAAWA,CAACC,WAAmC,EAAE;IAC7C,IAAI,CAACC,MAAM,GAAG,IAAIJ,UAAU,CAAiBG,WAAW,CAAC;EAC7D;EAEA,MAAME,GAAGA,CAACC,EAAU,EAAmB;IACnC,OAAQ,MAAM,IAAI,CAACF,MAAM,CAACG,IAAI,CAACD,EAAE,CAAC;EACtC;EAEA,MAAME,OAAOA,CAACC,GAAsB,EAAqB;IACrD,OAAQ,MAAM,IAAI,CAACL,MAAM,CAACM,QAAQ,CAACD,GAAG,CAAC;EAC3C;EAEAE,KAAKA,CAACL,EAAU,EAAQ;IACpB,IAAI,CAACF,MAAM,CAACO,KAAK,CAACL,EAAE,CAAC;EACzB;EAEAM,KAAKA,CAACN,EAAU,EAAEO,MAA0B,EAAQ;IAChD,IAAI,CAACT,MAAM,CAACQ,KAAK,CAACN,EAAE,EAAEO,MAAgB,CAAC;EAC3C;AACJ","ignoreList":[]}

package/features/tenancy/shared/abstractions.d.ts

@@ -0,0 +1,11 @@
+import type { Tenant } from "../../../types/tenancy.js";
+export interface ITenantCache {
+    get(id: string): Promise<Tenant>;
+    getMany(ids: readonly string[]): Promise<Tenant[]>;
+    clear(id: string): void;
+    prime(id: string, tenant: Tenant | undefined): void;
+}
+export declare const TenantCache: import("@webiny/di").Abstraction<ITenantCache>;
+export declare namespace TenantCache {
+    type Interface = ITenantCache;
+}

package/features/tenancy/shared/abstractions.js

@@ -0,0 +1,4 @@
+import { createAbstraction } from "@webiny/feature/api";
+export const TenantCache = createAbstraction("TenantCache");
+
+//# sourceMappingURL=abstractions.js.map

package/features/tenancy/shared/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","TenantCache"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Tenant } from \"~/types/tenancy.js\";\n\nexport interface ITenantCache {\n    get(id: string): Promise<Tenant>;\n    getMany(ids: readonly string[]): Promise<Tenant[]>;\n    clear(id: string): void;\n    prime(id: string, tenant: Tenant | undefined): void;\n}\n\nexport const TenantCache = createAbstraction<ITenantCache>(\"TenantCache\");\n\nexport namespace TenantCache {\n    export type Interface = ITenantCache;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAUvD,OAAO,MAAMC,WAAW,GAAGD,iBAAiB,CAAe,aAAa,CAAC","ignoreList":[]}

package/features/tenancy/shared/storageOperations.d.ts

@@ -0,0 +1,9 @@
+import type { TenancyStorageOperations as ITenancyStorageOperations } from "../../../types/tenancy.js";
+/**
+ * Abstraction for Tenancy Storage Operations
+ * This allows the legacy storage operations to be injected through DI
+ */
+export declare const TenancyStorageOperations: import("@webiny/di").Abstraction<ITenancyStorageOperations>;
+export declare namespace TenancyStorageOperations {
+    type Interface = ITenancyStorageOperations;
+}

package/features/tenancy/shared/storageOperations.js

@@ -0,0 +1,8 @@
+import { createAbstraction } from "@webiny/feature/api";
+/**
+ * Abstraction for Tenancy Storage Operations
+ * This allows the legacy storage operations to be injected through DI
+ */
+export const TenancyStorageOperations = createAbstraction("TenancyStorageOperations");
+
+//# sourceMappingURL=storageOperations.js.map

package/features/tenancy/shared/storageOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","TenancyStorageOperations"],"sources":["storageOperations.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { TenancyStorageOperations as ITenancyStorageOperations } from \"~/types/tenancy.js\";\n\n/**\n * Abstraction for Tenancy Storage Operations\n * This allows the legacy storage operations to be injected through DI\n */\nexport const TenancyStorageOperations = createAbstraction<ITenancyStorageOperations>(\n    \"TenancyStorageOperations\"\n);\n\nexport namespace TenancyStorageOperations {\n    export type Interface = ITenancyStorageOperations;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAGvD;AACA;AACA;AACA;AACA,OAAO,MAAMC,wBAAwB,GAAGD,iBAAiB,CACrD,0BACJ,CAAC","ignoreList":[]}

package/features/users/AdminUsersFeature.d.ts

@@ -0,0 +1 @@
+export declare const AdminUsersFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<import("../../types/users.js").AdminUsersStorageOperations>;

package/features/users/AdminUsersFeature.js

@@ -0,0 +1,33 @@
+import { createFeature } from "@webiny/feature/api";
+import { AdminUsersRepository } from "./shared/AdminUsersRepository.js";
+import { GetUserFeature } from "./GetUser/feature.js";
+import { GetIdentityProfileFeature } from "./GetIdentityProfile/feature.js";
+import { ListUsersFeature } from "./ListUsers/feature.js";
+import { CreateUserFeature } from "./CreateUser/feature.js";
+import { UpdateUserFeature } from "./UpdateUser/feature.js";
+import { DeleteUserFeature } from "./DeleteUser/feature.js";
+import { ListUserTeamsFeature } from "./ListUserTeams/feature.js";
+import { AdminUsersStorageOperations } from "./shared/storageAbstractions.js";
+import { ExternalIdpUserSyncFeature } from "./ExternalIdpUserSync/index.js";
+export const AdminUsersFeature = createFeature({
+  name: "AdminUsers",
+  register(container, storageOperations) {
+    // Register repository in singleton scope
+    container.register(AdminUsersRepository).inSingletonScope();
+
+    // Register all use cases
+    GetUserFeature.register(container);
+    GetIdentityProfileFeature.register(container);
+    ListUsersFeature.register(container);
+    ListUserTeamsFeature.register(container);
+    CreateUserFeature.register(container);
+    UpdateUserFeature.register(container);
+    DeleteUserFeature.register(container);
+    ExternalIdpUserSyncFeature.register(container);
+
+    // Legacy storage ops
+    container.registerInstance(AdminUsersStorageOperations, storageOperations);
+  }
+});
+
+//# sourceMappingURL=AdminUsersFeature.js.map

package/features/users/AdminUsersFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","AdminUsersRepository","GetUserFeature","GetIdentityProfileFeature","ListUsersFeature","CreateUserFeature","UpdateUserFeature","DeleteUserFeature","ListUserTeamsFeature","AdminUsersStorageOperations","ExternalIdpUserSyncFeature","AdminUsersFeature","name","register","container","storageOperations","inSingletonScope","registerInstance"],"sources":["AdminUsersFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { AdminUsersRepository } from \"./shared/AdminUsersRepository.js\";\nimport { GetUserFeature } from \"./GetUser/feature.js\";\nimport { GetIdentityProfileFeature } from \"./GetIdentityProfile/feature.js\";\nimport { ListUsersFeature } from \"./ListUsers/feature.js\";\nimport { CreateUserFeature } from \"./CreateUser/feature.js\";\nimport { UpdateUserFeature } from \"./UpdateUser/feature.js\";\nimport { DeleteUserFeature } from \"./DeleteUser/feature.js\";\nimport { ListUserTeamsFeature } from \"./ListUserTeams/feature.js\";\nimport { AdminUsersStorageOperations } from \"./shared/storageAbstractions.js\";\nimport { ExternalIdpUserSyncFeature } from \"./ExternalIdpUserSync/index.js\";\n\nexport const AdminUsersFeature = createFeature({\n    name: \"AdminUsers\",\n    register(container, storageOperations: AdminUsersStorageOperations.Interface) {\n        // Register repository in singleton scope\n        container.register(AdminUsersRepository).inSingletonScope();\n\n        // Register all use cases\n        GetUserFeature.register(container);\n        GetIdentityProfileFeature.register(container);\n        ListUsersFeature.register(container);\n        ListUserTeamsFeature.register(container);\n        CreateUserFeature.register(container);\n        UpdateUserFeature.register(container);\n        DeleteUserFeature.register(container);\n        ExternalIdpUserSyncFeature.register(container);\n\n        // Legacy storage ops\n        container.registerInstance(AdminUsersStorageOperations, storageOperations);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,oBAAoB;AAC7B,SAASC,cAAc;AACvB,SAASC,yBAAyB;AAClC,SAASC,gBAAgB;AACzB,SAASC,iBAAiB;AAC1B,SAASC,iBAAiB;AAC1B,SAASC,iBAAiB;AAC1B,SAASC,oBAAoB;AAC7B,SAASC,2BAA2B;AACpC,SAASC,0BAA0B;AAEnC,OAAO,MAAMC,iBAAiB,GAAGX,aAAa,CAAC;EAC3CY,IAAI,EAAE,YAAY;EAClBC,QAAQA,CAACC,SAAS,EAAEC,iBAAwD,EAAE;IAC1E;IACAD,SAAS,CAACD,QAAQ,CAACZ,oBAAoB,CAAC,CAACe,gBAAgB,CAAC,CAAC;;IAE3D;IACAd,cAAc,CAACW,QAAQ,CAACC,SAAS,CAAC;IAClCX,yBAAyB,CAACU,QAAQ,CAACC,SAAS,CAAC;IAC7CV,gBAAgB,CAACS,QAAQ,CAACC,SAAS,CAAC;IACpCN,oBAAoB,CAACK,QAAQ,CAACC,SAAS,CAAC;IACxCT,iBAAiB,CAACQ,QAAQ,CAACC,SAAS,CAAC;IACrCR,iBAAiB,CAACO,QAAQ,CAACC,SAAS,CAAC;IACrCP,iBAAiB,CAACM,QAAQ,CAACC,SAAS,CAAC;IACrCJ,0BAA0B,CAACG,QAAQ,CAACC,SAAS,CAAC;;IAE9C;IACAA,SAAS,CAACG,gBAAgB,CAACR,2BAA2B,EAAEM,iBAAiB,CAAC;EAC9E;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/users/CreateUser/CreateUserUseCase.d.ts

@@ -0,0 +1,19 @@
+import { Result } from "@webiny/feature/api";
+import { TenantContext } from "../../../features/tenancy/TenantContext/index.js";
+import { IdentityContext } from "../../../features/security/IdentityContext/index.js";
+import { EventPublisher } from "../../../features/eventPublisher/index.js";
+import { CreateUserUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { AdminUsersRepository } from "../../../features/users/shared/abstractions.js";
+import type { AdminUser } from "../../../features/users/shared/types.js";
+import type { CreateUserInput } from "../../../features/users/shared/types.js";
+declare class CreateUserUseCaseImpl implements UseCaseAbstraction.Interface {
+    private tenantContext;
+    private identityContext;
+    private eventPublisher;
+    private repository;
+    constructor(tenantContext: TenantContext.Interface, identityContext: IdentityContext.Interface, eventPublisher: EventPublisher.Interface, repository: AdminUsersRepository.Interface);
+    execute(input: CreateUserInput): Promise<Result<AdminUser, UseCaseAbstraction.Error>>;
+    private getDisplayName;
+}
+export declare const CreateUserUseCase: import("@webiny/di").Implementation<typeof CreateUserUseCaseImpl>;
+export {};