@icure/cardinal-sdk 2.0.0-PREVIEW-10 → 2.0.0-PREVIEW-13

package/api/AnonymousHealthcarePartyApi.d.mts

@@ -1,4 +1,4 @@
-import { UserAndHealthcareParty } from '../model/UserAndHealthcareParty.mjs';
+import { HealthcareParty } from '../model/HealthcareParty.mjs';
 export interface AnonymousHealthcarePartyApi {
-    getPublicHealthcarePartiesInGroup(groupId: string): Promise<Array<UserAndHealthcareParty>>;
+    getPublicHealthcarePartiesInGroup(groupId: string): Promise<Array<HealthcareParty>>;
 }

package/cardinal-sdk-ts.d.mts

@@ -10,6 +10,7 @@ import * as model from './model.mjs'
 import * as api from './api.mjs'
 import * as kerberus from './kerberus.mjs'
 type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
 /** @deprecated  */
 export declare const initHook: { get(): any; };
 export declare interface Challenge {
@@ -26,23 +27,44 @@ export declare interface Solution {
 export declare class NotFoundException extends Error {
     constructor(msg: string);
 }
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace NotFoundException.$metadata$ {
+    const constructor: abstract new () => NotFoundException;
+}
 export declare class RevisionConflictException extends Error {
     constructor();
 }
-export declare const InternalSdkInitializers: {
-    getInstance(): {
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace RevisionConflictException.$metadata$ {
+    const constructor: abstract new () => RevisionConflictException;
+}
+export declare abstract class InternalSdkInitializers {
+    static readonly getInstance: () => typeof InternalSdkInitializers.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalSdkInitializers.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         initializeSdk(applicationId: Nullable<string>, baseUrl: string, authenticationMethod: options.AuthenticationMethod, storageFacade: any, options: Nullable<options.SdkOptions>): Promise<sdk.CardinalSdk>;
         initializeWithProcess(applicationId: Nullable<string>, baseUrl: string, messageGatewayUrl: string, externalServicesSpecId: string, processId: string, userTelecomType: string, userTelecom: string, captchaOptions: auth.CaptchaOptions, baseStorage: any, authenticationProcessTemplateParameters: Nullable<options.AuthenticationProcessTemplateParameters>, options: Nullable<options.SdkOptions>): Promise<sdk.CardinalSdk.AuthenticationWithProcessStep>;
         initializeBase(applicationId: Nullable<string>, baseUrl: string, authenticationMethod: options.AuthenticationMethod, options: Nullable<options.BasicSdkOptions>): Promise<sdk.CardinalBaseSdk>;
         initializeAnonymous(baseUrl: string, options: Nullable<options.AnonymousSdkOptions>): sdk.CardinalAnonymousSdk;
-    };
-};
+        private constructor();
+    }
+}
 export declare function spkiHexKeyToFingerprintV1(key: string): string;
 export declare function spkiHexKeyToFingerprintV2(key: string): string;
 export declare function fingerprintV1ToFingerprintV2(fingerprint: string): string;
 export declare class CancellationException extends Error {
     constructor();
 }
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace CancellationException.$metadata$ {
+    const constructor: abstract new () => CancellationException;
+}
 export declare interface FilterOptions<T extends model.Identifiable<string>> {
     readonly __doNotUseOrImplementIt: {
         readonly "com.icure.cardinal.sdk.js.filters.FilterOptions": unique symbol;
@@ -63,25 +85,51 @@ export declare interface BaseSortableFilterOptions<T extends model.Identifiable<
         readonly "com.icure.cardinal.sdk.js.filters.BaseSortableFilterOptions": unique symbol;
     } & BaseFilterOptions<T>["__doNotUseOrImplementIt"] & SortableFilterOptions<T>["__doNotUseOrImplementIt"];
 }
-export declare const InternalFilterOptions: {
-    getInstance(): {
+export declare abstract class InternalFilterOptions {
+    static readonly getInstance: () => typeof InternalFilterOptions.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalFilterOptions.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         union<T extends model.Identifiable<string>>(a: FilterOptions<T>, b: FilterOptions<T>, others: Array<FilterOptions<T>>): FilterOptions<T>;
         intersection<T extends model.Identifiable<string>>(a: FilterOptions<T>, b: FilterOptions<T>, others: Array<FilterOptions<T>>): FilterOptions<T>;
         difference<T extends model.Identifiable<string>>(of: FilterOptions<T>, subtracting: FilterOptions<T>): FilterOptions<T>;
-    };
-};
-export declare const InternalAccessLogFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalAccessLogFiltersObj {
+    static readonly getInstance: () => typeof InternalAccessLogFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalAccessLogFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         byPatientsDateForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, options: any): SortableFilterOptions<model.AccessLog>;
         byPatientsDateForSelf(patients: Array<model.Patient>, options: any): SortableFilterOptions<model.AccessLog>;
         byPatientSecretIdsDateForDataOwner(dataOwnerId: string, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.AccessLog>;
         byPatientSecretIdsDateForSelf(secretIds: Array<string>, options: any): SortableFilterOptions<model.AccessLog>;
         byDate(options: any): BaseSortableFilterOptions<model.AccessLog>;
         byUserTypeDate(userId: string, options: any): BaseSortableFilterOptions<model.AccessLog>;
-    };
-};
-export declare const InternalAgendaFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalAgendaFiltersObj {
+    static readonly getInstance: () => typeof InternalAgendaFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalAgendaFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         all(): BaseFilterOptions<model.Agenda>;
         byUser(userId: string): BaseFilterOptions<model.Agenda>;
         byUserInGroup(userReference: model.EntityReferenceInGroup): BaseFilterOptions<model.Agenda>;
@@ -94,10 +142,19 @@ export declare const InternalAgendaFiltersObj: {
         byLongProperty(propertyId: string, propertyValue: number): BaseFilterOptions<model.Agenda>;
         byDoubleProperty(propertyId: string, propertyValue: number): BaseFilterOptions<model.Agenda>;
         withProperty(propertyId: string): BaseFilterOptions<model.Agenda>;
-    };
-};
-export declare const InternalCalendarItemFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalCalendarItemFiltersObj {
+    static readonly getInstance: () => typeof InternalCalendarItemFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalCalendarItemFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         byPatientsStartTimeForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, options: any): SortableFilterOptions<model.CalendarItem>;
         byPatientsStartTimeForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.GroupScoped<model.Patient>>, options: any): SortableFilterOptions<model.CalendarItem>;
         byPatientsStartTimeForSelf(patients: Array<model.Patient>, options: any): SortableFilterOptions<model.CalendarItem>;
