@komune-io/im-space-domain 0.26.0 → 0.27.0-alpha.4344fa6

package/{im-0.26.0-im-f2-space-im-space-domain.d.mts → connect-im-im-f2-space-im-space-domain.d.mts}

@@ -1,32 +1,22 @@
-type Nullable<T> = T | null | undefined
 declare function KtSingleton<T>(): T & (abstract new() => any);
-export declare interface KtList<out 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, out 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 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();
@@ -122,29 +112,14 @@ 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<in T, out 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);
@@ -153,7 +128,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 */
@@ -162,52 +137,33 @@ export declare namespace 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 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"] & WithEnvelopeData<any>["__doNotUseOrImplementIt"] & WithEnvelopeId["__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<any>["__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 */
@@ -229,35 +185,25 @@ export declare namespace Envelope {
 }
 export declare interface WithEnvelopeData<T> {
     readonly data: T;
-    readonly __doNotUseOrImplementIt: {
-        readonly "f2.dsl.cqrs.envelope.WithEnvelopeData": unique symbol;
-    };
 }
 export declare interface WithEnvelopeId {
     readonly id: string;
-    readonly __doNotUseOrImplementIt: {
-        readonly "f2.dsl.cqrs.envelope.WithEnvelopeId": unique symbol;
-    };
 }
 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 */
@@ -266,7 +212,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 {
@@ -281,7 +227,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();
             }
         }
