@komune-io/im-user-domain 0.24.0-alpha.f3d42d4 → 0.27.0-alpha.16005bb

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

@@ -1,34 +1,21 @@
-type Nullable<T> = T | null | undefined
 declare function KtSingleton<T>(): T & (abstract new() => any);
-export declare interface KtList<E> /* extends Collection<E> */ {
+export declare interface out 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>;
+    function fromJsArray<E>(array: ReadonlyArray<E>): E[];
 }
-export declare interface KtMap<K, V> {
+export declare interface Record<K, out 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 namespace Record {
+    function fromJsMap<K, V>(map: ReadonlyMap<K, V>): Record<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();
@@ -40,12 +27,12 @@ export declare abstract class ImMfaPasswordOtpFlowAcr {
         get name(): "PASSWORD_OTP";
         get ordinal(): 1;
     };
+    static values(): [typeof ImMfaPasswordOtpFlowAcr.PASSWORD_ONLY, typeof ImMfaPasswordOtpFlowAcr.PASSWORD_OTP];
+    static valueOf(value: string): ImMfaPasswordOtpFlowAcr;
     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 */
@@ -59,55 +46,40 @@ 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$ {
             abstract class constructor {
-                asKeycloakMap(): KtMap<string, string>;
+                asKeycloakMap(): Record<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> */ {
+export declare interface EnvelopeDTO<T> extends WithEnvelopeId, WithEnvelopeData<T>, Message {
+    readonly id: string;
+    readonly data: 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"];
+    readonly datacontenttype?: string;
+    readonly specversion?: string;
+    readonly source?: string;
+    readonly time?: string;
 }
 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>);
+    constructor(id: string, data: T, type: string, datacontenttype?: string, specversion?: string, source?: string, time?: string);
+    get id(): string;
+    get data(): T;
     get type(): string;
-    get datacontenttype(): Nullable<string>;
-    get specversion(): Nullable<string>;
-    get source(): Nullable<string>;
-    get time(): Nullable<string>;
-    readonly __doNotUseOrImplementIt: EnvelopeDTO<T>["__doNotUseOrImplementIt"];
+    get datacontenttype(): string | undefined;
+    get specversion(): string | undefined;
+    get source(): string | undefined;
+    get time(): string | undefined;
 }
 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 */
@@ -127,25 +99,27 @@ export declare namespace Envelope {
         }
     }
 }
+export declare interface WithEnvelopeData<T> {
+    readonly data: T;
+}
+export declare interface WithEnvelopeId {
+    readonly id: string;
+}
 export declare interface F2ErrorDTO extends Problem {
-    readonly id: Nullable<string>;
+    readonly id?: string;
     readonly timestamp: string;
     readonly code: number;
-    readonly requestId: Nullable<string>;
+    readonly requestId?: 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>);
+    constructor(message: string, id?: string, timestamp?: string, code?: number, requestId?: string);
     get message(): string;
-    get id(): Nullable<string>;
+    get id(): string | undefined;
     get timestamp(): string;
     get code(): number;
-    get requestId(): Nullable<string>;
+    get requestId(): string | undefined;
     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 */
@@ -154,7 +128,7 @@ export declare namespace F2Error {
     }
 }
 export declare class F2Exception extends /* RuntimeException */ Error {
-    constructor(error: F2ErrorDTO, cause?: Nullable<Error>);
+    constructor(error: F2ErrorDTO, cause?: Error);
     get error(): F2ErrorDTO;
 }
 export declare namespace F2Exception {
@@ -169,7 +143,7 @@ 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$ {
             abstract class constructor {
-                invoke(message: string, id?: string, requestId?: string, code?: number, cause?: Nullable<Error>): F2Exception;
+                invoke(message: string, id?: string, requestId?: string, code?: number, cause?: Error): F2Exception;
                 private constructor();
             }
         }
@@ -177,34 +151,24 @@ export declare namespace F2Exception {
 }
 export declare interface Match<T> {
     readonly negative: boolean;
-    map<R>(transform: (p0: T) => R): Match<R>;
+    map<R>(transform: (value: 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;
-    };
+    readonly nullsFirst?: boolean;
 }
-export declare interface PageDTO<OBJECT> {
+export declare interface PageDTO<out OBJECT> {
     readonly total: number;
-    readonly items: KtList<OBJECT>;
-    readonly __doNotUseOrImplementIt: {
-        readonly "f2.dsl.cqrs.page.PageDTO": unique symbol;
-    };
+    readonly items: OBJECT[];
 }
-export declare class Page<OBJECT> implements PageDTO<OBJECT> {
-    constructor(total: number, items: KtList<OBJECT>);
+export declare class Page<out OBJECT> implements PageDTO<OBJECT> {
+    constructor(total: number, items: OBJECT[]);
     get total(): number;
-    get items(): KtList<OBJECT>;
-    readonly __doNotUseOrImplementIt: PageDTO<OBJECT>["__doNotUseOrImplementIt"];
+    get items(): OBJECT[];
 }
 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 */
@@ -213,23 +177,16 @@ export declare namespace Page {
     }
 }
 export declare interface PageQueryDTO extends Query {
-    readonly pagination: Nullable<OffsetPaginationDTO>;
-    readonly __doNotUseOrImplementIt: {
-        readonly "f2.dsl.cqrs.page.PageQueryDTO": unique symbol;
-    } & Query["__doNotUseOrImplementIt"];
+    readonly pagination?: OffsetPaginationDTO;
 }
-export declare interface PageQueryResultDTO<OBJECT> extends Event, PageDTO<OBJECT> {
+export declare interface PageQueryResultDTO<out 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"];
+    readonly items: OBJECT[];
+    readonly pagination?: OffsetPaginationDTO;
 }
 export declare class PageQuery implements PageQueryDTO {
-    constructor(pagination: Nullable<OffsetPaginationDTO>);
-    get pagination(): Nullable<OffsetPaginationDTO>;
-    readonly __doNotUseOrImplementIt: PageQueryDTO["__doNotUseOrImplementIt"];
+    constructor(pagination?: OffsetPaginationDTO);
+    get pagination(): OffsetPaginationDTO | undefined;
 }
 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 */
@@ -237,12 +194,11 @@ export declare namespace PageQuery {
         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>;
+export declare class PageQueryResult<out OBJECT> implements PageQueryResultDTO<OBJECT> {
+    constructor(pagination?: OffsetPagination, total: number, items: OBJECT[]);
+    get pagination(): OffsetPagination | undefined;
     get total(): number;
-    get items(): KtList<OBJECT>;
-    readonly __doNotUseOrImplementIt: PageQueryResultDTO<OBJECT>["__doNotUseOrImplementIt"];
+    get items(): OBJECT[];
 }
 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 */
@@ -251,29 +207,19 @@ export declare namespace PageQueryResult {
     }
 }
 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"];
+    readonly page?: number;
+    readonly size?: number;
 }
 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 */
@@ -282,10 +228,9 @@ export declare namespace 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"];
+    constructor(page?: number, size?: number);
+    get page(): number | undefined;
+    get size(): number | undefined;
 }
 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 */
@@ -295,13 +240,10 @@ export declare namespace 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;
-    };
+    readonly identifier?: string;
+    readonly memberOf?: string;
+    readonly roles?: Array<string>;
+    readonly acr?: string;
 }
 export declare abstract class ImPermission {
     private constructor();
@@ -313,8 +255,8 @@ export declare abstract class ImPermission {
         get name(): "IM_USER_READ";
         get ordinal(): 1;
     };
-    static get IM_USER_ROLE_READ(): ImPermission & {
-        get name(): "IM_USER_ROLE_READ";
+    static get IM_USER_ROLE_WRITE(): ImPermission & {
+        get name(): "IM_USER_ROLE_WRITE";
         get ordinal(): 2;
     };
     static get IM_USER_WRITE(): ImPermission & {
@@ -365,11 +307,11 @@ export declare abstract class 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";
+    static values(): [typeof ImPermission.IM_FORCE_MFA_OTP, typeof ImPermission.IM_USER_READ, typeof ImPermission.IM_USER_ROLE_WRITE, typeof ImPermission.IM_USER_WRITE, typeof ImPermission.IM_ORGANIZATION_READ, typeof ImPermission.IM_ORGANIZATION_WRITE, typeof ImPermission.IM_MY_ORGANIZATION_WRITE, typeof ImPermission.IM_ORGANIZATION_API_KEY_READ, typeof ImPermission.IM_ORGANIZATION_STATUS_WRITE, typeof ImPermission.IM_APIKEY_READ, typeof ImPermission.IM_APIKEY_WRITE, typeof ImPermission.IM_SPACE_READ, typeof ImPermission.IM_SPACE_WRITE, typeof ImPermission.IM_ROLE_READ, typeof ImPermission.IM_ROLE_WRITE];
+    static valueOf(value: string): ImPermission;
+    get name(): "IM_FORCE_MFA_OTP" | "IM_USER_READ" | "IM_USER_ROLE_WRITE" | "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 */
@@ -397,21 +339,12 @@ 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;
@@ -434,133 +367,79 @@ export declare namespace PrivilegePolicies {
 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;
-    };
+    readonly item?: FeatureDTO;
 }
 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;
-    };
+    readonly items: FeatureDTO[];
 }
 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;