@@ -112,28 +169,55 @@ export declare const InternalCalendarItemFiltersObj: {
         lifecycleBetweenForDataOwner(dataOwnerId: string, startTimestamp: Nullable<number>, endTimestamp: Nullable<number>, descending: boolean): BaseFilterOptions<model.CalendarItem>;
         lifecycleBetweenForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, startTimestamp: Nullable<number>, endTimestamp: Nullable<number>, descending: boolean): BaseFilterOptions<model.CalendarItem>;
         lifecycleBetweenForSelf(startTimestamp: Nullable<number>, endTimestamp: Nullable<number>, descending: boolean): FilterOptions<model.CalendarItem>;
-    };
-};
-export declare const InternalClassificationFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalClassificationFiltersObj {
+    static readonly getInstance: () => typeof InternalClassificationFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalClassificationFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         byPatientsCreatedForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Classification>;
         byPatientsCreatedForSelf(patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Classification>;
         byPatientSecretIdsCreatedForDataOwner(dataOwnerId: string, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.Classification>;
         byPatientSecretIdsCreatedForSelf(secretIds: Array<string>, options: any): SortableFilterOptions<model.Classification>;
-    };
-};
-export declare const InternalCodeFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalCodeFiltersObj {
+    static readonly getInstance: () => typeof InternalCodeFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalCodeFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         all(): BaseFilterOptions<model.Code>;
         byIds(ids: Array<string>): BaseSortableFilterOptions<model.Code>;
         byQualifiedLink(linkType: string, options: any): BaseFilterOptions<model.Code>;
         byRegionTypeCodeVersion(region: string, options: any): BaseFilterOptions<model.Code>;
         byLanguageTypeLabelRegion(language: string, type: string, options: any): BaseFilterOptions<model.Code>;
         byLanguageTypesLabelRegionVersion(language: string, types: Array<string>, label: string, options: any): BaseFilterOptions<model.Code>;
-    };
-};
-export declare const InternalContactFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalContactFiltersObj {
+    static readonly getInstance: () => typeof InternalContactFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalContactFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         allContactsForDataOwner(dataOwnerId: string): BaseFilterOptions<model.Contact>;
         allContactsForSelf(): FilterOptions<model.Contact>;
         byFormIdsForDataOwner(dataOwnerId: string, formIds: Array<string>): BaseFilterOptions<model.Contact>;
@@ -160,17 +244,35 @@ export declare const InternalContactFiltersObj: {
         byPatientsSecretIdsForDataOwner(dataOwnerId: string, secretIds: Array<string>): BaseSortableFilterOptions<model.Contact>;
         byPatientsSecretIdsForSelf(secretIds: Array<string>): SortableFilterOptions<model.Contact>;
         byServiceIds(serviceIds: Array<string>): BaseSortableFilterOptions<model.Contact>;
-    };
-};
-export declare const InternalDeviceFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalDeviceFiltersObj {
+    static readonly getInstance: () => typeof InternalDeviceFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalDeviceFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         all(): BaseFilterOptions<model.Device>;
         byResponsible(responsibleId: string): BaseFilterOptions<model.Device>;
         byIds(ids: Array<string>): BaseSortableFilterOptions<model.Device>;
-    };
-};
-export declare const InternalDocumentFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalDocumentFiltersObj {
+    static readonly getInstance: () => typeof InternalDocumentFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalDocumentFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         byPatientsCreatedForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Document>;
         byMessagesCreatedForDataOwner(dataOwnerId: string, messages: Array<model.Message>, options: any): SortableFilterOptions<model.Document>;
         byPatientsCreatedForSelf(patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Document>;
@@ -183,10 +285,19 @@ export declare const InternalDocumentFiltersObj: {
         byMessagesAndTypeForSelf(documentType: string, messages: Array<model.Message>): FilterOptions<model.Document>;
         byOwningEntitySecretIdsAndTypeForDataOwner(dataOwnerId: string, documentType: string, secretIds: Array<string>): FilterOptions<model.Document>;
         byOwningEntitySecretIdsAndTypeForSelf(documentType: string, secretIds: Array<string>): FilterOptions<model.Document>;
-    };
-};
-export declare const InternalFormFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalFormFiltersObj {
+    static readonly getInstance: () => typeof InternalFormFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalFormFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         byParentIdForDataOwner(dataOwnerId: string, parentId: string): BaseFilterOptions<model.Form>;
         byParentIdForSelf(parentId: string): FilterOptions<model.Form>;
         byPatientsOpeningDateForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Form>;
@@ -195,17 +306,35 @@ export declare const InternalFormFiltersObj: {
         byPatientSecretIdsOpeningDateForSelf(secretIds: Array<string>, options: any): SortableFilterOptions<model.Form>;
         byLogicalUuid(logicalUuid: string, options: any): BaseSortableFilterOptions<model.Form>;
         byUniqueId(uniqueId: string, options: any): BaseSortableFilterOptions<model.Form>;
-    };
-};
-export declare const InternalGroupFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalGroupFiltersObj {
+    static readonly getInstance: () => typeof InternalGroupFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalGroupFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         all(): BaseFilterOptions<model.Group>;
         bySuperGroup(superGroupId: string): BaseFilterOptions<model.Group>;
         withContent(superGroupId: string, searchString: string): BaseSortableFilterOptions<model.Group>;
-    };
-};
-export declare const InternalHealthElementFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalHealthElementFiltersObj {
+    static readonly getInstance: () => typeof InternalHealthElementFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalHealthElementFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         allHealthElementsForDataOwner(dataOwnerId: string): BaseFilterOptions<model.HealthElement>;
         allHealthElementsForSelf(): FilterOptions<model.HealthElement>;
         byIdentifiersForDataOwner(dataOwnerId: string, identifiers: Array<model.Identifier>): BaseSortableFilterOptions<model.HealthElement>;
@@ -225,10 +354,19 @@ export declare const InternalHealthElementFiltersObj: {
         byPatientSecretIdsOpeningDateForSelf(secretIds: Array<string>, options: any): SortableFilterOptions<model.HealthElement>;
         byStatusForDataOwner(dataOwnerId: string, status: number): BaseFilterOptions<model.HealthElement>;
         byStatusForSelf(status: number): FilterOptions<model.HealthElement>;
-    };
-};
-export declare const InternalHealthcarePartyFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalHealthcarePartyFiltersObj {
+    static readonly getInstance: () => typeof InternalHealthcarePartyFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalHealthcarePartyFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         all(): BaseFilterOptions<model.HealthcareParty>;
         byIdentifiers(identifiers: Array<model.Identifier>): BaseFilterOptions<model.HealthcareParty>;
         byCode(codeType: string, options: any): BaseSortableFilterOptions<model.HealthcareParty>;
@@ -238,10 +376,19 @@ export declare const InternalHealthcarePartyFiltersObj: {
         byNationalIdentifier(searchString: string, options: any): BaseSortableFilterOptions<model.HealthcareParty>;
         byParentId(parentId: string): BaseFilterOptions<model.HealthcareParty>;
         byTypeSpecialtyPostCode(specialty: string, specCode: string, startPostCode: string, endPostCode: string): BaseFilterOptions<model.HealthcareParty>;
-    };
-};
-export declare const InternalMaintenanceTaskFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalMaintenanceTaskFiltersObj {
+    static readonly getInstance: () => typeof InternalMaintenanceTaskFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalMaintenanceTaskFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         byIds(ids: Array<string>): BaseSortableFilterOptions<model.MaintenanceTask>;
         byIdentifiersForDataOwner(dataOwnerId: string, identifiers: Array<model.Identifier>): BaseSortableFilterOptions<model.MaintenanceTask>;
         byIdentifiersForSelf(identifiers: Array<model.Identifier>): SortableFilterOptions<model.MaintenanceTask>;
@@ -249,16 +396,34 @@ export declare const InternalMaintenanceTaskFiltersObj: {
         byTypeForSelf(type: string): FilterOptions<model.MaintenanceTask>;
         afterDateForDataOwner(dataOwnerId: string, date: number): BaseSortableFilterOptions<model.MaintenanceTask>;
         afterDateForSelf(date: number): SortableFilterOptions<model.MaintenanceTask>;
-    };
-};
-export declare const InternalMedicalLocationFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalMedicalLocationFiltersObj {
+    static readonly getInstance: () => typeof InternalMedicalLocationFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalMedicalLocationFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         all(): BaseFilterOptions<model.MedicalLocation>;
         byPostCode(postCode: string): BaseFilterOptions<model.MedicalLocation>;
-    };
-};
-export declare const InternalMessageFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalMessageFiltersObj {
+    static readonly getInstance: () => typeof InternalMessageFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalMessageFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         allMessagesForDataOwner(dataOwnerId: string): BaseFilterOptions<model.Message>;
         allMessagesForSelf(): FilterOptions<model.Message>;
         byTransportGuidForDataOwner(dataOwnerId: string, transportGuid: string): BaseSortableFilterOptions<model.Message>;
@@ -280,10 +445,19 @@ export declare const InternalMessageFiltersObj: {
         lifecycleBetweenForDataOwner(dataOwnerId: string, startTimestamp: Nullable<number>, endTimestamp: Nullable<number>, descending: boolean): BaseFilterOptions<model.Message>;
         lifecycleBetweenForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, startTimestamp: Nullable<number>, endTimestamp: Nullable<number>, descending: boolean): BaseFilterOptions<model.Message>;
         lifecycleBetweenForSelf(startTimestamp: Nullable<number>, endTimestamp: Nullable<number>, descending: boolean): FilterOptions<model.Message>;
-    };
-};
-export declare const InternalPatientFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalPatientFiltersObj {
+    static readonly getInstance: () => typeof InternalPatientFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalPatientFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         allPatientsForDataOwner(dataOwnerId: string): BaseFilterOptions<model.Patient>;
         allPatientsForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup): BaseFilterOptions<model.Patient>;
         allPatientsForSelf(): FilterOptions<model.Patient>;