@@ -293,30 +239,20 @@ export declare interface Match<T> {
     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<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<out OBJECT> implements PageDTO<OBJECT> {
-    constructor(total: number, items: KtList<OBJECT>);
+    constructor(total: number, items: OBJECT[]);
     get total(): number;
-    get items(): KtList<OBJECT>;
-    readonly __doNotUseOrImplementIt: PageDTO<any>["__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 */
@@ -325,23 +261,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<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;
-    } & PageDTO<any>["__doNotUseOrImplementIt"] & Event["__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 */
@@ -350,11 +279,10 @@ export declare namespace PageQuery {
     }
 }
 export declare class PageQueryResult<out OBJECT> implements PageQueryResultDTO<OBJECT> {
-    constructor(pagination: Nullable<OffsetPagination>, total: number, items: KtList<OBJECT>);
-    get pagination(): Nullable<OffsetPagination>;
+    constructor(pagination?: OffsetPagination, total: number, items: OBJECT[]);
+    get pagination(): OffsetPagination | undefined;
     get total(): number;
-    get items(): KtList<OBJECT>;
-    readonly __doNotUseOrImplementIt: PageQueryResultDTO<any>["__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 */
@@ -363,29 +291,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 */
@@ -394,10 +312,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 */
@@ -410,7 +327,7 @@ export declare abstract class AuthRealm {
     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 */
@@ -429,7 +346,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 */
@@ -438,17 +355,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 */
@@ -457,18 +374,18 @@ export declare namespace AuthRealmClientSecret {
     }
 }
 export declare class TokenInfo {
-    constructor(accessToken: string, expiresIn: number, refreshExpiresIn: Nullable<number> | undefined, tokenType: string, scope: Nullable<string>, idToken?: Nullable<string>, refreshToken?: Nullable<string>);
+    constructor(accessToken: string, expiresIn: number, refreshExpiresIn?: number | undefined, tokenType: string, scope?: string, idToken?: string, refreshToken?: string);
     get accessToken(): string;
     get expiresIn(): number;
-    get refreshExpiresIn(): Nullable<number>;
+    get refreshExpiresIn(): number | undefined;
     get tokenType(): string;
-    get scope(): Nullable<string>;
-    get idToken(): Nullable<string>;
-    get refreshToken(): Nullable<string>;
-    copy(accessToken?: string, expiresIn?: number, refreshExpiresIn?: Nullable<number>, tokenType?: string, scope?: Nullable<string>, idToken?: Nullable<string>, refreshToken?: Nullable<string>): TokenInfo;
+    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: Nullable<any>): boolean;
+    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 */
@@ -478,53 +395,35 @@ export declare namespace TokenInfo {
 }
 export declare interface SpaceDefineCommandDTO extends Command {
     readonly identifier: string;
-    readonly displayName: Nullable<string>;
-    readonly theme: Nullable<string>;
-    readonly smtp: Nullable<KtMap<string, string>>;
-    readonly locales: Nullable<KtList<string>>;
-    readonly settings: Nullable<SpaceSettingsDTO>;
-    readonly mfa: Nullable<KtList<string>>;
-    readonly sslRequired: Nullable<string>;
-    readonly __doNotUseOrImplementIt: {
-        readonly "io.komune.im.f2.space.domain.command.SpaceDefineCommandDTO": unique symbol;
-    } & Command["__doNotUseOrImplementIt"];
+    readonly displayName?: string;
+    readonly theme?: string;
+    readonly smtp?: Record<string, string>;
+    readonly locales?: string[];
+    readonly settings?: SpaceSettingsDTO;
+    readonly mfa?: string[];
+    readonly sslRequired?: string;
 }
 export declare interface SpaceSettingsDTO {
-    readonly registrationAllowed: Nullable<boolean>;
-    readonly rememberMe: Nullable<boolean>;
-    readonly resetPasswordAllowed: Nullable<boolean>;
-    readonly registrationEmailAsUsername: Nullable<boolean>;
-    readonly __doNotUseOrImplementIt: {
-        readonly "io.komune.im.f2.space.domain.command.SpaceSettingsDTO": unique symbol;
-    };
+    readonly registrationAllowed?: boolean;
+    readonly rememberMe?: boolean;
+    readonly resetPasswordAllowed?: boolean;
+    readonly registrationEmailAsUsername?: boolean;
 }
 export declare interface SpaceDefinedEventDTO extends Event {
     readonly identifier: string;
-    readonly __doNotUseOrImplementIt: {
-        readonly "io.komune.im.f2.space.domain.command.SpaceDefinedEventDTO": unique symbol;
-    } & Event["__doNotUseOrImplementIt"];
 }
 export declare interface SpaceDeleteCommandDTO extends Command {
     readonly id: string;
-    readonly __doNotUseOrImplementIt: {
-        readonly "io.komune.im.f2.space.domain.command.SpaceDeleteCommandDTO": unique symbol;
-    } & Command["__doNotUseOrImplementIt"];
 }
 export declare interface SpaceDeletedEventDTO extends Event {
     readonly id: string;
-    readonly __doNotUseOrImplementIt: {
-        readonly "io.komune.im.f2.space.domain.command.SpaceDeletedEventDTO": unique symbol;
-    } & Event["__doNotUseOrImplementIt"];
 }
 export declare interface SpaceDTO {
-    readonly identifier: Nullable<string>;
-    readonly displayName: Nullable<string>;
-    readonly smtp: Nullable<KtMap<string, string>>;
-    readonly theme: Nullable<string>;
-    readonly locales: Nullable<KtList<string>>;
-    readonly __doNotUseOrImplementIt: {
-        readonly "io.komune.im.f2.space.domain.model.SpaceDTO": unique symbol;
-    };
+    readonly identifier?: string;
+    readonly displayName?: string;
+    readonly smtp?: Record<string, string>;
+    readonly theme?: string;
+    readonly locales?: string[];
 }
 export declare abstract class SpacePolicies {
     static readonly getInstance: () => typeof SpacePolicies.$metadata$.type;
@@ -547,26 +446,14 @@ export declare namespace SpacePolicies {
 }
 export declare interface SpaceGetQueryDTO extends Query {
     readonly id: string;
-    readonly __doNotUseOrImplementIt: {
-        readonly "io.komune.im.f2.space.domain.query.SpaceGetQueryDTO": unique symbol;
-    } & Query["__doNotUseOrImplementIt"];
 }
 export declare interface SpaceGetResultDTO extends Event {
-    readonly item: Nullable<SpaceDTO>;
-    readonly __doNotUseOrImplementIt: {
-        readonly "io.komune.im.f2.space.domain.query.SpaceGetResultDTO": unique symbol;
-    } & Event["__doNotUseOrImplementIt"];
+    readonly item?: SpaceDTO;
 }
 export declare interface SpacePageQueryDTO extends Query {
-    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;
-    } & Query["__doNotUseOrImplementIt"];
+    readonly search?: string;
+    readonly page?: number;
+    readonly size?: number;
 }
 export declare interface SpacePageResultDTO extends PageDTO<SpaceDTO> {
-    readonly __doNotUseOrImplementIt: {
-        readonly "io.komune.im.f2.space.domain.query.SpacePageResultDTO": unique symbol;
-    } & PageDTO<any>["__doNotUseOrImplementIt"];
 }

package/{im-0.26.0-im-f2-space-im-space-domain.mjs → connect-im-im-f2-space-im-space-domain.mjs}

@@ -8258,24 +8258,24 @@ initMetadataForClass(AbstractMutableCollection, 'AbstractMutableCollection', VOI
 initMetadataForClass(IteratorImpl, 'IteratorImpl');
 initMetadataForClass(ListIteratorImpl, 'ListIteratorImpl');
 protoOf(AbstractMutableList).asJsReadonlyArrayView = asJsReadonlyArrayView;
-initMetadataForClass(AbstractMutableList, 'AbstractMutableList', VOID, VOID, [KtList, Collection]);
+initMetadataForClass(AbstractMutableList, 'AbstractMutableList', VOID, VOID, [Collection, KtList]);
 initMetadataForClass(SubList, 'SubList');
 protoOf(AbstractMap).asJsReadonlyMapView = asJsReadonlyMapView;
 initMetadataForClass(AbstractMap, 'AbstractMap', VOID, VOID, [KtMap]);
 initMetadataForClass(AbstractMutableMap, 'AbstractMutableMap', VOID, VOID, [KtMap]);
-initMetadataForClass(AbstractMutableSet, 'AbstractMutableSet', VOID, VOID, [KtSet, Collection]);
+initMetadataForClass(AbstractMutableSet, 'AbstractMutableSet', VOID, VOID, [Collection, KtSet]);
 initMetadataForCompanion(Companion_2);
-initMetadataForClass(ArrayList, 'ArrayList', ArrayList.y4, VOID, [KtList, Collection]);
+initMetadataForClass(ArrayList, 'ArrayList', ArrayList.y4, VOID, [Collection, KtList]);
 initMetadataForClass(HashMap, 'HashMap', HashMap.h5, VOID, [KtMap]);
-initMetadataForClass(HashMapKeys, 'HashMapKeys', VOID, VOID, [KtSet, Collection]);
+initMetadataForClass(HashMapKeys, 'HashMapKeys', VOID, VOID, [Collection, KtSet]);
 initMetadataForClass(HashMapValues, 'HashMapValues', VOID, VOID, [Collection]);
-initMetadataForClass(HashMapEntrySetBase, 'HashMapEntrySetBase', VOID, VOID, [KtSet, Collection]);
+initMetadataForClass(HashMapEntrySetBase, 'HashMapEntrySetBase', VOID, VOID, [Collection, KtSet]);
 initMetadataForClass(HashMapEntrySet, 'HashMapEntrySet');
 initMetadataForClass(HashMapKeysDefault$iterator$1);
 initMetadataForClass(HashMapKeysDefault, 'HashMapKeysDefault');
 initMetadataForClass(HashMapValuesDefault$iterator$1);
 initMetadataForClass(HashMapValuesDefault, 'HashMapValuesDefault');
-initMetadataForClass(HashSet, 'HashSet', HashSet.t6, VOID, [KtSet, Collection]);
+initMetadataForClass(HashSet, 'HashSet', HashSet.t6, VOID, [Collection, KtSet]);
 initMetadataForCompanion(Companion_3);
 initMetadataForClass(Itr, 'Itr');
 initMetadataForClass(KeysItr, 'KeysItr');
@@ -8528,4 +8528,4 @@ export {
 };
 //endregion
 
-//# sourceMappingURL=im-0.26.0-im-f2-space-im-space-domain.mjs.map
+//# sourceMappingURL=connect-im-im-f2-space-im-space-domain.mjs.map