-    };
+    readonly features?: string[][];
 }
 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"];
+    readonly features?: string[][];
 }
 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;
-    };
+    readonly item?: PermissionDTO;
 }
 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;
-    };
+    readonly items: PermissionDTO[];
 }
 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;
-    };
+    readonly targets: string[];
+    readonly locale: Record<string, string>;
+    readonly bindings?: Record<string, string[]>;
+    readonly permissions?: string[];
 }
 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"];
+    readonly targets: string[];
+    readonly locale: Record<string, string>;
+    readonly bindings: Record<string, RoleDTO[]>;
+    readonly permissions: string[];
 }
 export declare abstract class RoleTargetValues {
     static readonly getInstance: () => typeof RoleTargetValues.$metadata$.type;
@@ -582,134 +461,86 @@ export declare namespace RoleTargetValues {
 }
 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;
-    };
+    readonly item?: RoleDTO;
 }
 export declare interface RoleListQueryDTO {
-    readonly target: Nullable<string>;
-    readonly __doNotUseOrImplementIt: {
-        readonly "io.komune.im.f2.privilege.domain.role.query.RoleListQueryDTO": unique symbol;
-    };
+    readonly target?: string;
 }
 export declare interface RoleListResultDTO {
-    readonly items: KtList<RoleDTO>;
-    readonly __doNotUseOrImplementIt: {
-        readonly "io.komune.im.f2.privilege.domain.role.query.RoleListResultDTO": unique symbol;
-    };
+    readonly items: RoleDTO[];
 }
 export declare interface OrganizationCreateCommandDTO extends Command {
-    readonly siret: Nullable<string>;
+    readonly siret?: 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"];
+    readonly description?: string;
+    readonly address?: AddressDTO;
+    readonly website?: string;
+    readonly roles?: string[];
+    readonly parentOrganizationId?: string;
+    readonly attributes?: Record<string, string>;
+    readonly status?: string;
 }
 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"];
