@komune-io/im-space-domain 0.19.0-alpha.ddb2e67 → 0.19.0-alpha.f340596

package/connect-im-im-f2-space-im-space-domain.d.ts

@@ -1,72 +1,94 @@
+type Nullable<T> = T | null | undefined
 export declare namespace f2.dsl.cqrs {
     interface Command extends f2.dsl.cqrs.Message {
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.cqrs.Command": unique symbol;
+        } & f2.dsl.cqrs.Message["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace f2.dsl.cqrs {
     interface Event extends f2.dsl.cqrs.Message {
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.cqrs.Event": unique symbol;
+        } & f2.dsl.cqrs.Message["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace f2.dsl.cqrs {
     interface Message {
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.cqrs.Message": unique symbol;
+        };
     }
 }
 export declare namespace f2.dsl.cqrs {
     interface Problem extends f2.dsl.cqrs.Message {
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.cqrs.Problem": unique symbol;
+        } & f2.dsl.cqrs.Message["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace f2.dsl.cqrs {
     interface Query extends f2.dsl.cqrs.Message {
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.cqrs.Query": unique symbol;
+        } & f2.dsl.cqrs.Message["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace f2.dsl.cqrs.envelope {
     interface EnvelopeDTO<T> /* extends f2.dsl.cqrs.envelope.WithEnvelopeId, f2.dsl.cqrs.envelope.WithEnvelopeData<T> */ {
         readonly type: string;
-        readonly datacontenttype?: string;
-        readonly specversion?: string;
-        readonly source?: string;
-        readonly time?: 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;
+        };
     }
     class Envelope<T> implements f2.dsl.cqrs.envelope.EnvelopeDTO<T> {
-        constructor(id: string, data: T, type: string, datacontenttype?: string, specversion?: string, source?: string, time?: string);
+        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: f2.dsl.cqrs.envelope.EnvelopeDTO<T>["__doNotUseOrImplementIt"];
+        static get Companion(): {
+            get $cachedDescriptor(): any/* kotlinx.serialization.descriptors.SerialDescriptor */;
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
 export declare namespace f2.dsl.cqrs.error {
     interface F2ErrorDTO extends f2.dsl.cqrs.Problem {
-        readonly id?: string;
+        readonly id: Nullable<string>;
         readonly timestamp: string;
         readonly code: number;
-        readonly requestId?: string;
+        readonly requestId: Nullable<string>;
         readonly message: string;
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.cqrs.error.F2ErrorDTO": unique symbol;
+        } & f2.dsl.cqrs.Problem["__doNotUseOrImplementIt"];
     }
     class F2Error implements f2.dsl.cqrs.error.F2ErrorDTO {
-        constructor(message: string, id?: string, timestamp?: string, code?: number, requestId?: string);
+        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: f2.dsl.cqrs.error.F2ErrorDTO["__doNotUseOrImplementIt"];
+        static get Companion(): {
+        };
     }
 }
 export declare namespace f2.dsl.cqrs.exception {
     class F2Exception /* extends kotlin.RuntimeException */ {
-        constructor(error: f2.dsl.cqrs.error.F2ErrorDTO, cause?: Error);
+        constructor(error: f2.dsl.cqrs.error.F2ErrorDTO, cause?: Nullable<Error>);
         get error(): f2.dsl.cqrs.error.F2ErrorDTO;
-        
+        static get Companion(): {
+            invoke(message: string, id?: string, requestId?: string, code?: number, cause?: Nullable<Error>): f2.dsl.cqrs.exception.F2Exception;
+        };
     }
 }
 export declare namespace f2.dsl.cqrs.filter {
@@ -76,84 +98,112 @@ export declare namespace f2.dsl.cqrs.filter {
         not(): f2.dsl.cqrs.filter.Match<T>;
         and(match: f2.dsl.cqrs.filter.Match<T>): f2.dsl.cqrs.filter.Match<T>;
         or(match: f2.dsl.cqrs.filter.Match<T>): f2.dsl.cqrs.filter.Match<T>;
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.cqrs.filter.Match": unique symbol;
+        };
     }
 }
 export declare namespace f2.dsl.cqrs.filter {
     interface SortDTO {
         readonly property: string;
         readonly ascending: boolean;
-        readonly nullsFirst?: boolean;
-
+        readonly nullsFirst: Nullable<boolean>;
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.cqrs.filter.SortDTO": unique symbol;
+        };
     }
 }
 export declare namespace f2.dsl.cqrs.page {
     interface PageDTO<OBJECT> {
         readonly total: number;
-        readonly items: OBJECT[];
-
+        readonly items: any/* kotlin.collections.List<OBJECT> */;
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.cqrs.page.PageDTO": unique symbol;
+        };
     }
     class Page<OBJECT> implements f2.dsl.cqrs.page.PageDTO<OBJECT> {
-        constructor(total: number, items: OBJECT[]);
+        constructor(total: number, items: any/* kotlin.collections.List<OBJECT> */);
         get total(): number;
-        get items(): OBJECT[];
-        
+        get items(): any/* kotlin.collections.List<OBJECT> */;
+        readonly __doNotUseOrImplementIt: f2.dsl.cqrs.page.PageDTO<OBJECT>["__doNotUseOrImplementIt"];
+        static get Companion(): {
+            get $cachedDescriptor(): any/* kotlinx.serialization.descriptors.SerialDescriptor */;
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
 export declare namespace f2.dsl.cqrs.page {
     interface PageQueryDTO extends f2.dsl.cqrs.Query {
-        readonly pagination?: f2.dsl.cqrs.page.OffsetPaginationDTO;
-
+        readonly pagination: Nullable<f2.dsl.cqrs.page.OffsetPaginationDTO>;
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.cqrs.page.PageQueryDTO": unique symbol;
+        } & f2.dsl.cqrs.Query["__doNotUseOrImplementIt"];
     }
     interface PageQueryResultDTO<OBJECT> extends f2.dsl.cqrs.Event, f2.dsl.cqrs.page.PageDTO<OBJECT> {
         readonly total: number;
-        readonly items: OBJECT[];
-        readonly pagination?: f2.dsl.cqrs.page.OffsetPaginationDTO;
-
+        readonly items: any/* kotlin.collections.List<OBJECT> */;
+        readonly pagination: Nullable<f2.dsl.cqrs.page.OffsetPaginationDTO>;
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.cqrs.page.PageQueryResultDTO": unique symbol;
+        } & f2.dsl.cqrs.Event["__doNotUseOrImplementIt"] & f2.dsl.cqrs.page.PageDTO<OBJECT>["__doNotUseOrImplementIt"];
     }
     class PageQuery implements f2.dsl.cqrs.page.PageQueryDTO {
-        constructor(pagination?: f2.dsl.cqrs.page.OffsetPaginationDTO);
+        constructor(pagination: Nullable<f2.dsl.cqrs.page.OffsetPaginationDTO>);
         get pagination(): Nullable<f2.dsl.cqrs.page.OffsetPaginationDTO>;
-        
+        readonly __doNotUseOrImplementIt: f2.dsl.cqrs.page.PageQueryDTO["__doNotUseOrImplementIt"];
+        static get Companion(): {
+        };
     }
     class PageQueryResult<OBJECT> implements f2.dsl.cqrs.page.PageQueryResultDTO<OBJECT> {
-        constructor(pagination?: f2.dsl.cqrs.page.OffsetPagination, total: number, items: OBJECT[]);
+        constructor(pagination: Nullable<f2.dsl.cqrs.page.OffsetPagination>, total: number, items: any/* kotlin.collections.List<OBJECT> */);
         get pagination(): Nullable<f2.dsl.cqrs.page.OffsetPagination>;
         get total(): number;
-        get items(): OBJECT[];
-        
+        get items(): any/* kotlin.collections.List<OBJECT> */;
+        readonly __doNotUseOrImplementIt: f2.dsl.cqrs.page.PageQueryResultDTO<OBJECT>["__doNotUseOrImplementIt"];
+        static get Companion(): {
+            get $cachedDescriptor(): any/* kotlinx.serialization.descriptors.SerialDescriptor */;
+        } & any/* kotlinx.serialization.internal.SerializerFactory */;
     }
 }
 export declare namespace f2.dsl.cqrs.page {
     interface Pagination {
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.cqrs.page.Pagination": unique symbol;
+        };
     }
     interface OffsetPaginationDTO extends f2.dsl.cqrs.page.Pagination {
         readonly offset: number;
         readonly limit: number;
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.cqrs.page.OffsetPaginationDTO": unique symbol;
+        } & f2.dsl.cqrs.page.Pagination["__doNotUseOrImplementIt"];
     }
     interface PagePaginationDTO extends f2.dsl.cqrs.page.Pagination {
-        readonly page?: number;
-        readonly size?: number;
-
+        readonly page: Nullable<number>;
+        readonly size: Nullable<number>;
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.cqrs.page.PagePaginationDTO": unique symbol;
+        } & f2.dsl.cqrs.page.Pagination["__doNotUseOrImplementIt"];
     }
     class OffsetPagination implements f2.dsl.cqrs.page.OffsetPaginationDTO {
         constructor(offset: number, limit: number);
         get offset(): number;
         get limit(): number;
-        
+        readonly __doNotUseOrImplementIt: f2.dsl.cqrs.page.OffsetPaginationDTO["__doNotUseOrImplementIt"];
+        static get Companion(): {
+        };
     }
     class PagePagination implements f2.dsl.cqrs.page.PagePaginationDTO {
-        constructor(page?: number, size?: number);
+        constructor(page: Nullable<number>, size: Nullable<number>);
         get page(): Nullable<number>;
         get size(): Nullable<number>;
-        
+        readonly __doNotUseOrImplementIt: f2.dsl.cqrs.page.PagePaginationDTO["__doNotUseOrImplementIt"];
+        static get Companion(): {
+        };
     }
 }
 export declare namespace f2.client.domain {
     abstract class AuthRealm {
-        protected constructor(serverUrl: string, realmId: string, clientId: string, redirectUrl?: string);
+        protected constructor(serverUrl: string, realmId: string, clientId: string, redirectUrl: Nullable<string>);
         get serverUrl(): string;
         get realmId(): string;
         get clientId(): string;
@@ -170,33 +220,98 @@ export declare namespace f2.client.domain {
         copy(serverUrl?: string, realmId?: string, redirectUrl?: string, clientId?: string, username?: string, password?: string): f2.client.domain.AuthRealmPassword;
         toString(): string;
         hashCode(): number;
-        equals(other?: any): boolean;
+        equals(other: Nullable<any>): boolean;
     }
     class AuthRealmClientSecret extends f2.client.domain.AuthRealm {
-        constructor(serverUrl: string, realmId: string, clientId: string, redirectUrl?: string | undefined, clientSecret: string, isPublic?: boolean);
+        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?: string, clientSecret?: string, isPublic?: boolean): f2.client.domain.AuthRealmClientSecret;
+        copy(serverUrl?: string, realmId?: string, clientId?: string, redirectUrl?: Nullable<string>, clientSecret?: string, isPublic?: boolean): f2.client.domain.AuthRealmClientSecret;
         toString(): string;
         hashCode(): number;
-        equals(other?: any): boolean;
+        equals(other: Nullable<any>): boolean;
     }
 }
 export declare namespace io.komune.im.commons.auth {
     interface AuthedUserDTO {
         readonly id: string;
-        readonly identifier?: string;
-        readonly memberOf?: string;
+        readonly identifier: Nullable<string>;
+        readonly memberOf: Nullable<string>;
         readonly roles: Array<string>;
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.komune.im.commons.auth.AuthedUserDTO": unique symbol;
+        };
     }
 }
 export declare namespace io.komune.im.commons.auth {
-    type ImRole = "ORCHESTRATOR" | "ORCHESTRATOR_ADMIN" | "ORCHESTRATOR_USER" | "IM_USER_READ" | "IM_USER_WRITE" | "IM_ORGANIZATION_READ" | "IM_ORGANIZATION_WRITE" | "IM_MY_ORGANIZATION_WRITE" | "IM_APIKEY_READ" | "IM_APIKEY_WRITE" | "IM_SPACE_READ" | "IM_SPACE_WRITE" | "IM_ROLE_READ" | "IM_ROLE_WRITE";
+    abstract class ImRole {
+        private constructor();
+        get identifier(): string;
+        static get ORCHESTRATOR(): io.komune.im.commons.auth.ImRole & {
+            get name(): "ORCHESTRATOR";
+            get ordinal(): 0;
+        };
+        static get ORCHESTRATOR_ADMIN(): io.komune.im.commons.auth.ImRole & {
+            get name(): "ORCHESTRATOR_ADMIN";
+            get ordinal(): 1;
+        };
+        static get ORCHESTRATOR_USER(): io.komune.im.commons.auth.ImRole & {
+            get name(): "ORCHESTRATOR_USER";
+            get ordinal(): 2;
+        };
+        static get IM_USER_READ(): io.komune.im.commons.auth.ImRole & {
+            get name(): "IM_USER_READ";
+            get ordinal(): 3;
+        };
+        static get IM_USER_WRITE(): io.komune.im.commons.auth.ImRole & {
+            get name(): "IM_USER_WRITE";
+            get ordinal(): 4;
+        };
+        static get IM_ORGANIZATION_READ(): io.komune.im.commons.auth.ImRole & {
+            get name(): "IM_ORGANIZATION_READ";
+            get ordinal(): 5;
+        };
+        static get IM_ORGANIZATION_WRITE(): io.komune.im.commons.auth.ImRole & {
+            get name(): "IM_ORGANIZATION_WRITE";
+            get ordinal(): 6;
+        };
+        static get IM_MY_ORGANIZATION_WRITE(): io.komune.im.commons.auth.ImRole & {
+            get name(): "IM_MY_ORGANIZATION_WRITE";
+            get ordinal(): 7;
+        };
+        static get IM_APIKEY_READ(): io.komune.im.commons.auth.ImRole & {
+            get name(): "IM_APIKEY_READ";
+            get ordinal(): 8;
+        };
+        static get IM_APIKEY_WRITE(): io.komune.im.commons.auth.ImRole & {
+            get name(): "IM_APIKEY_WRITE";
+            get ordinal(): 9;
+        };
+        static get IM_SPACE_READ(): io.komune.im.commons.auth.ImRole & {
+            get name(): "IM_SPACE_READ";
+            get ordinal(): 10;
+        };
+        static get IM_SPACE_WRITE(): io.komune.im.commons.auth.ImRole & {
+            get name(): "IM_SPACE_WRITE";
+            get ordinal(): 11;
+        };
+        static get IM_ROLE_READ(): io.komune.im.commons.auth.ImRole & {
+            get name(): "IM_ROLE_READ";
+            get ordinal(): 12;
+        };
+        static get IM_ROLE_WRITE(): io.komune.im.commons.auth.ImRole & {
+            get name(): "IM_ROLE_WRITE";
+            get ordinal(): 13;
+        };
+        static values(): Array<io.komune.im.commons.auth.ImRole>;
+        static valueOf(value: string): io.komune.im.commons.auth.ImRole;
+        get name(): "ORCHESTRATOR" | "ORCHESTRATOR_ADMIN" | "ORCHESTRATOR_USER" | "IM_USER_READ" | "IM_USER_WRITE" | "IM_ORGANIZATION_READ" | "IM_ORGANIZATION_WRITE" | "IM_MY_ORGANIZATION_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;
+    }
 }
 export declare namespace io.komune.im.commons.exception {
     const ExceptionCodes: {
@@ -208,57 +323,77 @@ export declare namespace io.komune.im.commons.model {
         readonly street: string;
         readonly postalCode: string;
         readonly city: string;
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.komune.im.commons.model.AddressDTO": unique symbol;
+        };
     }
 }
 export declare namespace f2.dsl.fnc {
     interface F2Function<T, R> {
         invokePromise(cmds: Array<T>): Promise<Array<R>>;
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.fnc.F2Function": unique symbol;
+        };
     }
     interface F2Consumer<T> {
         invokePromise(cmds: Array<T>): Promise<void>;
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.fnc.F2Consumer": unique symbol;
+        };
     }
     interface F2Supplier<R> {
         invokePromise(): Promise<Array<R>>;
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.fnc.F2Supplier": unique symbol;
+        };
     }
     interface F2SupplierSingle<R> {
         invokePromise(): Promise<R>;
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "f2.dsl.fnc.F2SupplierSingle": unique symbol;
+        };
     }
 }
 export declare namespace io.komune.im.f2.space.domain.command {
     interface SpaceDefineCommandDTO extends f2.dsl.cqrs.Command {
         readonly identifier: string;
-        readonly theme?: string;
-        readonly smtp?: Record<string, string>;
-        readonly locales?: string[];
-
+        readonly theme: Nullable<string>;
+        readonly smtp: Nullable<any>/* Nullable<kotlin.collections.Map<string, string>> */;
+        readonly locales: Nullable<any>/* Nullable<kotlin.collections.List<string>> */;
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.komune.im.f2.space.domain.command.SpaceDefineCommandDTO": unique symbol;
+        } & f2.dsl.cqrs.Command["__doNotUseOrImplementIt"];
     }
     interface SpaceDefinedEventDTO extends f2.dsl.cqrs.Event {
         readonly identifier: string;
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.komune.im.f2.space.domain.command.SpaceDefinedEventDTO": unique symbol;
+        } & f2.dsl.cqrs.Event["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace io.komune.im.f2.space.domain.command {
     interface SpaceDeleteCommandDTO extends f2.dsl.cqrs.Command {
         readonly id: string;
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.komune.im.f2.space.domain.command.SpaceDeleteCommandDTO": unique symbol;
+        } & f2.dsl.cqrs.Command["__doNotUseOrImplementIt"];
     }
     interface SpaceDeletedEventDTO extends f2.dsl.cqrs.Event {
         readonly id: string;
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.komune.im.f2.space.domain.command.SpaceDeletedEventDTO": unique symbol;
+        } & f2.dsl.cqrs.Event["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace io.komune.im.f2.space.domain.model {
     interface SpaceDTO {
-        readonly identifier?: string;
-        readonly smtp?: Record<string, string>;
-        readonly theme?: string;
-        readonly locales?: string[];
-
+        readonly identifier: Nullable<string>;
+        readonly smtp: Nullable<any>/* Nullable<kotlin.collections.Map<string, string>> */;
+        readonly theme: Nullable<string>;
+        readonly locales: Nullable<any>/* Nullable<kotlin.collections.List<string>> */;
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.komune.im.f2.space.domain.model.SpaceDTO": unique symbol;
+        };
     }
 }
 export declare namespace io.komune.im.f2.space.domain.policies {
@@ -266,30 +401,38 @@ export declare namespace io.komune.im.f2.space.domain.policies {
         canGet(authedUser: io.komune.im.commons.auth.AuthedUserDTO): boolean;
         canPage(authedUser: io.komune.im.commons.auth.AuthedUserDTO): boolean;
         canDefine(authedUser: io.komune.im.commons.auth.AuthedUserDTO): boolean;
-        canDelete(authedUser: io.komune.im.commons.auth.AuthedUserDTO, spaceIdentifier: string): boolean;
+        canDelete(authedUser: io.komune.im.commons.auth.AuthedUserDTO): boolean;
     };
 }
 export declare namespace io.komune.im.f2.space.domain.query {
     interface SpaceGetQueryDTO extends f2.dsl.cqrs.Query {
         readonly id: string;
-
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.komune.im.f2.space.domain.query.SpaceGetQueryDTO": unique symbol;
+        } & f2.dsl.cqrs.Query["__doNotUseOrImplementIt"];
     }
     interface SpaceGetResultDTO extends f2.dsl.cqrs.Event {
-        readonly item?: io.komune.im.f2.space.domain.model.SpaceDTO;
-
+        readonly item: Nullable<io.komune.im.f2.space.domain.model.SpaceDTO>;
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.komune.im.f2.space.domain.query.SpaceGetResultDTO": unique symbol;
+        } & f2.dsl.cqrs.Event["__doNotUseOrImplementIt"];
     }
 }
 export declare namespace io.komune.im.f2.space.domain.query {
     interface SpacePageQueryDTO extends f2.dsl.cqrs.Query {
-        readonly search?: string;
-        readonly page?: number;
-        readonly size?: number;
-
+        readonly search: Nullable<string>;
+        readonly page: Nullable<number>;
+        readonly size: Nullable<number>;
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.komune.im.f2.space.domain.query.SpacePageQueryDTO": unique symbol;
+        } & f2.dsl.cqrs.Query["__doNotUseOrImplementIt"];
     }
     interface SpacePageResultDTO extends f2.dsl.cqrs.page.PageDTO<io.komune.im.f2.space.domain.model.SpaceDTO> {
         readonly total: number;
-        readonly items: io.komune.im.f2.space.domain.model.SpaceDTO[];
-
+        readonly items: any/* kotlin.collections.List<io.komune.im.f2.space.domain.model.SpaceDTO> */;
+        readonly __doNotUseOrImplementIt: {
+            readonly "io.komune.im.f2.space.domain.query.SpacePageResultDTO": unique symbol;
+        } & f2.dsl.cqrs.page.PageDTO<io.komune.im.f2.space.domain.model.SpaceDTO>["__doNotUseOrImplementIt"];
     }
 }
 export as namespace io_komune_im_im_space_domain;