@@ -321,10 +495,19 @@ export declare const InternalPatientFiltersObj: {
         byTagForSelf(tagType: string, tagCode: Nullable<string>): FilterOptions<model.Patient>;
         byTagForDataOwner(dataOwnerId: string, tagType: string, tagCode: Nullable<string>): BaseFilterOptions<model.Patient>;
         byTagForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, tagType: string, tagCode: Nullable<string>): BaseFilterOptions<model.Patient>;
-    };
-};
-export declare const InternalServiceFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalServiceFiltersObj {
+    static readonly getInstance: () => typeof InternalServiceFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalServiceFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         allServicesForDataOwner(dataOwnerId: string): BaseFilterOptions<model.Service>;
         allServicesForSelf(): FilterOptions<model.Service>;
         byIdentifiersForDataOwner(dataOwnerId: string, identifiers: Array<model.Identifier>): BaseSortableFilterOptions<model.Service>;
@@ -346,36 +529,73 @@ export declare const InternalServiceFiltersObj: {
         byPatientsDateForSelf(patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Service>;
         byPatientSecretIdsDateForDataOwner(dataOwnerId: string, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.Service>;
         byPatientSecretIdsDateForSelf(secretIds: Array<string>, options: any): SortableFilterOptions<model.Service>;
-    };
-};
-export declare const InternalTimeTableFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalTimeTableFiltersObj {
+    static readonly getInstance: () => typeof InternalTimeTableFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalTimeTableFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         byAgendaId(agendaId: string): BaseFilterOptions<model.TimeTable>;
         byPeriodAndAgendaId(agendaId: string, options: any): BaseSortableFilterOptions<model.TimeTable>;
-    };
-};
-export declare const InternalTopicFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalTopicFiltersObj {
+    static readonly getInstance: () => typeof InternalTopicFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalTopicFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         allTopicsForDataOwner(dataOwnerId: string): BaseFilterOptions<model.Topic>;
         allTopicsForSelf(): FilterOptions<model.Topic>;
         byParticipant(participantId: string): FilterOptions<model.Topic>;
-    };
-};
-export declare const InternalUserFiltersObj: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalUserFiltersObj {
+    static readonly getInstance: () => typeof InternalUserFiltersObj.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalUserFiltersObj.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         all(): BaseFilterOptions<model.User>;
         byIds(ids: Array<string>): BaseSortableFilterOptions<model.User>;
         byPatientId(patientId: string): BaseFilterOptions<model.User>;
         byHealthcarePartyId(healthcarePartyId: string): BaseFilterOptions<model.User>;
         byNameEmailOrPhone(searchString: string): BaseFilterOptions<model.User>;
-    };
-};
-export declare const InternalKeyPairUpdateNotificationJs_COMPANION: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalKeyPairUpdateNotificationJs_COMPANION {
+    static readonly getInstance: () => typeof InternalKeyPairUpdateNotificationJs_COMPANION.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalKeyPairUpdateNotificationJs_COMPANION.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         get TASK_TYPE(): string;
         parseFromMaintenanceTask(task: model.DecryptedMaintenanceTask): model.KeyPairUpdateNotification;
-    };
-};
+        private constructor();
+    }
+}
 export declare interface CardinalStorageOptions {
     readonly __doNotUseOrImplementIt: {
         readonly "com.icure.cardinal.sdk.js.storage.CardinalStorageOptions": unique symbol;
@@ -386,18 +606,36 @@ export declare interface CardinalKeyStorageOptions {
         readonly "com.icure.cardinal.sdk.js.storage.CardinalKeyStorageOptions": unique symbol;
     };
 }
-export declare const InternalCardinalStorageOptionsFactory: {
-    getInstance(): {
+export declare abstract class InternalCardinalStorageOptionsFactory {
+    static readonly getInstance: () => typeof InternalCardinalStorageOptionsFactory.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalCardinalStorageOptionsFactory.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         fileSystem(directory: string): CardinalStorageOptions;
         browserLocalStorage(): CardinalStorageOptions;
-    };
-};
-export declare const InternalCardinalKeyStorageOptionsFactory: {
-    getInstance(): {
+        private constructor();
+    }
+}
+export declare abstract class InternalCardinalKeyStorageOptionsFactory {
+    static readonly getInstance: () => typeof InternalCardinalKeyStorageOptionsFactory.$metadata$.type;
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace InternalCardinalKeyStorageOptionsFactory.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
+    abstract class constructor {
         encodingAsBase64(baseStorage: any): CardinalKeyStorageOptions;
         encodingAsJwk(baseStorage: any): CardinalKeyStorageOptions;
-    };
-};
+        private constructor();
+    }
+}
 export declare function base32Encode(bytes: Int8Array): string;
 export declare function base32Decode(base32String: string): Int8Array;
 export declare function hexEncode(bytes: Int8Array): string;