+    readonly parentOrganization?: string;
 }
 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 disabledBy?: 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"];
+    readonly attributes?: Record<string, string>;
+    readonly userAttributes?: Record<string, string>;
 }
 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"];
+    readonly userIds: string[];
 }
 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"];
+    readonly description?: string;
+    readonly address?: AddressDTO;
+    readonly website?: string;
+    readonly roles?: string[];
+    readonly attributes?: Record<string, string>;
+    readonly status?: string;
 }
 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 siret?: 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 description?: string;
+    readonly address?: AddressDTO;
+    readonly website?: string;
+    readonly attributes: Record<string, string>;
+    readonly roles: RoleDTO[];
+    readonly logo?: 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;
-    };
+    readonly disabledBy?: string;
+    readonly creationDate: number;
+    readonly disabledDate?: number;
 }
 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;
-    };
+    readonly roles: string[];
 }
 export declare abstract class OrganizationStatusValues {
     static readonly getInstance: () => typeof OrganizationStatusValues.$metadata$.type;
@@ -742,7 +573,7 @@ export declare namespace OrganizationPolicies {
         abstract class constructor {
             canGet(authedUser: AuthedUserDTO, organizationId: string): boolean;
             canList(authedUser: AuthedUserDTO): boolean;
-            checkRefList(authedUser: Nullable<AuthedUserDTO>): boolean;
+            checkRefList(authedUser?: AuthedUserDTO): boolean;
             canCreate(authedUser: AuthedUserDTO): boolean;
             canUpdate(authedUser: AuthedUserDTO, organizationId: string): boolean;
             canUpdateStatus(authedUser: AuthedUserDTO): boolean;
@@ -754,91 +585,49 @@ export declare namespace OrganizationPolicies {
 }
 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"];
+    readonly item?: OrganizationDTO;
 }
 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"];
+    readonly item?: OrganizationDTO;
 }
 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"];
+    readonly name?: string;
+    readonly role?: string;
+    readonly roles?: string[];
+    readonly attributes?: Record<string, string>;
+    readonly status?: string[];
+    readonly withDisabled?: boolean;
+    readonly offset?: number;
+    readonly limit?: number;
 }
 export declare interface OrganizationPageResultDTO extends PageDTO<OrganizationDTO> {
-    readonly items: KtList<OrganizationDTO>;
+    readonly items: 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"];
+    readonly item?: OrganizationRefDTO;
 }
 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"];