package/connect-im-im-f2-space-im-space-domain.js

@@ -80,14 +80,14 @@ if (typeof Math.imul === 'undefined') {
   setMetadataFor(AbstractMutableCollection, 'AbstractMutableCollection', classMeta, AbstractCollection, [AbstractCollection, Collection]);
   setMetadataFor(IteratorImpl, 'IteratorImpl', classMeta);
   setMetadataFor(List, 'List', interfaceMeta, VOID, [Collection]);
-  setMetadataFor(AbstractMutableList, 'AbstractMutableList', classMeta, AbstractMutableCollection, [AbstractMutableCollection, List, Collection]);
+  setMetadataFor(AbstractMutableList, 'AbstractMutableList', classMeta, AbstractMutableCollection, [AbstractMutableCollection, Collection, List]);
   setMetadataFor(Map_0, 'Map', interfaceMeta);
   setMetadataFor(AbstractMap, 'AbstractMap', classMeta, VOID, [Map_0]);
   setMetadataFor(AbstractMutableMap, 'AbstractMutableMap', classMeta, AbstractMap, [AbstractMap, Map_0]);
   setMetadataFor(Set, 'Set', interfaceMeta, VOID, [Collection]);
   setMetadataFor(AbstractMutableSet, 'AbstractMutableSet', classMeta, AbstractMutableCollection, [AbstractMutableCollection, Collection, Set]);
   setMetadataFor(Companion, 'Companion', objectMeta);
-  setMetadataFor(ArrayList, 'ArrayList', classMeta, AbstractMutableList, [AbstractMutableList, List, Collection], ArrayList_init_$Create$);
+  setMetadataFor(ArrayList, 'ArrayList', classMeta, AbstractMutableList, [AbstractMutableList, Collection, List], ArrayList_init_$Create$);
   setMetadataFor(HashMap, 'HashMap', classMeta, AbstractMutableMap, [AbstractMutableMap, Map_0], HashMap_init_$Create$);
   setMetadataFor(HashMapKeys, 'HashMapKeys', classMeta, AbstractMutableSet, [Collection, Set, AbstractMutableSet]);
   setMetadataFor(HashMapEntrySetBase, 'HashMapEntrySetBase', classMeta, AbstractMutableSet, [Collection, Set, AbstractMutableSet]);
@@ -382,7 +382,7 @@ if (typeof Math.imul === 'undefined') {
   setMetadataFor(Symbol_0, 'Symbol', classMeta);
   setMetadataFor(SetTimeoutBasedDispatcher, 'SetTimeoutBasedDispatcher', classMeta, CoroutineDispatcher, VOID, VOID, VOID, VOID, [1]);
   setMetadataFor(NodeDispatcher, 'NodeDispatcher', objectMeta, SetTimeoutBasedDispatcher, VOID, VOID, VOID, VOID, [1]);
-  setMetadataFor(MessageQueue, 'MessageQueue', classMeta, VOID, [List, Collection]);
+  setMetadataFor(MessageQueue, 'MessageQueue', classMeta, VOID, [Collection, List]);
   setMetadataFor(ScheduledMessageQueue, 'ScheduledMessageQueue', classMeta, MessageQueue);
   setMetadataFor(WindowMessageQueue, 'WindowMessageQueue', classMeta, MessageQueue);
   setMetadataFor(Dispatchers, 'Dispatchers', objectMeta);
@@ -11754,7 +11754,7 @@ if (typeof Math.imul === 'undefined') {
   protoOf(SpacePolicies).canDefine = function (authedUser) {
     return hasRole(authedUser, ImRole_IM_SPACE_WRITE_getInstance());
   };
-  protoOf(SpacePolicies).canDelete = function (authedUser, spaceIdentifier) {
+  protoOf(SpacePolicies).canDelete = function (authedUser) {
     return hasRole(authedUser, ImRole_IM_SPACE_WRITE_getInstance());
   };
   var SpacePolicies_instance;