@komune-io/im-user-domain 0.22.0-alpha.fc04425 → 0.23.0-alpha.86ada5a

package/connect-im-im-f2-user-im-user-domain.d.mts

@@ -0,0 +1,1144 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare interface KtList<E> /* extends Collection<E> */ {
+    asJsReadonlyArrayView(): ReadonlyArray<E>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "kotlin.collections.KtList": unique symbol;
+    };
+}
+export declare namespace KtList {
+    function fromJsArray<E>(array: ReadonlyArray<E>): KtList<E>;
+}
+export declare interface KtMap<K, V> {
+    asJsReadonlyMapView(): ReadonlyMap<K, V>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "kotlin.collections.KtMap": unique symbol;
+    };
+}
+export declare namespace KtMap {
+    function fromJsMap<K, V>(map: ReadonlyMap<K, V>): KtMap<K, V>;
+}
+export declare interface UserDeleteCommandDTO {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.core.user.domain.command.UserDeleteCommandDTO": unique symbol;
+    };
+}
+export declare interface UserDeletedEventDTO {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.core.user.domain.command.UserDeletedEventDTO": unique symbol;
+    };
+}
+export declare abstract class ImMfaPasswordOtpFlowAcr {
+    private constructor();
+    static get PASSWORD_ONLY(): ImMfaPasswordOtpFlowAcr & {
+        get name(): "PASSWORD_ONLY";
+        get ordinal(): 0;
+    };
+    static get PASSWORD_OTP(): ImMfaPasswordOtpFlowAcr & {
+        get name(): "PASSWORD_OTP";
+        get ordinal(): 1;
+    };
+    get name(): "PASSWORD_ONLY" | "PASSWORD_OTP";
+    get ordinal(): 0 | 1;
+    get key(): string;
+    get level(): number;
+    static values(): Array<ImMfaPasswordOtpFlowAcr>;
+    static valueOf(value: string): ImMfaPasswordOtpFlowAcr;
+}
+export declare namespace ImMfaPasswordOtpFlowAcr {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => ImMfaPasswordOtpFlowAcr;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                asKeycloakMap(): KtMap<string, string>;
+                private constructor();
+            }
+        }
+    }
+}
+export declare interface Command extends Message {
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.Command": unique symbol;
+    } & Message["__doNotUseOrImplementIt"];
+}
+export declare interface Event extends Message {
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.Event": unique symbol;
+    } & Message["__doNotUseOrImplementIt"];
+}
+export declare interface Message {
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.Message": unique symbol;
+    };
+}
+export declare interface Problem extends Message {
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.Problem": unique symbol;
+    } & Message["__doNotUseOrImplementIt"];
+}
+export declare interface Query extends Message {
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.Query": unique symbol;
+    } & Message["__doNotUseOrImplementIt"];
+}
+export declare interface EnvelopeDTO<T> extends Message/*, WithEnvelopeId, WithEnvelopeData<T> */ {
+    readonly type: string;
+    readonly datacontenttype: Nullable<string>;
+    readonly specversion: Nullable<string>;
+    readonly source: Nullable<string>;
+    readonly time: Nullable<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.envelope.EnvelopeDTO": unique symbol;
+    } & Message["__doNotUseOrImplementIt"];
+}
+export declare class Envelope<T> implements EnvelopeDTO<T> {
+    constructor(id: string, data: T, type: string, datacontenttype?: Nullable<string>, specversion?: Nullable<string>, source?: Nullable<string>, time?: Nullable<string>);
+    get type(): string;
+    get datacontenttype(): Nullable<string>;
+    get specversion(): Nullable<string>;
+    get source(): Nullable<string>;
+    get time(): Nullable<string>;
+    readonly __doNotUseOrImplementIt: EnvelopeDTO<T>["__doNotUseOrImplementIt"];
+}
+export declare namespace Envelope {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new <T>() => Envelope<T>;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor /* implements SerializerFactory */ {
+                get $cachedDescriptor(): any/* SerialDescriptor */;
+                private constructor();
+            }
+        }
+    }
+}
+export declare interface F2ErrorDTO extends Problem {
+    readonly id: Nullable<string>;
+    readonly timestamp: string;
+    readonly code: number;
+    readonly requestId: Nullable<string>;
+    readonly message: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.error.F2ErrorDTO": unique symbol;
+    } & Problem["__doNotUseOrImplementIt"];
+}
+export declare class F2Error implements F2ErrorDTO {
+    constructor(message: string, id?: Nullable<string>, timestamp?: string, code?: number, requestId?: Nullable<string>);
+    get message(): string;
+    get id(): Nullable<string>;
+    get timestamp(): string;
+    get code(): number;
+    get requestId(): Nullable<string>;
+    toString(): string;
+    readonly __doNotUseOrImplementIt: F2ErrorDTO["__doNotUseOrImplementIt"];
+}
+export declare namespace F2Error {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => F2Error;
+    }
+}
+export declare class F2Exception extends /* RuntimeException */ Error {
+    constructor(error: F2ErrorDTO, cause?: Nullable<Error>);
+    get error(): F2ErrorDTO;
+}
+export declare namespace F2Exception {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => F2Exception;
+    }
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                invoke(message: string, id?: string, requestId?: string, code?: number, cause?: Nullable<Error>): F2Exception;
+                private constructor();
+            }
+        }
+    }
+}
+export declare interface Match<T> {
+    readonly negative: boolean;
+    map<R>(transform: (p0: T) => R): Match<R>;
+    not(): Match<T>;
+    and(match: Match<T>): Match<T>;
+    or(match: Match<T>): Match<T>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.filter.Match": unique symbol;
+    };
+}
+export declare interface SortDTO {
+    readonly property: string;
+    readonly ascending: boolean;
+    readonly nullsFirst: Nullable<boolean>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.filter.SortDTO": unique symbol;
+    };
+}
+export declare interface PageDTO<OBJECT> {
+    readonly total: number;
+    readonly items: KtList<OBJECT>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.page.PageDTO": unique symbol;
+    };
+}
+export declare class Page<OBJECT> implements PageDTO<OBJECT> {
+    constructor(total: number, items: KtList<OBJECT>);
+    get total(): number;
+    get items(): KtList<OBJECT>;
+    readonly __doNotUseOrImplementIt: PageDTO<OBJECT>["__doNotUseOrImplementIt"];
+}
+export declare namespace Page {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new <OBJECT>() => Page<OBJECT>;
+    }
+}
+export declare interface PageQueryDTO extends Query {
+    readonly pagination: Nullable<OffsetPaginationDTO>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.page.PageQueryDTO": unique symbol;
+    } & Query["__doNotUseOrImplementIt"];
+}
+export declare interface PageQueryResultDTO<OBJECT> extends Event, PageDTO<OBJECT> {
+    readonly total: number;
+    readonly items: KtList<OBJECT>;
+    readonly pagination: Nullable<OffsetPaginationDTO>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.page.PageQueryResultDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"] & PageDTO<OBJECT>["__doNotUseOrImplementIt"];
+}
+export declare class PageQuery implements PageQueryDTO {
+    constructor(pagination: Nullable<OffsetPaginationDTO>);
+    get pagination(): Nullable<OffsetPaginationDTO>;
+    readonly __doNotUseOrImplementIt: PageQueryDTO["__doNotUseOrImplementIt"];
+}
+export declare namespace PageQuery {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PageQuery;
+    }
+}
+export declare class PageQueryResult<OBJECT> implements PageQueryResultDTO<OBJECT> {
+    constructor(pagination: Nullable<OffsetPagination>, total: number, items: KtList<OBJECT>);
+    get pagination(): Nullable<OffsetPagination>;
+    get total(): number;
+    get items(): KtList<OBJECT>;
+    readonly __doNotUseOrImplementIt: PageQueryResultDTO<OBJECT>["__doNotUseOrImplementIt"];
+}
+export declare namespace PageQueryResult {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new <OBJECT>() => PageQueryResult<OBJECT>;
+    }
+}
+export declare interface Pagination {
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.page.Pagination": unique symbol;
+    };
+}
+export declare interface OffsetPaginationDTO extends Pagination {
+    readonly offset: number;
+    readonly limit: number;
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.page.OffsetPaginationDTO": unique symbol;
+    } & Pagination["__doNotUseOrImplementIt"];
+}
+export declare interface PagePaginationDTO extends Pagination {
+    readonly page: Nullable<number>;
+    readonly size: Nullable<number>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.cqrs.page.PagePaginationDTO": unique symbol;
+    } & Pagination["__doNotUseOrImplementIt"];
+}
+export declare class OffsetPagination implements OffsetPaginationDTO {
+    constructor(offset: number, limit: number);
+    get offset(): number;
+    get limit(): number;
+    readonly __doNotUseOrImplementIt: OffsetPaginationDTO["__doNotUseOrImplementIt"];
+}
+export declare namespace OffsetPagination {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => OffsetPagination;
+    }
+}
+export declare class PagePagination implements PagePaginationDTO {
+    constructor(page: Nullable<number>, size: Nullable<number>);
+    get page(): Nullable<number>;
+    get size(): Nullable<number>;
+    readonly __doNotUseOrImplementIt: PagePaginationDTO["__doNotUseOrImplementIt"];
+}
+export declare namespace PagePagination {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => PagePagination;
+    }
+}
+export declare interface AuthedUserDTO {
+    readonly id: string;
+    readonly identifier: Nullable<string>;
+    readonly memberOf: Nullable<string>;
+    readonly roles: Nullable<Array<string>>;
+    readonly acr: Nullable<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.commons.auth.AuthedUserDTO": unique symbol;
+    };
+}
+export declare abstract class ImPermission {
+    private constructor();
+    static get IM_FORCE_MFA_OTP(): ImPermission & {
+        get name(): "IM_FORCE_MFA_OTP";
+        get ordinal(): 0;
+    };
+    static get IM_USER_READ(): ImPermission & {
+        get name(): "IM_USER_READ";
+        get ordinal(): 1;
+    };
+    static get IM_USER_ROLE_READ(): ImPermission & {
+        get name(): "IM_USER_ROLE_READ";
+        get ordinal(): 2;
+    };
+    static get IM_USER_WRITE(): ImPermission & {
+        get name(): "IM_USER_WRITE";
+        get ordinal(): 3;
+    };
+    static get IM_ORGANIZATION_READ(): ImPermission & {
+        get name(): "IM_ORGANIZATION_READ";
+        get ordinal(): 4;
+    };
+    static get IM_ORGANIZATION_WRITE(): ImPermission & {
+        get name(): "IM_ORGANIZATION_WRITE";
+        get ordinal(): 5;
+    };
+    static get IM_MY_ORGANIZATION_WRITE(): ImPermission & {
+        get name(): "IM_MY_ORGANIZATION_WRITE";
+        get ordinal(): 6;
+    };
+    static get IM_ORGANIZATION_API_KEY_READ(): ImPermission & {
+        get name(): "IM_ORGANIZATION_API_KEY_READ";
+        get ordinal(): 7;
+    };
+    static get IM_ORGANIZATION_STATUS_WRITE(): ImPermission & {
+        get name(): "IM_ORGANIZATION_STATUS_WRITE";
+        get ordinal(): 8;
+    };
+    static get IM_APIKEY_READ(): ImPermission & {
+        get name(): "IM_APIKEY_READ";
+        get ordinal(): 9;
+    };
+    static get IM_APIKEY_WRITE(): ImPermission & {
+        get name(): "IM_APIKEY_WRITE";
+        get ordinal(): 10;
+    };
+    static get IM_SPACE_READ(): ImPermission & {
+        get name(): "IM_SPACE_READ";
+        get ordinal(): 11;
+    };
+    static get IM_SPACE_WRITE(): ImPermission & {
+        get name(): "IM_SPACE_WRITE";
+        get ordinal(): 12;
+    };
+    static get IM_ROLE_READ(): ImPermission & {
+        get name(): "IM_ROLE_READ";
+        get ordinal(): 13;
+    };
+    static get IM_ROLE_WRITE(): ImPermission & {
+        get name(): "IM_ROLE_WRITE";
+        get ordinal(): 14;
+    };
+    get name(): "IM_FORCE_MFA_OTP" | "IM_USER_READ" | "IM_USER_ROLE_READ" | "IM_USER_WRITE" | "IM_ORGANIZATION_READ" | "IM_ORGANIZATION_WRITE" | "IM_MY_ORGANIZATION_WRITE" | "IM_ORGANIZATION_API_KEY_READ" | "IM_ORGANIZATION_STATUS_WRITE" | "IM_APIKEY_READ" | "IM_APIKEY_WRITE" | "IM_SPACE_READ" | "IM_SPACE_WRITE" | "IM_ROLE_READ" | "IM_ROLE_WRITE";
+    get ordinal(): 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14;
+    get identifier(): string;
+    static values(): Array<ImPermission>;
+    static valueOf(value: string): ImPermission;
+}
+export declare namespace ImPermission {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => ImPermission;
+    }
+}
+export declare abstract class ExceptionCodes {
+    static readonly getInstance: () => typeof ExceptionCodes.$metadata$.type;
+    private constructor();
+}
+export declare namespace ExceptionCodes {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            privilegeWrongTarget(): number;
+            private constructor();
+        }
+    }
+}
+export declare interface AddressDTO {
+    readonly street: string;
+    readonly postalCode: string;
+    readonly city: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.commons.model.AddressDTO": unique symbol;
+    };
+}
+export declare interface OrganizationDeleteCommandDTO extends Command {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.core.organization.domain.command.OrganizationDeleteCommandDTO": unique symbol;
+    } & Command["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationDeletedEventDTO extends Event {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.core.organization.domain.command.OrganizationDeletedEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare abstract class PrivilegePolicies {
+    static readonly getInstance: () => typeof PrivilegePolicies.$metadata$.type;
+    private constructor();
+}
+export declare namespace PrivilegePolicies {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            canGet(authedUser: AuthedUserDTO): boolean;
+            canList(authedUser: AuthedUserDTO): boolean;
+            canDefine(authedUser: AuthedUserDTO): boolean;
+            private constructor();
+        }
+    }
+}
+export declare interface FeatureDefineCommandDTO {
+    readonly identifier: string;
+    readonly description: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.feature.command.FeatureDefineCommandDTO": unique symbol;
+    };
+}
+export declare interface FeatureDefinedEventDTO extends Event {
+    readonly identifier: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.feature.command.FeatureDefinedEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface FeatureDTO extends PrivilegeDTO {
+    readonly id: string;
+    readonly type: string;
+    readonly identifier: string;
+    readonly description: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.feature.model.FeatureDTO": unique symbol;
+    } & PrivilegeDTO["__doNotUseOrImplementIt"];
+}
+export declare interface FeatureGetQueryDTO {
+    readonly identifier: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.feature.query.FeatureGetQueryDTO": unique symbol;
+    };
+}
+export declare interface FeatureGetResultDTO {
+    readonly item: Nullable<FeatureDTO>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.feature.query.FeatureGetResultDTO": unique symbol;
+    };
+}
+export declare interface FeatureListQueryDTO {
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.feature.query.FeatureListQueryDTO": unique symbol;
+    };
+}
+export declare interface FeatureListResultDTO {
+    readonly items: KtList<FeatureDTO>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.feature.query.FeatureListResultDTO": unique symbol;
+    };
+}
+export declare interface PrivilegeDTO {
+    readonly id: string;
+    readonly identifier: string;
+    readonly description: string;
+    readonly type: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.model.PrivilegeDTO": unique symbol;
+    };
+}
+export declare interface PermissionDefineCommandDTO {
+    readonly identifier: string;
+    readonly description: string;
+    readonly features: Nullable<KtList<KtList<string>>>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.permission.command.PermissionDefineCommandDTO": unique symbol;
+    };
+}
+export declare interface PermissionDefinedEventDTO extends Event {
+    readonly identifier: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.permission.command.PermissionDefinedEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface PermissionDTO extends PrivilegeDTO {
+    readonly id: string;
+    readonly type: string;
+    readonly identifier: string;
+    readonly description: string;
+    readonly features: Nullable<KtList<KtList<string>>>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.permission.model.PermissionDTO": unique symbol;
+    } & PrivilegeDTO["__doNotUseOrImplementIt"];
+}
+export declare interface PermissionGetQueryDTO {
+    readonly identifier: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.permission.query.PermissionGetQueryDTO": unique symbol;
+    };
+}
+export declare interface PermissionGetResultDTO {
+    readonly item: Nullable<PermissionDTO>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.permission.query.PermissionGetResultDTO": unique symbol;
+    };
+}
+export declare interface PermissionListQueryDTO {
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.permission.query.PermissionListQueryDTO": unique symbol;
+    };
+}
+export declare interface PermissionListResultDTO {
+    readonly items: KtList<PermissionDTO>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.permission.query.PermissionListResultDTO": unique symbol;
+    };
+}
+export declare interface RoleDefineCommandDTO {
+    readonly identifier: string;
+    readonly description: string;
+    readonly targets: KtList<string>;
+    readonly locale: KtMap<string, string>;
+    readonly bindings: Nullable<KtMap<string, KtList<string>>>;
+    readonly permissions: Nullable<KtList<string>>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.role.command.RoleDefineCommandDTO": unique symbol;
+    };
+}
+export declare interface RoleDefinedEventDTO extends Event {
+    readonly identifier: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.role.command.RoleDefinedEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface RoleDTO extends PrivilegeDTO {
+    readonly id: string;
+    readonly type: string;
+    readonly identifier: string;
+    readonly description: string;
+    readonly targets: KtList<string>;
+    readonly locale: KtMap<string, string>;
+    readonly bindings: KtMap<string, KtList<RoleDTO>>;
+    readonly permissions: KtList<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.role.model.RoleDTO": unique symbol;
+    } & PrivilegeDTO["__doNotUseOrImplementIt"];
+}
+export declare abstract class RoleTargetValues {
+    static readonly getInstance: () => typeof RoleTargetValues.$metadata$.type;
+    private constructor();
+}
+export declare namespace RoleTargetValues {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            organization(): string;
+            user(): string;
+            apiKey(): string;
+            private constructor();
+        }
+    }
+}
+export declare interface RoleGetQueryDTO {
+    readonly identifier: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.role.query.RoleGetQueryDTO": unique symbol;
+    };
+}
+export declare interface RoleGetResultDTO {
+    readonly item: Nullable<RoleDTO>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.role.query.RoleGetResultDTO": unique symbol;
+    };
+}
+export declare interface RoleListQueryDTO {
+    readonly target: Nullable<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.role.query.RoleListQueryDTO": unique symbol;
+    };
+}
+export declare interface RoleListResultDTO {
+    readonly items: KtList<RoleDTO>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.privilege.domain.role.query.RoleListResultDTO": unique symbol;
+    };
+}
+export declare interface OrganizationCreateCommandDTO extends Command {
+    readonly siret: Nullable<string>;
+    readonly name: string;
+    readonly description: Nullable<string>;
+    readonly address: Nullable<AddressDTO>;
+    readonly website: Nullable<string>;
+    readonly roles: Nullable<KtList<string>>;
+    readonly parentOrganizationId: Nullable<string>;
+    readonly attributes: Nullable<KtMap<string, string>>;
+    readonly status: Nullable<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.command.OrganizationCreateCommandDTO": unique symbol;
+    } & Command["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationCreatedEventDTO extends Event {
+    readonly id: string;
+    readonly parentOrganization: Nullable<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.command.OrganizationCreatedEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationDeleteCommandDTO extends OrganizationDeleteCommandDTO {
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.command.OrganizationDeleteCommandDTO": unique symbol;
+    } & OrganizationDeleteCommandDTO["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationDeletedEventDTO extends Event, OrganizationDeletedEventDTO {
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.command.OrganizationDeletedEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"] & OrganizationDeletedEventDTO["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationDisableCommandDTO extends Command {
+    readonly id: string;
+    readonly disabledBy: Nullable<string>;
+    readonly anonymize: boolean;
+    readonly attributes: Nullable<KtMap<string, string>>;
+    readonly userAttributes: Nullable<KtMap<string, string>>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.command.OrganizationDisableCommandDTO": unique symbol;
+    } & Command["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationDisabledEventDTO extends Event {
+    readonly id: string;
+    readonly userIds: KtList<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.command.OrganizationDisabledEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationUpdateCommandDTO extends Command {
+    readonly id: string;
+    readonly name: string;
+    readonly description: Nullable<string>;
+    readonly address: Nullable<AddressDTO>;
+    readonly website: Nullable<string>;
+    readonly roles: Nullable<KtList<string>>;
+    readonly attributes: Nullable<KtMap<string, string>>;
+    readonly status: Nullable<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.command.OrganizationUpdateCommandDTO": unique symbol;
+    } & Command["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationUpdatedResultDTO extends Event {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.command.OrganizationUpdatedResultDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationUploadLogoCommandDTO extends Command {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.command.OrganizationUploadLogoCommandDTO": unique symbol;
+    } & Command["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationUploadedLogoEventDTO extends Event {
+    readonly id: string;
+    readonly url: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.command.OrganizationUploadedLogoEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationDTO {
+    readonly id: string;
+    readonly siret: Nullable<string>;
+    readonly name: string;
+    readonly description: Nullable<string>;
+    readonly address: Nullable<AddressDTO>;
+    readonly website: Nullable<string>;
+    readonly attributes: KtMap<string, string>;
+    readonly roles: KtList<RoleDTO>;
+    readonly logo: Nullable<string>;
+    readonly enabled: boolean;
+    readonly status: string;
+    readonly disabledBy: Nullable<string>;
+    readonly creationDate: bigint;
+    readonly disabledDate: Nullable<bigint>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.model.OrganizationDTO": unique symbol;
+    };
+}
+export declare interface OrganizationRefDTO {
+    readonly id: string;
+    readonly name: string;
+    readonly roles: KtList<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.model.OrganizationRefDTO": unique symbol;
+    };
+}
+export declare abstract class OrganizationStatusValues {
+    static readonly getInstance: () => typeof OrganizationStatusValues.$metadata$.type;
+    private constructor();
+}
+export declare namespace OrganizationStatusValues {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            pending(): string;
+            validated(): string;
+            rejected(): string;
+            private constructor();
+        }
+    }
+}
+export declare abstract class OrganizationPolicies {
+    static readonly getInstance: () => typeof OrganizationPolicies.$metadata$.type;
+    private constructor();
+}
+export declare namespace OrganizationPolicies {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            canGet(authedUser: AuthedUserDTO, organizationId: string): boolean;
+            canList(authedUser: AuthedUserDTO): boolean;
+            checkRefList(authedUser: Nullable<AuthedUserDTO>): boolean;
+            canCreate(authedUser: AuthedUserDTO): boolean;
+            canUpdate(authedUser: AuthedUserDTO, organizationId: string): boolean;
+            canUpdateStatus(authedUser: AuthedUserDTO): boolean;
+            canDisable(authedUser: AuthedUserDTO): boolean;
+            canDelete(authedUser: AuthedUserDTO): boolean;
+            private constructor();
+        }
+    }
+}
+export declare interface OrganizationGetFromInseeQueryDTO extends Query {
+    readonly siret: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.query.OrganizationGetFromInseeQueryDTO": unique symbol;
+    } & Query["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationGetFromInseeResultDTO extends Event {
+    readonly item: Nullable<OrganizationDTO>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.query.OrganizationGetFromInseeResultDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationGetQueryDTO extends Query {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.query.OrganizationGetQueryDTO": unique symbol;
+    } & Query["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationGetResultDTO extends Event {
+    readonly item: Nullable<OrganizationDTO>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.query.OrganizationGetResultDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationPageQueryDTO extends Query {
+    readonly name: Nullable<string>;
+    readonly role: Nullable<string>;
+    readonly roles: Nullable<KtList<string>>;
+    readonly attributes: Nullable<KtMap<string, string>>;
+    readonly status: Nullable<KtList<string>>;
+    readonly withDisabled: Nullable<boolean>;
+    readonly offset: Nullable<number>;
+    readonly limit: Nullable<number>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.query.OrganizationPageQueryDTO": unique symbol;
+    } & Query["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationPageResultDTO extends PageDTO<OrganizationDTO> {
+    readonly items: KtList<OrganizationDTO>;
+    readonly total: number;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.query.OrganizationPageResultDTO": unique symbol;
+    } & PageDTO<OrganizationDTO>["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationRefGetQueryDTO extends Query {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.query.OrganizationRefGetQueryDTO": unique symbol;
+    } & Query["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationRefGetResultDTO extends Event {
+    readonly item: Nullable<OrganizationRefDTO>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.query.OrganizationRefGetResultDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationRefListQueryDTO extends Query {
+    readonly withDisabled: boolean;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.query.OrganizationRefListQueryDTO": unique symbol;
+    } & Query["__doNotUseOrImplementIt"];
+}
+export declare interface OrganizationRefListResultDTO extends Event {
+    readonly items: KtList<OrganizationRefDTO>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.organization.domain.query.OrganizationRefListResultDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface F2Consumer<T> {
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.fnc.F2Consumer": unique symbol;
+    };
+}
+export declare interface F2Function<T, R> {
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.fnc.F2Function": unique symbol;
+    };
+}
+export declare interface F2Supplier<R> {
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.fnc.F2Supplier": unique symbol;
+    };
+}
+export declare interface F2SupplierSingle<R> {
+    readonly __doNotUseOrImplementIt: {
+        readonly "f2.dsl.fnc.F2SupplierSingle": unique symbol;
+    };
+}
+export declare class Batch {
+    constructor(size?: number, concurrency?: number);
+    get size(): number;
+    get concurrency(): number;
+    copy(size?: number, concurrency?: number): Batch;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace Batch {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => Batch;
+    }
+}
+export declare abstract class AuthRealm {
+    protected constructor(serverUrl: string, realmId: string, clientId: string, redirectUrl: Nullable<string>);
+    get serverUrl(): string;
+    get realmId(): string;
+    get clientId(): string;
+    get redirectUrl(): Nullable<string>;
+}
+export declare namespace AuthRealm {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AuthRealm;
+    }
+}
+export declare class AuthRealmPassword extends AuthRealm.$metadata$.constructor {
+    constructor(serverUrl: string, realmId: string, redirectUrl: string, clientId: string, username: string, password: string);
+    get serverUrl(): string;
+    get realmId(): string;
+    get redirectUrl(): string;
+    get clientId(): string;
+    get username(): string;
+    get password(): string;
+    copy(serverUrl?: string, realmId?: string, redirectUrl?: string, clientId?: string, username?: string, password?: string): AuthRealmPassword;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AuthRealmPassword {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AuthRealmPassword;
+    }
+}
+export declare class AuthRealmClientSecret extends AuthRealm.$metadata$.constructor {
+    constructor(serverUrl: string, realmId: string, clientId: string, redirectUrl: Nullable<string> | undefined, clientSecret: string, isPublic?: boolean);
+    get serverUrl(): string;
+    get realmId(): string;
+    get clientId(): string;
+    get redirectUrl(): Nullable<string>;
+    get clientSecret(): string;
+    get isPublic(): boolean;
+    copy(serverUrl?: string, realmId?: string, clientId?: string, redirectUrl?: Nullable<string>, clientSecret?: string, isPublic?: boolean): AuthRealmClientSecret;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+export declare namespace AuthRealmClientSecret {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        const constructor: abstract new () => AuthRealmClientSecret;
+    }
+}
+export declare interface UserCreateCommandDTO extends Command {
+    readonly email: string;
+    readonly password: Nullable<string>;
+    readonly givenName: string;
+    readonly familyName: string;
+    readonly address: Nullable<AddressDTO>/* Nullable<Address> */;
+    readonly phone: Nullable<string>;
+    readonly roles: KtList<string>;
+    readonly memberOf: Nullable<string>;
+    readonly attributes: Nullable<KtMap<string, string>>;
+    readonly isEmailVerified: boolean;
+    readonly isPasswordTemporary: boolean;
+    readonly sendResetPassword: boolean;
+    readonly sendVerifyEmail: boolean;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserCreateCommandDTO": unique symbol;
+    } & Command["__doNotUseOrImplementIt"];
+}
+export declare interface UserCreatedEventDTO extends Event {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserCreatedEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface UserDeleteCommandDTO extends UserDeleteCommandDTO, Command {
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserDeleteCommandDTO": unique symbol;
+    } & UserDeleteCommandDTO["__doNotUseOrImplementIt"] & Command["__doNotUseOrImplementIt"];
+}
+export declare interface UserDeletedEventDTO extends UserDeletedEventDTO, Event {
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserDeletedEventDTO": unique symbol;
+    } & UserDeletedEventDTO["__doNotUseOrImplementIt"] & Event["__doNotUseOrImplementIt"];
+}
+export declare interface UserDisableCommandDTO extends Command {
+    readonly id: string;
+    readonly disabledBy: Nullable<string>;
+    readonly anonymize: boolean;
+    readonly attributes: Nullable<KtMap<string, string>>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserDisableCommandDTO": unique symbol;
+    } & Command["__doNotUseOrImplementIt"];
+}
+export declare interface UserDisabledEventDTO extends Event {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserDisabledEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface UserDisableMfaCommandDTO extends Command {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserDisableMfaCommandDTO": unique symbol;
+    } & Command["__doNotUseOrImplementIt"];
+}
+export declare interface UserDisabledMfaEventDTO extends Event {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserDisabledMfaEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface UserEnableCommandDTO {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserEnableCommandDTO": unique symbol;
+    };
+}
+export declare interface UserEnabledEventDTO extends Event {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserEnabledEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface UserResetPasswordCommandDTO extends Command {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserResetPasswordCommandDTO": unique symbol;
+    } & Command["__doNotUseOrImplementIt"];
+}
+export declare interface UserResetPasswordEventDTO extends Event {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserResetPasswordEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface UserUpdateCommandDTO extends Command {
+    readonly id: string;
+    readonly givenName: string;
+    readonly familyName: string;
+    readonly address: Nullable<AddressDTO>;
+    readonly phone: Nullable<string>;
+    readonly roles: KtList<string>;
+    readonly memberOf: Nullable<string>;
+    readonly attributes: Nullable<KtMap<string, string>>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserUpdateCommandDTO": unique symbol;
+    } & Command["__doNotUseOrImplementIt"];
+}
+export declare interface UserUpdatedEventDTO extends Event {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserUpdatedEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface UserUpdateEmailCommandDTO extends Command {
+    readonly id: string;
+    readonly email: string;
+    readonly sendVerificationEmail: boolean;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserUpdateEmailCommandDTO": unique symbol;
+    } & Command["__doNotUseOrImplementIt"];
+}
+export declare interface UserUpdatedEmailEventDTO extends Event {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserUpdatedEmailEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface UserUpdatePasswordCommandDTO extends Command {
+    readonly id: string;
+    readonly password: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserUpdatePasswordCommandDTO": unique symbol;
+    } & Command["__doNotUseOrImplementIt"];
+}
+export declare interface UserUpdatedPasswordEventDTO extends Event {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.command.UserUpdatedPasswordEventDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface UserDTO {
+    readonly id: string;
+    readonly memberOf: Nullable<OrganizationRefDTO>;
+    readonly email: string;
+    readonly givenName: string;
+    readonly familyName: string;
+    readonly address: Nullable<AddressDTO>;
+    readonly phone: Nullable<string>;
+    readonly roles: KtList<RoleDTO>;
+    readonly mfa: Nullable<KtList<string>>;
+    readonly attributes: KtMap<string, string>;
+    readonly enabled: boolean;
+    readonly disabledBy: Nullable<string>;
+    readonly creationDate: bigint;
+    readonly disabledDate: Nullable<bigint>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.model.UserDTO": unique symbol;
+    };
+}
+export declare abstract class UserPolicies {
+    static readonly getInstance: () => typeof UserPolicies.$metadata$.type;
+    private constructor();
+}
+export declare namespace UserPolicies {
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace $metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            canGet(authedUser: AuthedUserDTO, user: Nullable<UserDTO>): boolean;
+            canPage(authedUser: AuthedUserDTO): boolean;
+            checkRefList(authedUser: AuthedUserDTO): boolean;
+            canCreate(authedUser: AuthedUserDTO, organizationId: Nullable<string>): boolean;
+            canUpdate(authedUser: AuthedUserDTO, user: UserDTO): boolean;
+            canConfigureMfa(authedUser: AuthedUserDTO, user: UserDTO): boolean;
+            canDisableMfa(authedUser: AuthedUserDTO, user: UserDTO): boolean;
+            canDisableMfaAcr(authedUser: AuthedUserDTO, user: UserDTO): boolean;
+            canUpdateMemberOf(authedUser: AuthedUserDTO): boolean;
+            canUpdateRole(authedUser: AuthedUserDTO): boolean;
+            canDisable(authedUser: AuthedUserDTO, user: UserDTO): boolean;
+            canEnable(authedUser: AuthedUserDTO, user: UserDTO): boolean;
+            canDelete(authedUser: AuthedUserDTO, user: UserDTO): boolean;
+            private constructor();
+        }
+    }
+}
+export declare interface UserExistsByEmailQueryDTO extends Query {
+    readonly email: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.query.UserExistsByEmailQueryDTO": unique symbol;
+    } & Query["__doNotUseOrImplementIt"];
+}
+export declare interface UserExistsByEmailResultDTO extends Event {
+    readonly item: boolean;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.query.UserExistsByEmailResultDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface UserGetByEmailQueryDTO extends Query {
+    readonly email: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.query.UserGetByEmailQueryDTO": unique symbol;
+    } & Query["__doNotUseOrImplementIt"];
+}
+export declare interface UserGetByEmailResultDTO extends Event {
+    readonly item: Nullable<UserDTO>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.query.UserGetByEmailResultDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface UserGetQueryDTO extends Query {
+    readonly id: string;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.query.UserGetQueryDTO": unique symbol;
+    } & Query["__doNotUseOrImplementIt"];
+}
+export declare interface UserGetResultDTO extends Event {
+    readonly item: Nullable<UserDTO>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.query.UserGetResultDTO": unique symbol;
+    } & Event["__doNotUseOrImplementIt"];
+}
+export declare interface UserPageQueryDTO extends Query {
+    readonly organizationId: Nullable<string>;
+    readonly organizationName: Nullable<string>;
+    readonly name: Nullable<string>;
+    readonly email: Nullable<string>;
+    readonly role: Nullable<string>;
+    readonly roles: Nullable<KtList<string>>;
+    readonly attributes: Nullable<KtMap<string, string>>;
+    readonly withDisabled: boolean;
+    readonly offset: Nullable<number>;
+    readonly limit: Nullable<number>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.query.UserPageQueryDTO": unique symbol;
+    } & Query["__doNotUseOrImplementIt"];
+}
+export declare interface UserPageResultDTO extends PageDTO<UserDTO> {
+    readonly items: KtList<UserDTO>;
+    readonly total: number;
+    readonly __doNotUseOrImplementIt: {
+        readonly "io.komune.im.f2.user.domain.query.UserPageResultDTO": unique symbol;
+    } & PageDTO<UserDTO>["__doNotUseOrImplementIt"];
+}