+    readonly items: OrganizationRefDTO[];
 }
 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 F2Function<in T, out R> {
 }
 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);
@@ -847,7 +636,7 @@ export declare class Batch {
     copy(size?: number, concurrency?: number): Batch;
     toString(): string;
     hashCode(): number;
-    equals(other: Nullable<any>): boolean;
+    equals(other?: 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 */
@@ -856,11 +645,11 @@ export declare namespace Batch {
     }
 }
 export declare abstract class AuthRealm {
-    protected constructor(serverUrl: string, realmId: string, clientId: string, redirectUrl: Nullable<string>);
+    private constructor();
     get serverUrl(): string;
     get realmId(): string;
     get clientId(): string;
-    get redirectUrl(): Nullable<string>;
+    get redirectUrl(): string | undefined;
 }
 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 */
@@ -879,7 +668,7 @@ export declare class AuthRealmPassword extends AuthRealm.$metadata$.constructor
     copy(serverUrl?: string, realmId?: string, redirectUrl?: string, clientId?: string, username?: string, password?: string): AuthRealmPassword;
     toString(): string;
     hashCode(): number;
-    equals(other: Nullable<any>): boolean;
+    equals(other?: 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 */
@@ -888,17 +677,17 @@ export declare namespace AuthRealmPassword {
     }
 }
 export declare class AuthRealmClientSecret extends AuthRealm.$metadata$.constructor {
-    constructor(serverUrl: string, realmId: string, clientId: string, redirectUrl: Nullable<string> | undefined, clientSecret: string, isPublic?: boolean);
+    constructor(serverUrl: string, realmId: string, clientId: string, redirectUrl?: string | undefined, clientSecret: string, isPublic?: boolean);
     get serverUrl(): string;
     get realmId(): string;
     get clientId(): string;
-    get redirectUrl(): Nullable<string>;
+    get redirectUrl(): string | undefined;
     get clientSecret(): string;
     get isPublic(): boolean;
-    copy(serverUrl?: string, realmId?: string, clientId?: string, redirectUrl?: Nullable<string>, clientSecret?: string, isPublic?: boolean): AuthRealmClientSecret;
+    copy(serverUrl?: string, realmId?: string, clientId?: string, redirectUrl?: string, clientSecret?: string, isPublic?: boolean): AuthRealmClientSecret;
     toString(): string;
     hashCode(): number;
-    equals(other: Nullable<any>): boolean;
+    equals(other?: 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 */
@@ -906,155 +695,118 @@ export declare namespace AuthRealmClientSecret {
         const constructor: abstract new () => AuthRealmClientSecret;
     }
 }
+export declare class TokenInfo {
+    constructor(accessToken: string, expiresIn: number, refreshExpiresIn?: number | undefined, tokenType: string, scope?: string, idToken?: string, refreshToken?: string);
+    get accessToken(): string;
+    get expiresIn(): number;
+    get refreshExpiresIn(): number | undefined;
+    get tokenType(): string;
+    get scope(): string | undefined;
+    get idToken(): string | undefined;
+    get refreshToken(): string | undefined;
+    copy(accessToken?: string, expiresIn?: number, refreshExpiresIn?: number, tokenType?: string, scope?: string, idToken?: string, refreshToken?: string): TokenInfo;
+    toString(): string;
+    hashCode(): number;
+    equals(other?: any): boolean;
+}
+export declare namespace TokenInfo {
+    /** @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 () => TokenInfo;
+    }
+}
 export declare interface UserCreateCommandDTO extends Command {
     readonly email: string;
-    readonly password: Nullable<string>;
+    readonly password?: 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 address?: AddressDTO/* Nullable<Address> */;
+    readonly phone?: string;
+    readonly roles: string[];
+    readonly memberOf?: string;
+    readonly attributes?: Record<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 disabledBy?: 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"];
+    readonly attributes?: Record<string, string>;
 }
 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"];
+    readonly address?: AddressDTO;
+    readonly phone?: string;
+    readonly roles: string[];
+    readonly memberOf?: string;
+    readonly attributes?: Record<string, string>;
 }
 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 memberOf?: 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 address?: AddressDTO;
+    readonly phone?: string;
+    readonly roles: RoleDTO[];
+    readonly mfa?: string[];
+    readonly attributes: Record<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;
-    };
+    readonly disabledBy?: string;
+    readonly creationDate: number;
+    readonly disabledDate?: number;
 }
 export declare abstract class UserPolicies {
     static readonly getInstance: () => typeof UserPolicies.$metadata$.type;
@@ -1067,10 +819,10 @@ export declare namespace UserPolicies {
             private constructor();
         }
         abstract class constructor {
-            canGet(authedUser: AuthedUserDTO, user: Nullable<UserDTO>): boolean;
+            canGet(authedUser: AuthedUserDTO, user?: UserDTO): boolean;
             canPage(authedUser: AuthedUserDTO): boolean;
             checkRefList(authedUser: AuthedUserDTO): boolean;
-            canCreate(authedUser: AuthedUserDTO, organizationId: Nullable<string>): boolean;
+            canCreate(authedUser: AuthedUserDTO, organizationId?: string): boolean;
             canUpdate(authedUser: AuthedUserDTO, user: UserDTO): boolean;
             canConfigureMfa(authedUser: AuthedUserDTO, user: UserDTO): boolean;
             canDisableMfa(authedUser: AuthedUserDTO, user: UserDTO): boolean;
@@ -1086,59 +838,35 @@ export declare namespace UserPolicies {
 }
 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"];
+    readonly item?: UserDTO;
 }
 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"];
+    readonly item?: UserDTO;
 }
 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 organizationId?: string;
+    readonly organizationName?: string;
+    readonly name?: string;
+    readonly email?: string;
+    readonly role?: string;
+    readonly roles?: string[];
+    readonly attributes?: Record<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"];
+    readonly offset?: number;
+    readonly limit?: number;
 }
 export declare interface UserPageResultDTO extends PageDTO<UserDTO> {
-    readonly items: KtList<UserDTO>;
+    readonly items: UserDTO[];
     readonly total: number;
-    readonly __doNotUseOrImplementIt: {
-        readonly "io.komune.im.f2.user.domain.query.UserPageResultDTO": unique symbol;
-    } & PageDTO<UserDTO>["__doNotUseOrImplementIt"];
 }