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

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

@@ -0,0 +1,633 @@
+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 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 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 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 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 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;
+    };
+}