import * as filters from './filters.mjs'
import * as storage from './storage.mjs'
import * as sdk from './sdk.mjs'
import * as subscription from './subscription.mjs'
import * as crypto from './crypto.mjs'
import * as auth from './auth.mjs'
import * as options from './options.mjs'
import * as kerberus from './kerberus.mjs'
import * as utils from './utils.mjs'
import * as api from './api.mjs'
import * as model from './model.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 {
    readonly id: string;
    readonly salts: Array<string>;
    readonly difficultyFactor: number;
}
export declare function resolveChallenge(config: Challenge, serializedInput: string, cryptoService?: Nullable<crypto.PartialXCryptoService>, onProgress?: (p0: number) => void): Promise<Solution>;
export declare function validateSolution(config: Challenge, result: Solution, serializedInput: string, cryptoService?: Nullable<crypto.PartialXCryptoService>): Promise<boolean>;
export declare interface Solution {
    readonly id: string;
    readonly nonces: Array<string>;
}
export declare class NotFoundException extends Error {
    constructor(msg: string);
}
export declare namespace NotFoundException {
    /** @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 () => NotFoundException;
    }
}
export declare class RevisionConflictException extends Error {
    constructor();
}
export declare namespace RevisionConflictException {
    /** @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 () => RevisionConflictException;
    }
}
export declare class SecureStorageException extends /* Exception */ Error {
    constructor(message: string, cause?: Nullable<Error>);
}
export declare namespace SecureStorageException {
    /** @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 () => SecureStorageException;
    }
}
export declare class SecureStorageCorruptedException extends SecureStorageException.$metadata$.constructor {
    constructor(message: string, cause?: Nullable<Error>);
}
export declare namespace SecureStorageCorruptedException {
    /** @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 () => SecureStorageCorruptedException;
    }
}
export declare class SecureStorageKeyInvalidatedException extends SecureStorageException.$metadata$.constructor {
    constructor(message: string, cause?: Nullable<Error>);
}
export declare namespace SecureStorageKeyInvalidatedException {
    /** @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 () => SecureStorageKeyInvalidatedException;
    }
}
export declare class SecureStorageCryptoException extends SecureStorageException.$metadata$.constructor {
    constructor(message: string, cause?: Nullable<Error>);
}
export declare namespace SecureStorageCryptoException {
    /** @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 () => SecureStorageCryptoException;
    }
}
export declare class SecureStorageConfigurationException extends SecureStorageException.$metadata$.constructor {
    constructor(message: string, cause?: Nullable<Error>);
}
export declare namespace SecureStorageConfigurationException {
    /** @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 () => SecureStorageConfigurationException;
    }
}
export declare abstract class InternalSdkInitializers {
    static readonly getInstance: () => typeof InternalSdkInitializers.$metadata$.type;
    private constructor();
}
export declare namespace InternalSdkInitializers {
    /** @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 {
            initializeSdk(projectId: Nullable<string>, baseUrl: string, authenticationMethod: options.AuthenticationMethod, storageFacade: any, options: Nullable<options.SdkOptions>): Promise<sdk.CardinalSdk>;
            initializeWithProcess(projectId: 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(projectId: Nullable<string>, baseUrl: string, authenticationMethod: options.AuthenticationMethod, options: Nullable<options.BasicSdkOptions>): Promise<sdk.CardinalBaseSdk>;
            initializeWithProcessBase(projectId: Nullable<string>, baseUrl: string, messageGatewayUrl: string, externalServicesSpecId: string, processId: string, userTelecomType: string, userTelecom: string, captchaOptions: auth.CaptchaOptions, authenticationProcessTemplateParameters: Nullable<options.AuthenticationProcessTemplateParameters>, options: Nullable<options.BasicSdkOptions>): Promise<sdk.CardinalBaseSdk.BaseAuthenticationWithProcessStep>;
            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();
}
export declare namespace CancellationException {
    /** @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 () => CancellationException;
    }
}
export declare interface FilterOptions<T extends model.Identifiable<string>> {
    readonly __doNotUseOrImplementIt: {
        readonly "com.icure.cardinal.sdk.js.filters.FilterOptions": unique symbol;
    };
}
export declare interface SortableFilterOptions<T extends model.Identifiable<string>> extends FilterOptions<T> {
    readonly __doNotUseOrImplementIt: {
        readonly "com.icure.cardinal.sdk.js.filters.SortableFilterOptions": unique symbol;
    } & FilterOptions<any>["__doNotUseOrImplementIt"];
}
export declare interface BaseFilterOptions<T extends model.Identifiable<string>> extends FilterOptions<T> {
    readonly __doNotUseOrImplementIt: {
        readonly "com.icure.cardinal.sdk.js.filters.BaseFilterOptions": unique symbol;
    } & FilterOptions<any>["__doNotUseOrImplementIt"];
}
export declare interface BaseSortableFilterOptions<T extends model.Identifiable<string>> extends BaseFilterOptions<T>, SortableFilterOptions<T> {
    readonly __doNotUseOrImplementIt: {
        readonly "com.icure.cardinal.sdk.js.filters.BaseSortableFilterOptions": unique symbol;
    } & SortableFilterOptions<any>["__doNotUseOrImplementIt"] & BaseFilterOptions<any>["__doNotUseOrImplementIt"];
}
export declare abstract class InternalFilterOptions {
    static readonly getInstance: () => typeof InternalFilterOptions.$metadata$.type;
    private constructor();
}
export declare namespace InternalFilterOptions {
    /** @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 {
            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>;
            private constructor();
        }
    }
}
export declare abstract class InternalAccessLogFiltersObj {
    static readonly getInstance: () => typeof InternalAccessLogFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalAccessLogFiltersObj {
    /** @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 {
            byPatientsDateForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, options: any): SortableFilterOptions<model.AccessLog>;
            byPatientsDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.GroupScoped<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>;
            private constructor();
        }
    }
}
export declare abstract class InternalAgendaFiltersObj {
    static readonly getInstance: () => typeof InternalAgendaFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalAgendaFiltersObj {
    /** @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 {
            all(): BaseFilterOptions<model.Agenda>;
            byUser(userId: string): BaseFilterOptions<model.Agenda>;
            byUserInGroup(userReference: model.EntityReferenceInGroup): BaseFilterOptions<model.Agenda>;
            readableByUser(userId: string): BaseFilterOptions<model.Agenda>;
            readableByUserInGroup(userReference: model.EntityReferenceInGroup): BaseFilterOptions<model.Agenda>;
            readableByUserRights(userId: string): BaseFilterOptions<model.Agenda>;
            readableByUserRightsInGroup(userReference: model.EntityReferenceInGroup): BaseFilterOptions<model.Agenda>;
            byStringProperty(propertyId: string, propertyValue: string): BaseFilterOptions<model.Agenda>;
            byBooleanProperty(propertyId: string, propertyValue: boolean): BaseFilterOptions<model.Agenda>;
            byLongProperty(propertyId: string, propertyValue: number): BaseFilterOptions<model.Agenda>;
            byDoubleProperty(propertyId: string, propertyValue: number): BaseFilterOptions<model.Agenda>;
            withProperty(propertyId: string): BaseFilterOptions<model.Agenda>;
            private constructor();
        }
    }
}
export declare abstract class InternalCalendarItemFiltersObj {
    static readonly getInstance: () => typeof InternalCalendarItemFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalCalendarItemFiltersObj {
    /** @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 {
            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>;
            byPatientSecretIdsStartTimeForDataOwner(dataOwnerId: string, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.CalendarItem>;
            byPatientSecretIdsStartTimeForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.CalendarItem>;
            byPatientSecretIdsStartTimeForSelf(secretIds: Array<string>, options: any): SortableFilterOptions<model.CalendarItem>;
            byPeriodAndAgenda(agendaId: string, from: number, to: number, options: any): BaseSortableFilterOptions<model.CalendarItem>;
            byPeriodForDataOwner(dataOwnerId: string, from: number, to: number): BaseFilterOptions<model.CalendarItem>;
            byPeriodForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, from: number, to: number): BaseFilterOptions<model.CalendarItem>;
            byPeriodForSelf(from: number, to: number): FilterOptions<model.CalendarItem>;
            byRecurrenceId(recurrenceId: string): FilterOptions<model.CalendarItem>;
            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>;
            private constructor();
        }
    }
}
export declare abstract class InternalCodeFiltersObj {
    static readonly getInstance: () => typeof InternalCodeFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalCodeFiltersObj {
    /** @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 {
            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>;
            private constructor();
        }
    }
}
export declare abstract class InternalContactFiltersObj {
    static readonly getInstance: () => typeof InternalContactFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalContactFiltersObj {
    /** @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 {
            allContactsForDataOwner(dataOwnerId: string): BaseFilterOptions<model.Contact>;
            allContactsForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup): BaseFilterOptions<model.Contact>;
            allContactsForSelf(): FilterOptions<model.Contact>;
            byFormIdsForDataOwner(dataOwnerId: string, formIds: Array<string>): BaseFilterOptions<model.Contact>;
            byFormIdsForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, formIds: Array<string>): BaseFilterOptions<model.Contact>;
            byFormIdsForSelf(formIds: Array<string>): FilterOptions<model.Contact>;
            byPatientsOpeningDateForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Contact>;
            byPatientsOpeningDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.GroupScoped<model.Patient>>, options: any): SortableFilterOptions<model.Contact>;
            byPatientsOpeningDateForSelf(patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Contact>;
            byPatientSecretIdsOpeningDateForDataOwner(dataOwnerId: string, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.Contact>;
            byPatientSecretIdsOpeningDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.Contact>;
            byPatientSecretIdsOpeningDateForSelf(secretIds: Array<string>, options: any): SortableFilterOptions<model.Contact>;
            byIdentifiersForSelf(identifiers: Array<model.Identifier>): FilterOptions<model.Contact>;
            byIdentifiersForDataOwner(dataOwnerId: string, identifiers: Array<model.Identifier>): BaseFilterOptions<model.Contact>;
            byIdentifiersForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, identifiers: Array<model.Identifier>): BaseFilterOptions<model.Contact>;
            byCodeAndOpeningDateForDataOwner(dataOwnerId: string, codeType: string, options: any): BaseSortableFilterOptions<model.Contact>;
            byCodeAndOpeningDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, codeType: string, options: any): BaseSortableFilterOptions<model.Contact>;
            byCodeAndOpeningDateForSelf(codeType: string, options: any): SortableFilterOptions<model.Contact>;
            byTagAndOpeningDateForDataOwner(dataOwnerId: string, tagType: string, options: any): BaseSortableFilterOptions<model.Contact>;
            byTagAndOpeningDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, tagType: string, options: any): BaseSortableFilterOptions<model.Contact>;
            byOpeningDateForDataOwner(dataOwnerId: string, options: any): BaseSortableFilterOptions<model.Contact>;
            byOpeningDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, options: any): BaseSortableFilterOptions<model.Contact>;
            byOpeningDateForSelf(options: any): SortableFilterOptions<model.Contact>;
            byServiceTagForSelf(tagType: string, options: any): FilterOptions<model.Contact>;
            byServiceTagForDataOwner(dataOwnerId: string, tagType: string, options: any): BaseFilterOptions<model.Contact>;
            byServiceTagForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, tagType: string, options: any): BaseFilterOptions<model.Contact>;
            byServiceCodeForSelf(codeType: string, options: any): FilterOptions<model.Contact>;
            byServiceCodeForDataOwner(dataOwnerId: string, codeType: string, options: any): BaseFilterOptions<model.Contact>;
            byServiceCodeForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, codeType: string, options: any): BaseFilterOptions<model.Contact>;
            byTagAndOpeningDateForSelf(tagType: string, options: any): SortableFilterOptions<model.Contact>;
            byPatientsForDataOwner(dataOwnerId: string, patients: Array<model.Patient>): FilterOptions<model.Contact>;
            byPatientsForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.GroupScoped<model.Patient>>): FilterOptions<model.Contact>;
            byPatientsForSelf(patients: Array<model.Patient>): FilterOptions<model.Contact>;
            byPatientsSecretIdsForDataOwner(dataOwnerId: string, secretIds: Array<string>): BaseFilterOptions<model.Contact>;
            byPatientsSecretIdsForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, secretIds: Array<string>): BaseFilterOptions<model.Contact>;
            byPatientsSecretIdsForSelf(secretIds: Array<string>): FilterOptions<model.Contact>;
            byServiceIds(serviceIds: Array<string>): BaseSortableFilterOptions<model.Contact>;
            private constructor();
        }
    }
}
export declare abstract class InternalDeviceFiltersObj {
    static readonly getInstance: () => typeof InternalDeviceFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalDeviceFiltersObj {
    /** @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 {
            all(): BaseFilterOptions<model.Device>;
            byResponsible(responsibleId: string): BaseFilterOptions<model.Device>;
            byResponsibleInGroup(responsible: model.EntityReferenceInGroup): BaseFilterOptions<model.Device>;
            byIds(ids: Array<string>): BaseSortableFilterOptions<model.Device>;
            private constructor();
        }
    }
}
export declare abstract class InternalDocumentFiltersObj {
    static readonly getInstance: () => typeof InternalDocumentFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalDocumentFiltersObj {
    /** @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 {
            byPatientsCreatedForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Document>;
            byPatientsCreatedForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.GroupScoped<model.Patient>>, options: any): SortableFilterOptions<model.Document>;
            byMessagesCreatedForDataOwner(dataOwnerId: string, messages: Array<model.Message>, options: any): SortableFilterOptions<model.Document>;
            byMessagesCreatedForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, messages: Array<model.GroupScoped<model.Message>>, options: any): SortableFilterOptions<model.Document>;
            byPatientsCreatedForSelf(patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Document>;
            byMessagesCreatedForSelf(messages: Array<model.Message>, options: any): SortableFilterOptions<model.Document>;
            byOwningEntitySecretIdsCreatedForDataOwner(dataOwnerId: string, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.Document>;
            byOwningEntitySecretIdsCreatedForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.Document>;
            byOwningEntitySecretIdsCreatedForSelf(secretIds: Array<string>, options: any): SortableFilterOptions<model.Document>;
            byPatientsAndTypeForDataOwner(dataOwnerId: string, documentType: string, patients: Array<model.Patient>): FilterOptions<model.Document>;
            byPatientsAndTypeForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, documentType: string, patients: Array<model.GroupScoped<model.Patient>>): FilterOptions<model.Document>;
            byMessagesAndTypeForDataOwner(dataOwnerId: string, documentType: string, messages: Array<model.Message>): FilterOptions<model.Document>;
            byMessagesAndTypeForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, documentType: string, messages: Array<model.GroupScoped<model.Message>>): FilterOptions<model.Document>;
            byPatientsAndTypeForSelf(documentType: string, patients: Array<model.Patient>): FilterOptions<model.Document>;
            byMessagesAndTypeForSelf(documentType: string, messages: Array<model.Message>): FilterOptions<model.Document>;
            byOwningEntitySecretIdsAndTypeForDataOwner(dataOwnerId: string, documentType: string, secretIds: Array<string>): FilterOptions<model.Document>;
            byOwningEntitySecretIdsAndTypeForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, documentType: string, secretIds: Array<string>): FilterOptions<model.Document>;
            byOwningEntitySecretIdsAndTypeForSelf(documentType: string, secretIds: Array<string>): FilterOptions<model.Document>;
            byCodeForDataOwner(dataOwnerId: string, codeType: string, options: any): BaseFilterOptions<model.Document>;
            byCodeForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, codeType: string, options: any): BaseFilterOptions<model.Document>;
            byCodeForSelf(codeType: string, options: any): SortableFilterOptions<model.Document>;
            byTagForDataOwner(dataOwnerId: string, tagType: string, options: any): BaseFilterOptions<model.Document>;
            byTagForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, tagType: string, options: any): BaseFilterOptions<model.Document>;
            byTagForSelf(tagType: string, options: any): FilterOptions<model.Document>;
            private constructor();
        }
    }
}
export declare abstract class InternalFormFiltersObj {
    static readonly getInstance: () => typeof InternalFormFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalFormFiltersObj {
    /** @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 {
            byParentIdForDataOwner(dataOwnerId: string, parentId: string): BaseFilterOptions<model.Form>;
            byParentIdForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, parentId: string): BaseFilterOptions<model.Form>;
            byParentIdForSelf(parentId: string): FilterOptions<model.Form>;
            byPatientsOpeningDateForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Form>;
            byPatientsOpeningDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.GroupScoped<model.Patient>>, options: any): SortableFilterOptions<model.Form>;
            byPatientsOpeningDateForSelf(patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Form>;
            byPatientSecretIdsOpeningDateForDataOwner(dataOwnerId: string, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.Form>;
            byPatientSecretIdsOpeningDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.Form>;
            byPatientSecretIdsOpeningDateForSelf(secretIds: Array<string>, options: any): SortableFilterOptions<model.Form>;
            byUniqueId(uniqueId: string, options: any): BaseSortableFilterOptions<model.Form>;
            private constructor();
        }
    }
}
export declare abstract class InternalFormTemplateFiltersObj {
    static readonly getInstance: () => typeof InternalFormTemplateFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalFormTemplateFiltersObj {
    /** @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 {
            bySpecialtyCode(specialtyCode: string): BaseFilterOptions<model.FormTemplate>;
            private constructor();
        }
    }
}
export declare abstract class InternalGroupFiltersObj {
    static readonly getInstance: () => typeof InternalGroupFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalGroupFiltersObj {
    /** @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 {
            all(): BaseFilterOptions<model.Group>;
            bySuperGroup(superGroupId: string): BaseFilterOptions<model.Group>;
            withContent(superGroupId: string, searchString: string): BaseSortableFilterOptions<model.Group>;
            private constructor();
        }
    }
}
export declare abstract class InternalHealthElementFiltersObj {
    static readonly getInstance: () => typeof InternalHealthElementFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalHealthElementFiltersObj {
    /** @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 {
            allHealthElementsForDataOwner(dataOwnerId: string): BaseFilterOptions<model.HealthElement>;
            allHealthElementsForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup): BaseFilterOptions<model.HealthElement>;
            allHealthElementsForSelf(): FilterOptions<model.HealthElement>;
            byIdentifiersForDataOwner(dataOwnerId: string, identifiers: Array<model.Identifier>): BaseFilterOptions<model.HealthElement>;
            byIdentifiersForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, identifiers: Array<model.Identifier>): BaseFilterOptions<model.HealthElement>;
            byIdentifiersForSelf(identifiers: Array<model.Identifier>): FilterOptions<model.HealthElement>;
            byCodeForDataOwner(dataOwnerId: string, codeType: string, options: any): BaseFilterOptions<model.HealthElement>;
            byCodeForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, codeType: string, options: any): BaseFilterOptions<model.HealthElement>;
            byCodeForSelf(codeType: string, options: any): FilterOptions<model.HealthElement>;
            byTagForDataOwner(dataOwnerId: string, tagType: string, options: any): BaseFilterOptions<model.HealthElement>;
            byTagForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, tagType: string, options: any): BaseFilterOptions<model.HealthElement>;
            byTagForSelf(tagType: string, options: any): FilterOptions<model.HealthElement>;
            byPatientsForDataOwner(dataOwnerId: string, patients: Array<model.Patient>): FilterOptions<model.HealthElement>;
            byPatientsForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.GroupScoped<model.Patient>>): FilterOptions<model.HealthElement>;
            byPatientsForSelf(patients: Array<model.Patient>): FilterOptions<model.HealthElement>;
            byPatientsSecretIdsForDataOwner(dataOwnerId: string, secretIds: Array<string>): BaseFilterOptions<model.HealthElement>;
            byPatientsSecretIdsForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, secretIds: Array<string>): BaseFilterOptions<model.HealthElement>;
            byPatientsSecretIdsForSelf(secretIds: Array<string>): FilterOptions<model.HealthElement>;
            byIds(ids: Array<string>): BaseSortableFilterOptions<model.HealthElement>;
            byPatientsOpeningDateForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, options: any): SortableFilterOptions<model.HealthElement>;
            byPatientsOpeningDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.GroupScoped<model.Patient>>, options: any): SortableFilterOptions<model.HealthElement>;
            byPatientsOpeningDateForSelf(patients: Array<model.Patient>, options: any): SortableFilterOptions<model.HealthElement>;
            byPatientSecretIdsOpeningDateForDataOwner(dataOwnerId: string, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.HealthElement>;
            byPatientSecretIdsOpeningDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.HealthElement>;
            byPatientSecretIdsOpeningDateForSelf(secretIds: Array<string>, options: any): SortableFilterOptions<model.HealthElement>;
            private constructor();
        }
    }
}
export declare abstract class InternalHealthcarePartyFiltersObj {
    static readonly getInstance: () => typeof InternalHealthcarePartyFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalHealthcarePartyFiltersObj {
    /** @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 {
            all(): BaseFilterOptions<model.HealthcareParty>;
            byIdentifiers(identifiers: Array<model.Identifier>): BaseFilterOptions<model.HealthcareParty>;
            byCode(codeType: string, options: any): BaseSortableFilterOptions<model.HealthcareParty>;
            byTag(tagType: string, options: any): BaseSortableFilterOptions<model.HealthcareParty>;
            byIds(ids: Array<string>): SortableFilterOptions<model.HealthcareParty>;
            byName(searchString: string, options: any): BaseSortableFilterOptions<model.HealthcareParty>;
            byNationalIdentifier(searchString: string, options: any): BaseSortableFilterOptions<model.HealthcareParty>;
            byParentId(parentId: string): BaseFilterOptions<model.HealthcareParty>;
            private constructor();
        }
    }
}
export declare abstract class InternalInsuranceFiltersObj {
    static readonly getInstance: () => typeof InternalInsuranceFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalInsuranceFiltersObj {
    /** @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 {
            all(): BaseFilterOptions<model.Insurance>;
            byIdentifiers(identifiers: Array<model.Identifier>): BaseFilterOptions<model.Insurance>;
            byCode(codeType: string, options: any): BaseSortableFilterOptions<model.Insurance>;
            byTag(tagType: string, options: any): BaseSortableFilterOptions<model.Insurance>;
            private constructor();
        }
    }
}
export declare abstract class InternalMaintenanceTaskFiltersObj {
    static readonly getInstance: () => typeof InternalMaintenanceTaskFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalMaintenanceTaskFiltersObj {
    /** @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 {
            byIds(ids: Array<string>): BaseSortableFilterOptions<model.MaintenanceTask>;
            byIdentifiersForDataOwner(dataOwnerId: string, identifiers: Array<model.Identifier>): BaseFilterOptions<model.MaintenanceTask>;
            byIdentifiersForSelf(identifiers: Array<model.Identifier>): FilterOptions<model.MaintenanceTask>;
            byTypeForDataOwner(dataOwnerId: string, type: string): BaseFilterOptions<model.MaintenanceTask>;
            byTypeForSelf(type: string): FilterOptions<model.MaintenanceTask>;
            afterDateForDataOwner(dataOwnerId: string, date: number): BaseSortableFilterOptions<model.MaintenanceTask>;
            afterDateForSelf(date: number): SortableFilterOptions<model.MaintenanceTask>;
            private constructor();
        }
    }
}
export declare abstract class InternalMessageFiltersObj {
    static readonly getInstance: () => typeof InternalMessageFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalMessageFiltersObj {
    /** @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 {
            allMessagesForDataOwner(dataOwnerId: string): BaseFilterOptions<model.Message>;
            allMessagesForSelf(): FilterOptions<model.Message>;
            byTransportGuidForDataOwner(dataOwnerId: string, transportGuid: string): BaseFilterOptions<model.Message>;
            byTransportGuidForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, transportGuid: string): BaseFilterOptions<model.Message>;
            byTransportGuidForSelf(transportGuid: string): FilterOptions<model.Message>;
            fromAddressForDataOwner(dataOwnerId: string, address: string): BaseFilterOptions<model.Message>;
            fromAddressForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, address: string): BaseFilterOptions<model.Message>;
            fromAddressForSelf(address: string): FilterOptions<model.Message>;
            byPatientsSentDateForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Message>;
            byPatientsSentDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.GroupScoped<model.Patient>>, options: any): SortableFilterOptions<model.Message>;
            byPatientsSentDateForSelf(patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Message>;
            byPatientSecretIdsSentDateForDataOwner(dataOwnerId: string, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.Message>;
            byPatientSecretIdsSentDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.Message>;
            byPatientSecretIdsSentDateForSelf(secretIds: Array<string>, options: any): SortableFilterOptions<model.Message>;
            toAddressForDataOwner(dataOwnerId: string, address: string): BaseFilterOptions<model.Message>;
            toAddressForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, address: string): BaseFilterOptions<model.Message>;
            toAddressForSelf(address: string): FilterOptions<model.Message>;
            byTransportGuidSentDateForDataOwner(dataOwnerId: string, transportGuid: string, from: Nullable<number>, to: Nullable<number>, options: any): BaseFilterOptions<model.Message>;
            byTransportGuidSentDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, transportGuid: string, from: Nullable<number>, to: Nullable<number>, options: any): BaseFilterOptions<model.Message>;
            byTransportGuidSentDateForSelf(transportGuid: string, from: Nullable<number>, to: Nullable<number>, options: any): FilterOptions<model.Message>;
            latestByTransportGuidForDataOwner(dataOwnerId: string, transportGuid: string): BaseFilterOptions<model.Message>;
            latestByTransportGuidForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, transportGuid: string): BaseFilterOptions<model.Message>;
            latestByTransportGuidForSelf(transportGuid: string): FilterOptions<model.Message>;
            byInvoiceIds(invoiceIds: Array<string>): BaseFilterOptions<model.Message>;
            byParentIds(parentIds: Array<string>): BaseFilterOptions<model.Message>;
            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>;
            byCodeForDataOwner(dataOwnerId: string, codeType: string, options: any): BaseSortableFilterOptions<model.Message>;
            byCodeForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, codeType: string, options: any): BaseSortableFilterOptions<model.Message>;
            byCodeForSelf(codeType: string, options: any): FilterOptions<model.Message>;
            byTagForDataOwner(dataOwnerId: string, tagType: string, options: any): BaseSortableFilterOptions<model.Message>;
            byTagForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, tagType: string, options: any): BaseSortableFilterOptions<model.Message>;
            byTagForSelf(tagType: string, options: any): FilterOptions<model.Message>;
            private constructor();
        }
    }
}
export declare abstract class InternalPatientFiltersObj {
    static readonly getInstance: () => typeof InternalPatientFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalPatientFiltersObj {
    /** @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 {
            allPatientsForDataOwner(dataOwnerId: string): BaseFilterOptions<model.Patient>;
            allPatientsForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup): BaseFilterOptions<model.Patient>;
            allPatientsForSelf(): FilterOptions<model.Patient>;
            byIds(ids: Array<string>): SortableFilterOptions<model.Patient>;
            byIdentifiersForDataOwner(dataOwnerId: string, identifiers: Array<model.Identifier>): BaseFilterOptions<model.Patient>;
            byIdentifiersForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, identifiers: Array<model.Identifier>): BaseFilterOptions<model.Patient>;
            bySsinsForDataOwner(dataOwnerId: string, ssins: Array<string>): BaseFilterOptions<model.Patient>;
            bySsinsForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, ssins: Array<string>): BaseFilterOptions<model.Patient>;
            byDateOfBirthBetweenForDataOwner(dataOwnerId: string, fromDate: number, toDate: number): BaseFilterOptions<model.Patient>;
            byDateOfBirthBetweenForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, fromDate: number, toDate: number): BaseFilterOptions<model.Patient>;
            byFuzzyNameForDataOwner(dataOwnerId: string, searchString: string): BaseFilterOptions<model.Patient>;
            byFuzzyNameForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, searchString: string): BaseFilterOptions<model.Patient>;
            byGenderEducationProfessionForDataOwner(dataOwnerId: string, gender: string, options: any): BaseFilterOptions<model.Patient>;
            byGenderEducationProfessionForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, gender: string, options: any): BaseFilterOptions<model.Patient>;
            byActiveForDataOwner(dataOwnerId: string, active: boolean): BaseFilterOptions<model.Patient>;
            byActiveForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, active: boolean): BaseFilterOptions<model.Patient>;
            byTelecomForDataOwner(dataOwnerId: string, searchString: string): BaseFilterOptions<model.Patient>;
            byTelecomForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, searchString: string): BaseFilterOptions<model.Patient>;
            byAddressPostalCodeHouseNumberForDataOwner(dataOwnerId: string, searchString: string, postalCode: string, options: any): BaseFilterOptions<model.Patient>;
            byAddressPostalCodeHouseNumberForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, searchString: string, postalCode: string, options: any): BaseFilterOptions<model.Patient>;
            byAddressForDataOwner(dataOwnerId: string, searchString: string): BaseFilterOptions<model.Patient>;
            byAddressForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, searchString: string): BaseFilterOptions<model.Patient>;
            byIdentifiersForSelf(identifiers: Array<model.Identifier>): FilterOptions<model.Patient>;
            bySsinsForSelf(ssins: Array<string>): FilterOptions<model.Patient>;
            byDateOfBirthBetweenForSelf(fromDate: number, toDate: number): FilterOptions<model.Patient>;
            byNameForSelf(searchString: string): FilterOptions<model.Patient>;
            byGenderEducationProfessionForSelf(gender: string, options: any): FilterOptions<model.Patient>;
            byActiveForSelf(active: boolean): FilterOptions<model.Patient>;
            byTelecomForSelf(searchString: string): FilterOptions<model.Patient>;
            byAddressPostalCodeHouseNumberForSelf(searchString: string, postalCode: string, options: any): FilterOptions<model.Patient>;
            byAddressForSelf(searchString: string): FilterOptions<model.Patient>;
            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>;
            private constructor();
        }
    }
}
export declare abstract class InternalRelatedPersonFiltersObj {
    static readonly getInstance: () => typeof InternalRelatedPersonFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalRelatedPersonFiltersObj {
    /** @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 {
            allRelatedPersonsForDataOwner(dataOwnerId: string): BaseFilterOptions<model.RelatedPerson>;
            allRelatedPersonsForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup): BaseFilterOptions<model.RelatedPerson>;
            allRelatedPersonsForSelf(): FilterOptions<model.RelatedPerson>;
            byIdentifiersForDataOwner(dataOwnerId: string, identifiers: Array<model.Identifier>): BaseFilterOptions<model.RelatedPerson>;
            byIdentifiersForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, identifiers: Array<model.Identifier>): BaseFilterOptions<model.RelatedPerson>;
            byIdentifiersForSelf(identifiers: Array<model.Identifier>): FilterOptions<model.RelatedPerson>;
            byNameForDataOwner(dataOwnerId: string, name: string): BaseFilterOptions<model.RelatedPerson>;
            byNameForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, name: string): BaseFilterOptions<model.RelatedPerson>;
            byNameForSelf(name: string): FilterOptions<model.RelatedPerson>;
            byIds(ids: Array<string>): BaseSortableFilterOptions<model.RelatedPerson>;
            private constructor();
        }
    }
}
export declare abstract class InternalServiceFiltersObj {
    static readonly getInstance: () => typeof InternalServiceFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalServiceFiltersObj {
    /** @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 {
            allServicesForDataOwner(dataOwnerId: string): BaseFilterOptions<model.Service>;
            allServicesForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup): BaseFilterOptions<model.Service>;
            allServicesForSelf(): FilterOptions<model.Service>;
            byIdentifiersForDataOwner(dataOwnerId: string, identifiers: Array<model.Identifier>): BaseFilterOptions<model.Service>;
            byIdentifiersForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, identifiers: Array<model.Identifier>): BaseFilterOptions<model.Service>;
            byCodeAndValueDateForDataOwner(dataOwnerId: string, codeType: string, options: any): BaseFilterOptions<model.Service>;
            byCodeAndValueDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, codeType: string, options: any): BaseFilterOptions<model.Service>;
            byTagAndValueDateForDataOwner(dataOwnerId: string, tagType: string, options: any): BaseFilterOptions<model.Service>;
            byTagAndValueDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, tagType: string, options: any): BaseFilterOptions<model.Service>;
            byPatientsForDataOwner(dataOwnerId: string, patients: Array<model.Patient>): FilterOptions<model.Service>;
            byPatientsForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.Patient>): FilterOptions<model.Service>;
            byPatientsSecretIdsForDataOwner(dataOwnerId: string, secretIds: Array<string>): BaseFilterOptions<model.Service>;
            byPatientsSecretIdsForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, secretIds: Array<string>): BaseFilterOptions<model.Service>;
            byHealthElementIdFromSubContactForDataOwner(dataOwnerId: string, healthElementIds: Array<string>): BaseFilterOptions<model.Service>;
            byHealthElementIdFromSubContactForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, healthElementIds: Array<string>): BaseFilterOptions<model.Service>;
            byIdentifiersForSelf(identifiers: Array<model.Identifier>): FilterOptions<model.Service>;
            byCodeAndValueDateForSelf(codeType: string, options: any): FilterOptions<model.Service>;
            byTagAndValueDateForSelf(tagType: string, options: any): FilterOptions<model.Service>;
            byPatientsForSelf(patients: Array<model.Patient>): FilterOptions<model.Service>;
            byPatientsSecretIdsForSelf(secretIds: Array<string>): FilterOptions<model.Service>;
            byHealthElementIdFromSubContactForSelf(healthElementIds: Array<string>): FilterOptions<model.Service>;
            byIds(ids: Array<string>): BaseSortableFilterOptions<model.Service>;
            byAssociationId(associationId: string): BaseFilterOptions<model.Service>;
            byQualifiedLink(linkValues: Array<string>, options: any): BaseFilterOptions<model.Service>;
            byPatientsDateForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Service>;
            byPatientsDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Service>;
            byPatientsDateForSelf(patients: Array<model.Patient>, options: any): SortableFilterOptions<model.Service>;
            byPatientSecretIdsDateForDataOwner(dataOwnerId: string, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.Service>;
            byPatientSecretIdsDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, secretIds: Array<string>, options: any): BaseSortableFilterOptions<model.Service>;
            byPatientSecretIdsDateForSelf(secretIds: Array<string>, options: any): SortableFilterOptions<model.Service>;
            byCodesAndValueDateForDataOwner(dataOwnerId: string, codeCodes: Record<string, Array<string>>, options: any): BaseFilterOptions<model.Service>;
            byCodesAndValueDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, codeCodes: Record<string, Array<string>>, options: any): BaseFilterOptions<model.Service>;
            byCodesAndValueDateForSelf(codeCodes: Record<string, Array<string>>, options: any): FilterOptions<model.Service>;
            byCodePrefixAndValueDateForDataOwner(dataOwnerId: string, codeType: string, codeCodePrefix: string, options: any): BaseFilterOptions<model.Service>;
            byCodePrefixAndValueDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, codeType: string, codeCodePrefix: string, options: any): BaseFilterOptions<model.Service>;
            byCodePrefixAndValueDateForSelf(codeType: string, codeCodePrefix: string, options: any): FilterOptions<model.Service>;
            byTagCodesAndValueDateForDataOwner(dataOwnerId: string, tagCodes: Record<string, Array<string>>, options: any): BaseFilterOptions<model.Service>;
            byTagCodesAndValueDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, tagCodes: Record<string, Array<string>>, options: any): BaseFilterOptions<model.Service>;
            byTagCodesAndValueDateForSelf(tagCodes: Record<string, Array<string>>, options: any): FilterOptions<model.Service>;
            byTagPrefixAndValueDateForDataOwner(dataOwnerId: string, tagType: string, tagCodePrefix: string, options: any): BaseFilterOptions<model.Service>;
            byTagPrefixAndValueDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, tagType: string, tagCodePrefix: string, options: any): BaseFilterOptions<model.Service>;
            byTagPrefixAndValueDateForSelf(tagType: string, tagCodePrefix: string, options: any): FilterOptions<model.Service>;
            byPatientsCodesAndValueDateForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, codeCodes: Record<string, Array<string>>, options: any): FilterOptions<model.Service>;
            byPatientsCodesAndValueDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.Patient>, codeCodes: Record<string, Array<string>>, options: any): FilterOptions<model.Service>;
            byPatientsCodesAndValueDateForSelf(patients: Array<model.Patient>, codeCodes: Record<string, Array<string>>, options: any): FilterOptions<model.Service>;
            byPatientSecretIdsCodesAndValueDateForDataOwner(dataOwnerId: string, secretIds: Array<string>, codeCodes: Record<string, Array<string>>, options: any): BaseFilterOptions<model.Service>;
            byPatientSecretIdsCodesAndValueDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, secretIds: Array<string>, codeCodes: Record<string, Array<string>>, options: any): BaseFilterOptions<model.Service>;
            byPatientSecretIdsCodesAndValueDateForSelf(secretIds: Array<string>, codeCodes: Record<string, Array<string>>, options: any): FilterOptions<model.Service>;
            byPatientsCodePrefixAndValueDateForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, codeType: string, codeCodePrefix: string, options: any): FilterOptions<model.Service>;
            byPatientsCodePrefixAndValueDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.Patient>, codeType: string, codeCodePrefix: string, options: any): FilterOptions<model.Service>;
            byPatientsCodePrefixAndValueDateForSelf(patients: Array<model.Patient>, codeType: string, codeCodePrefix: string, options: any): FilterOptions<model.Service>;
            byPatientSecretIdsCodePrefixAndValueDateForDataOwner(dataOwnerId: string, secretIds: Array<string>, codeType: string, codeCodePrefix: string, options: any): BaseFilterOptions<model.Service>;
            byPatientSecretIdsCodePrefixAndValueDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, secretIds: Array<string>, codeType: string, codeCodePrefix: string, options: any): BaseFilterOptions<model.Service>;
            byPatientSecretIdsCodePrefixAndValueDateForSelf(secretIds: Array<string>, codeType: string, codeCodePrefix: string, options: any): FilterOptions<model.Service>;
            byPatientsTagCodesAndValueDateForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, tagCodes: Record<string, Array<string>>, options: any): FilterOptions<model.Service>;
            byPatientsTagCodesAndValueDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.Patient>, tagCodes: Record<string, Array<string>>, options: any): FilterOptions<model.Service>;
            byPatientsTagCodesAndValueDateForSelf(patients: Array<model.Patient>, tagCodes: Record<string, Array<string>>, options: any): FilterOptions<model.Service>;
            byPatientSecretIdsTagCodesAndValueDateForDataOwner(dataOwnerId: string, secretIds: Array<string>, tagCodes: Record<string, Array<string>>, options: any): BaseFilterOptions<model.Service>;
            byPatientSecretIdsTagCodesAndValueDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, secretIds: Array<string>, tagCodes: Record<string, Array<string>>, options: any): BaseFilterOptions<model.Service>;
            byPatientSecretIdsTagCodesAndValueDateForSelf(secretIds: Array<string>, tagCodes: Record<string, Array<string>>, options: any): FilterOptions<model.Service>;
            byPatientsTagPrefixAndValueDateForDataOwner(dataOwnerId: string, patients: Array<model.Patient>, tagType: string, tagCodePrefix: string, options: any): FilterOptions<model.Service>;
            byPatientsTagPrefixAndValueDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, patients: Array<model.Patient>, tagType: string, tagCodePrefix: string, options: any): FilterOptions<model.Service>;
            byPatientsTagPrefixAndValueDateForSelf(patients: Array<model.Patient>, tagType: string, tagCodePrefix: string, options: any): FilterOptions<model.Service>;
            byPatientSecretIdsTagPrefixAndValueDateForDataOwner(dataOwnerId: string, secretIds: Array<string>, tagType: string, tagCodePrefix: string, options: any): BaseFilterOptions<model.Service>;
            byPatientSecretIdsTagPrefixAndValueDateForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup, secretIds: Array<string>, tagType: string, tagCodePrefix: string, options: any): BaseFilterOptions<model.Service>;
            byPatientSecretIdsTagPrefixAndValueDateForSelf(secretIds: Array<string>, tagType: string, tagCodePrefix: string, options: any): FilterOptions<model.Service>;
            private constructor();
        }
    }
}
export declare abstract class InternalTopicFiltersObj {
    static readonly getInstance: () => typeof InternalTopicFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalTopicFiltersObj {
    /** @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 {
            allTopicsForDataOwner(dataOwnerId: string): BaseFilterOptions<model.Topic>;
            allTopicsForDataOwnerInGroup(dataOwner: model.EntityReferenceInGroup): BaseFilterOptions<model.Topic>;
            allTopicsForSelf(): FilterOptions<model.Topic>;
            byParticipant(participantId: string): FilterOptions<model.Topic>;
            byParticipantInGroup(participant: model.EntityReferenceInGroup): FilterOptions<model.Topic>;
            private constructor();
        }
    }
}
export declare abstract class InternalUserFiltersObj {
    static readonly getInstance: () => typeof InternalUserFiltersObj.$metadata$.type;
    private constructor();
}
export declare namespace InternalUserFiltersObj {
    /** @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 {
            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>;
            private constructor();
        }
    }
}
export declare abstract class InternalKeyPairUpdateNotificationJs_COMPANION {
    static readonly getInstance: () => typeof InternalKeyPairUpdateNotificationJs_COMPANION.$metadata$.type;
    private constructor();
}
export declare namespace InternalKeyPairUpdateNotificationJs_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 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;
    };
}
export declare interface CardinalKeyStorageOptions {
    readonly __doNotUseOrImplementIt: {
        readonly "com.icure.cardinal.sdk.js.storage.CardinalKeyStorageOptions": unique symbol;
    };
}
export declare abstract class InternalCardinalStorageOptionsFactory {
    static readonly getInstance: () => typeof InternalCardinalStorageOptionsFactory.$metadata$.type;
    private constructor();
}
export declare namespace InternalCardinalStorageOptionsFactory {
    /** @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 {
            fileSystem(directory: string): CardinalStorageOptions;
            browserLocalStorage(): CardinalStorageOptions;
            private constructor();
        }
    }
}
export declare abstract class InternalCardinalKeyStorageOptionsFactory {
    static readonly getInstance: () => typeof InternalCardinalKeyStorageOptionsFactory.$metadata$.type;
    private constructor();
}
export declare namespace InternalCardinalKeyStorageOptionsFactory {
    /** @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 {
            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;
export declare function hexDecode(hexString: string): Int8Array;
export declare function base64Encode(bytes: Int8Array): string;
export declare function base64Decode(base64String: string): Int8Array;
export declare function allPublicKeysOf(cryptoActor: model.CryptoActor): Array<string>;
export declare interface PaginatedListIterator<T extends any> {
    hasNext(): Promise<boolean>;
    next(limit: number): Promise<Array<T>>;
    readonly __doNotUseOrImplementIt: {
        readonly "com.icure.cardinal.sdk.js.utils.pagination.PaginatedListIterator": unique symbol;
    };
}
export * from './filters.mjs'
export * from './storage.mjs'
export * from './sdk.mjs'
export * from './subscription.mjs'
export * from './crypto.mjs'
export * from './auth.mjs'
export * from './options.mjs'
export * from './kerberus.mjs'
export * from './utils.mjs'
export * from './api.mjs'
export * from './model.mjs'