@icure/cardinal-sdk 1.0.0-RC.1

package/api/CalendarItemFlavouredApi.d.mts

@@ -0,0 +1,27 @@
+import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { CalendarItemShareOptions } from '../crypto/entities/CalendarItemShareOptions.mjs';
+import { CalendarItem } from '../model/CalendarItem.mjs';
+import { PaginatedList } from '../model/PaginatedList.mjs';
+import { Patient } from '../model/Patient.mjs';
+export interface CalendarItemFlavouredApi<E extends CalendarItem> {
+    shareWith(delegateId: string, calendarItem: E, options?: {
+        options?: CalendarItemShareOptions | undefined;
+    }): Promise<E>;
+    shareWithMany(calendarItem: E, delegates: {
+        [key: string]: CalendarItemShareOptions;
+    }): Promise<E>;
+    findCalendarItemsByHcPartyPatient(hcPartyId: string, patient: Patient, options?: {
+        startDate?: number | undefined;
+        endDate?: number | undefined;
+        descending?: boolean | undefined;
+    }): Promise<PaginatedListIterator<E>>;
+    linkToPatient(calendarItem: CalendarItem, patient: Patient, shareLinkWithDelegates: Array<string>): Promise<E>;
+    filterCalendarItemsBy(filter: FilterOptions<CalendarItem>): Promise<PaginatedListIterator<E>>;
+    filterCalendarItemsBySorted(filter: SortableFilterOptions<CalendarItem>): Promise<PaginatedListIterator<E>>;
+    modifyCalendarItem(entity: E): Promise<E>;
+    getCalendarItem(entityId: string): Promise<E>;
+    getCalendarItems(entityIds: Array<string>): Promise<Array<E>>;
+    getCalendarItemsByPeriodAndHcPartyId(startDate: number, endDate: number, hcPartyId: string): Promise<Array<E>>;
+    getCalendarsByPeriodAndAgendaId(startDate: number, endDate: number, agendaId: string): Promise<Array<E>>;
+    findCalendarItemsByRecurrenceId(recurrenceId: string, startKey: string | undefined, startDocumentId: string | undefined, limit: number): Promise<PaginatedList<E>>;
+}

package/api/CalendarItemFlavouredApi.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=CalendarItemFlavouredApi.mjs.map

package/api/CalendarItemFlavouredApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CalendarItemFlavouredApi.mjs","sourceRoot":"","sources":["../../tsSourcesProject/api/CalendarItemFlavouredApi.mts"],"names":[],"mappings":"","sourcesContent":["// auto-generated file\nimport {FilterOptions, PaginatedListIterator, SortableFilterOptions} from '../cardinal-sdk-ts.mjs';\nimport {CalendarItemShareOptions} from '../crypto/entities/CalendarItemShareOptions.mjs';\nimport {CalendarItem} from '../model/CalendarItem.mjs';\nimport {PaginatedList} from '../model/PaginatedList.mjs';\nimport {Patient} from '../model/Patient.mjs';\n\n\nexport interface CalendarItemFlavouredApi<E extends CalendarItem> {\n\n\tshareWith(delegateId: string, calendarItem: E,\n\t\t\toptions?: { options?: CalendarItemShareOptions | undefined }): Promise<E>;\n\n\tshareWithMany(calendarItem: E,\n\t\t\tdelegates: { [ key: string ]: CalendarItemShareOptions }): Promise<E>;\n\n\tfindCalendarItemsByHcPartyPatient(hcPartyId: string, patient: Patient,\n\t\t\toptions?: { startDate?: number | undefined, endDate?: number | undefined, descending?: boolean | undefined }): Promise<PaginatedListIterator<E>>;\n\n\tlinkToPatient(calendarItem: CalendarItem, patient: Patient,\n\t\t\tshareLinkWithDelegates: Array<string>): Promise<E>;\n\n\tfilterCalendarItemsBy(filter: FilterOptions<CalendarItem>): Promise<PaginatedListIterator<E>>;\n\n\tfilterCalendarItemsBySorted(filter: SortableFilterOptions<CalendarItem>): Promise<PaginatedListIterator<E>>;\n\n\tmodifyCalendarItem(entity: E): Promise<E>;\n\n\tgetCalendarItem(entityId: string): Promise<E>;\n\n\tgetCalendarItems(entityIds: Array<string>): Promise<Array<E>>;\n\n\tgetCalendarItemsByPeriodAndHcPartyId(startDate: number, endDate: number,\n\t\t\thcPartyId: string): Promise<Array<E>>;\n\n\tgetCalendarsByPeriodAndAgendaId(startDate: number, endDate: number,\n\t\t\tagendaId: string): Promise<Array<E>>;\n\n\tfindCalendarItemsByRecurrenceId(recurrenceId: string, startKey: string | undefined,\n\t\t\tstartDocumentId: string | undefined, limit: number): Promise<PaginatedList<E>>;\n\n}\n"]}

package/api/CardinalMaintenanceTaskApi.d.mts

@@ -0,0 +1,10 @@
+import { DataOwnerType } from '../model/DataOwnerType.mjs';
+import { KeyPairUpdateNotification } from '../model/sdk/KeyPairUpdateNotification.mjs';
+import { SpkiHexString } from '../model/specializations/SpkiHexString.mjs';
+export interface CardinalMaintenanceTaskApi {
+    applyKeyPairUpdate(updateRequest: KeyPairUpdateNotification): Promise<void>;
+    createKeyPairUpdateNotificationsToAllDelegationCounterparts(key: SpkiHexString, options?: {
+        requestToOwnerTypes?: Array<DataOwnerType> | undefined;
+    }): Promise<void>;
+    createKeyPairUpdateNotificationTo(dataOwnerId: string, key: SpkiHexString): Promise<void>;
+}

package/api/CardinalMaintenanceTaskApi.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=CardinalMaintenanceTaskApi.mjs.map

package/api/CardinalMaintenanceTaskApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CardinalMaintenanceTaskApi.mjs","sourceRoot":"","sources":["../../tsSourcesProject/api/CardinalMaintenanceTaskApi.mts"],"names":[],"mappings":"","sourcesContent":["// auto-generated file\nimport {DataOwnerType} from '../model/DataOwnerType.mjs';\nimport {KeyPairUpdateNotification} from '../model/sdk/KeyPairUpdateNotification.mjs';\nimport {SpkiHexString} from '../model/specializations/SpkiHexString.mjs';\n\n\nexport interface CardinalMaintenanceTaskApi {\n\n\tapplyKeyPairUpdate(updateRequest: KeyPairUpdateNotification): Promise<void>;\n\n\tcreateKeyPairUpdateNotificationsToAllDelegationCounterparts(key: SpkiHexString,\n\t\t\toptions?: { requestToOwnerTypes?: Array<DataOwnerType> | undefined }): Promise<void>;\n\n\tcreateKeyPairUpdateNotificationTo(dataOwnerId: string, key: SpkiHexString): Promise<void>;\n\n}\n"]}

package/api/ClassificationApi.d.mts

@@ -0,0 +1,48 @@
+import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { ClassificationShareOptions } from '../crypto/entities/ClassificationShareOptions.mjs';
+import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
+import { Classification, DecryptedClassification, EncryptedClassification } from '../model/Classification.mjs';
+import { Patient } from '../model/Patient.mjs';
+import { User } from '../model/User.mjs';
+import { DocIdentifier } from '../model/couchdb/DocIdentifier.mjs';
+import { AccessLevel } from '../model/embed/AccessLevel.mjs';
+import { HexString } from '../model/specializations/HexString.mjs';
+import { ClassificationFlavouredApi } from './ClassificationFlavouredApi.mjs';
+export interface ClassificationApi {
+    encrypted: ClassificationFlavouredApi<EncryptedClassification>;
+    tryAndRecover: ClassificationFlavouredApi<Classification>;
+    createClassification(entity: DecryptedClassification): Promise<DecryptedClassification>;
+    withEncryptionMetadata(base: DecryptedClassification | undefined, patient: Patient, options?: {
+        user?: User | undefined;
+        delegates?: {
+            [key: string]: AccessLevel;
+        };
+        secretId?: SecretIdUseOption;
+    }): Promise<DecryptedClassification>;
+    getEncryptionKeysOf(classification: Classification): Promise<Array<HexString>>;
+    hasWriteAccess(classification: Classification): Promise<boolean>;
+    decryptPatientIdOf(classification: Classification): Promise<Array<string>>;
+    createDelegationDeAnonymizationMetadata(entity: Classification, delegates: Array<string>): Promise<void>;
+    decrypt(classification: EncryptedClassification): Promise<DecryptedClassification>;
+    tryDecrypt(classification: EncryptedClassification): Promise<Classification>;
+    matchClassificationsBy(filter: FilterOptions<Classification>): Promise<Array<string>>;
+    matchClassificationsBySorted(filter: SortableFilterOptions<Classification>): Promise<Array<string>>;
+    deleteClassification(entityId: string): Promise<DocIdentifier>;
+    deleteClassifications(entityIds: Array<string>): Promise<Array<DocIdentifier>>;
+    shareWith(delegateId: string, classification: DecryptedClassification, options?: {
+        options?: ClassificationShareOptions | undefined;
+    }): Promise<DecryptedClassification>;
+    shareWithMany(classification: DecryptedClassification, delegates: {
+        [key: string]: ClassificationShareOptions;
+    }): Promise<DecryptedClassification>;
+    findClassificationsByHcPartyPatient(hcPartyId: string, patient: Patient, options?: {
+        startDate?: number | undefined;
+        endDate?: number | undefined;
+        descending?: boolean | undefined;
+    }): Promise<PaginatedListIterator<DecryptedClassification>>;
+    filterClassificationsBy(filter: FilterOptions<Classification>): Promise<PaginatedListIterator<DecryptedClassification>>;
+    filterClassificationsBySorted(filter: SortableFilterOptions<Classification>): Promise<PaginatedListIterator<DecryptedClassification>>;
+    modifyClassification(entity: DecryptedClassification): Promise<DecryptedClassification>;
+    getClassification(entityId: string): Promise<DecryptedClassification>;
+    getClassifications(entityIds: Array<string>): Promise<Array<DecryptedClassification>>;
+}

package/api/ClassificationApi.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ClassificationApi.mjs.map

package/api/ClassificationApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassificationApi.mjs","sourceRoot":"","sources":["../../tsSourcesProject/api/ClassificationApi.mts"],"names":[],"mappings":"","sourcesContent":["// auto-generated file\nimport {FilterOptions, PaginatedListIterator, SortableFilterOptions} from '../cardinal-sdk-ts.mjs';\nimport {ClassificationShareOptions} from '../crypto/entities/ClassificationShareOptions.mjs';\nimport {SecretIdUseOption} from '../crypto/entities/SecretIdUseOption.mjs';\nimport {Classification, DecryptedClassification, EncryptedClassification} from '../model/Classification.mjs';\nimport {Patient} from '../model/Patient.mjs';\nimport {User} from '../model/User.mjs';\nimport {DocIdentifier} from '../model/couchdb/DocIdentifier.mjs';\nimport {AccessLevel} from '../model/embed/AccessLevel.mjs';\nimport {HexString} from '../model/specializations/HexString.mjs';\nimport {ClassificationFlavouredApi} from './ClassificationFlavouredApi.mjs';\n\n\nexport interface ClassificationApi {\n\n\tencrypted: ClassificationFlavouredApi<EncryptedClassification>;\n\n\ttryAndRecover: ClassificationFlavouredApi<Classification>;\n\n\tcreateClassification(entity: DecryptedClassification): Promise<DecryptedClassification>;\n\n\twithEncryptionMetadata(base: DecryptedClassification | undefined, patient: Patient,\n\t\t\toptions?: { user?: User | undefined, delegates?: { [ key: string ]: AccessLevel }, secretId?: SecretIdUseOption }): Promise<DecryptedClassification>;\n\n\tgetEncryptionKeysOf(classification: Classification): Promise<Array<HexString>>;\n\n\thasWriteAccess(classification: Classification): Promise<boolean>;\n\n\tdecryptPatientIdOf(classification: Classification): Promise<Array<string>>;\n\n\tcreateDelegationDeAnonymizationMetadata(entity: Classification,\n\t\t\tdelegates: Array<string>): Promise<void>;\n\n\tdecrypt(classification: EncryptedClassification): Promise<DecryptedClassification>;\n\n\ttryDecrypt(classification: EncryptedClassification): Promise<Classification>;\n\n\tmatchClassificationsBy(filter: FilterOptions<Classification>): Promise<Array<string>>;\n\n\tmatchClassificationsBySorted(filter: SortableFilterOptions<Classification>): Promise<Array<string>>;\n\n\tdeleteClassification(entityId: string): Promise<DocIdentifier>;\n\n\tdeleteClassifications(entityIds: Array<string>): Promise<Array<DocIdentifier>>;\n\n\tshareWith(delegateId: string, classification: DecryptedClassification,\n\t\t\toptions?: { options?: ClassificationShareOptions | undefined }): Promise<DecryptedClassification>;\n\n\tshareWithMany(classification: DecryptedClassification,\n\t\t\tdelegates: { [ key: string ]: ClassificationShareOptions }): Promise<DecryptedClassification>;\n\n\tfindClassificationsByHcPartyPatient(hcPartyId: string, patient: Patient,\n\t\t\toptions?: { startDate?: number | undefined, endDate?: number | undefined, descending?: boolean | undefined }): Promise<PaginatedListIterator<DecryptedClassification>>;\n\n\tfilterClassificationsBy(filter: FilterOptions<Classification>): Promise<PaginatedListIterator<DecryptedClassification>>;\n\n\tfilterClassificationsBySorted(filter: SortableFilterOptions<Classification>): Promise<PaginatedListIterator<DecryptedClassification>>;\n\n\tmodifyClassification(entity: DecryptedClassification): Promise<DecryptedClassification>;\n\n\tgetClassification(entityId: string): Promise<DecryptedClassification>;\n\n\tgetClassifications(entityIds: Array<string>): Promise<Array<DecryptedClassification>>;\n\n}\n"]}

package/api/ClassificationBasicApi.d.mts

@@ -0,0 +1,14 @@
+import { BaseFilterOptions, BaseSortableFilterOptions, PaginatedListIterator } from '../cardinal-sdk-ts.mjs';
+import { Classification, EncryptedClassification } from '../model/Classification.mjs';
+import { DocIdentifier } from '../model/couchdb/DocIdentifier.mjs';
+export interface ClassificationBasicApi {
+    matchClassificationsBy(filter: BaseFilterOptions<Classification>): Promise<Array<string>>;
+    matchClassificationsBySorted(filter: BaseSortableFilterOptions<Classification>): Promise<Array<string>>;
+    filterClassificationsBy(filter: BaseFilterOptions<Classification>): Promise<PaginatedListIterator<EncryptedClassification>>;
+    filterClassificationsBySorted(filter: BaseSortableFilterOptions<Classification>): Promise<PaginatedListIterator<EncryptedClassification>>;
+    deleteClassification(entityId: string): Promise<DocIdentifier>;
+    deleteClassifications(entityIds: Array<string>): Promise<Array<DocIdentifier>>;
+    modifyClassification(entity: EncryptedClassification): Promise<EncryptedClassification>;
+    getClassification(entityId: string): Promise<EncryptedClassification>;
+    getClassifications(entityIds: Array<string>): Promise<Array<EncryptedClassification>>;
+}

package/api/ClassificationBasicApi.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ClassificationBasicApi.mjs.map

package/api/ClassificationBasicApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassificationBasicApi.mjs","sourceRoot":"","sources":["../../tsSourcesProject/api/ClassificationBasicApi.mts"],"names":[],"mappings":"","sourcesContent":["// auto-generated file\nimport {BaseFilterOptions, BaseSortableFilterOptions, PaginatedListIterator} from '../cardinal-sdk-ts.mjs';\nimport {Classification, EncryptedClassification} from '../model/Classification.mjs';\nimport {DocIdentifier} from '../model/couchdb/DocIdentifier.mjs';\n\n\nexport interface ClassificationBasicApi {\n\n\tmatchClassificationsBy(filter: BaseFilterOptions<Classification>): Promise<Array<string>>;\n\n\tmatchClassificationsBySorted(filter: BaseSortableFilterOptions<Classification>): Promise<Array<string>>;\n\n\tfilterClassificationsBy(filter: BaseFilterOptions<Classification>): Promise<PaginatedListIterator<EncryptedClassification>>;\n\n\tfilterClassificationsBySorted(filter: BaseSortableFilterOptions<Classification>): Promise<PaginatedListIterator<EncryptedClassification>>;\n\n\tdeleteClassification(entityId: string): Promise<DocIdentifier>;\n\n\tdeleteClassifications(entityIds: Array<string>): Promise<Array<DocIdentifier>>;\n\n\tmodifyClassification(entity: EncryptedClassification): Promise<EncryptedClassification>;\n\n\tgetClassification(entityId: string): Promise<EncryptedClassification>;\n\n\tgetClassifications(entityIds: Array<string>): Promise<Array<EncryptedClassification>>;\n\n}\n"]}

package/api/ClassificationFlavouredApi.d.mts

@@ -0,0 +1,22 @@
+import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { ClassificationShareOptions } from '../crypto/entities/ClassificationShareOptions.mjs';
+import { Classification } from '../model/Classification.mjs';
+import { Patient } from '../model/Patient.mjs';
+export interface ClassificationFlavouredApi<E extends Classification> {
+    shareWith(delegateId: string, classification: E, options?: {
+        options?: ClassificationShareOptions | undefined;
+    }): Promise<E>;
+    shareWithMany(classification: E, delegates: {
+        [key: string]: ClassificationShareOptions;
+    }): Promise<E>;
+    findClassificationsByHcPartyPatient(hcPartyId: string, patient: Patient, options?: {
+        startDate?: number | undefined;
+        endDate?: number | undefined;
+        descending?: boolean | undefined;
+    }): Promise<PaginatedListIterator<E>>;
+    filterClassificationsBy(filter: FilterOptions<Classification>): Promise<PaginatedListIterator<E>>;
+    filterClassificationsBySorted(filter: SortableFilterOptions<Classification>): Promise<PaginatedListIterator<E>>;
+    modifyClassification(entity: E): Promise<E>;
+    getClassification(entityId: string): Promise<E>;
+    getClassifications(entityIds: Array<string>): Promise<Array<E>>;
+}

package/api/ClassificationFlavouredApi.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ClassificationFlavouredApi.mjs.map

package/api/ClassificationFlavouredApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassificationFlavouredApi.mjs","sourceRoot":"","sources":["../../tsSourcesProject/api/ClassificationFlavouredApi.mts"],"names":[],"mappings":"","sourcesContent":["// auto-generated file\nimport {FilterOptions, PaginatedListIterator, SortableFilterOptions} from '../cardinal-sdk-ts.mjs';\nimport {ClassificationShareOptions} from '../crypto/entities/ClassificationShareOptions.mjs';\nimport {Classification} from '../model/Classification.mjs';\nimport {Patient} from '../model/Patient.mjs';\n\n\nexport interface ClassificationFlavouredApi<E extends Classification> {\n\n\tshareWith(delegateId: string, classification: E,\n\t\t\toptions?: { options?: ClassificationShareOptions | undefined }): Promise<E>;\n\n\tshareWithMany(classification: E,\n\t\t\tdelegates: { [ key: string ]: ClassificationShareOptions }): Promise<E>;\n\n\tfindClassificationsByHcPartyPatient(hcPartyId: string, patient: Patient,\n\t\t\toptions?: { startDate?: number | undefined, endDate?: number | undefined, descending?: boolean | undefined }): Promise<PaginatedListIterator<E>>;\n\n\tfilterClassificationsBy(filter: FilterOptions<Classification>): Promise<PaginatedListIterator<E>>;\n\n\tfilterClassificationsBySorted(filter: SortableFilterOptions<Classification>): Promise<PaginatedListIterator<E>>;\n\n\tmodifyClassification(entity: E): Promise<E>;\n\n\tgetClassification(entityId: string): Promise<E>;\n\n\tgetClassifications(entityIds: Array<string>): Promise<Array<E>>;\n\n}\n"]}

package/api/CodeApi.d.mts

@@ -0,0 +1,56 @@
+import { BaseFilterOptions, BaseSortableFilterOptions, PaginatedListIterator } from '../cardinal-sdk-ts.mjs';
+import { BooleanResponse } from '../model/BooleanResponse.mjs';
+import { Code } from '../model/Code.mjs';
+import { PaginatedList } from '../model/PaginatedList.mjs';
+export interface CodeApi {
+    findCodesByLabel(region: string | undefined, types: string, language: string, label: string, options?: {
+        version?: string | undefined;
+        startKey?: any | undefined;
+        startDocumentId?: string | undefined;
+        limit?: number | undefined;
+    }): Promise<PaginatedList<Code>>;
+    findCodesByType(region: string, options?: {
+        type?: string | undefined;
+        code?: string | undefined;
+        version?: string | undefined;
+        startKey?: any | undefined;
+        startDocumentId?: string | undefined;
+        limit?: number | undefined;
+    }): Promise<PaginatedList<Code>>;
+    findCodesByLink(linkType: string, options?: {
+        linkedId?: string | undefined;
+        startKey?: any | undefined;
+        startDocumentId?: string | undefined;
+        limit?: number | undefined;
+    }): Promise<PaginatedList<Code>>;
+    listCodesByRegionTypeCodeVersion(region: string, options?: {
+        type?: string | undefined;
+        code?: string | undefined;
+        version?: string | undefined;
+    }): Promise<Array<Code>>;
+    listCodeTypesBy(options?: {
+        region?: string | undefined;
+        type?: string | undefined;
+    }): Promise<Array<string>>;
+    listTagTypesBy(options?: {
+        region?: string | undefined;
+        type?: string | undefined;
+    }): Promise<Array<string>>;
+    createCode(c: Code): Promise<Code>;
+    createCodes(codeBatch: Array<Code>): Promise<Array<Code>>;
+    createCodes(groupId: string, codeBatch: Array<Code>): Promise<Array<Code>>;
+    isCodeValid(type: string, code: string, version: string | undefined): Promise<BooleanResponse>;
+    getCodeByRegionLanguageTypeLabel(region: string, label: string, type: string, languages: string | undefined): Promise<Code | undefined>;
+    getCodes(codeIds: Array<string>): Promise<Array<Code>>;
+    getCodes(groupId: string, codeIds: Array<string>): Promise<Array<Code>>;
+    getCode(codeId: string): Promise<Code>;
+    getCodeWithParts(type: string, code: string, version: string): Promise<Code>;
+    modifyCode(codeDto: Code): Promise<Code>;
+    modifyCodes(codeBatch: Array<Code>): Promise<Array<Code>>;
+    modifyCodes(groupId: string, codeBatch: Array<Code>): Promise<Array<Code>>;
+    filterCodesBy(filter: BaseFilterOptions<Code>): Promise<PaginatedListIterator<Code>>;
+    filterCodesBySorted(filter: BaseSortableFilterOptions<Code>): Promise<PaginatedListIterator<Code>>;
+    matchCodesBy(filter: BaseFilterOptions<Code>): Promise<Array<string>>;
+    matchCodesBySorted(filter: BaseSortableFilterOptions<Code>): Promise<Array<string>>;
+    importCodes(codeType: string): Promise<void>;
+}

package/api/CodeApi.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=CodeApi.mjs.map

package/api/CodeApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodeApi.mjs","sourceRoot":"","sources":["../../tsSourcesProject/api/CodeApi.mts"],"names":[],"mappings":"","sourcesContent":["// auto-generated file\nimport {BaseFilterOptions, BaseSortableFilterOptions, PaginatedListIterator} from '../cardinal-sdk-ts.mjs';\nimport {BooleanResponse} from '../model/BooleanResponse.mjs';\nimport {Code} from '../model/Code.mjs';\nimport {PaginatedList} from '../model/PaginatedList.mjs';\n\n\nexport interface CodeApi {\n\n\tfindCodesByLabel(\n\t\t\tregion: string | undefined,\n\t\t\ttypes: string,\n\t\t\tlanguage: string,\n\t\t\tlabel: string,\n\t\t\toptions?: { version?: string | undefined, startKey?: any | undefined, startDocumentId?: string | undefined, limit?: number | undefined }\n\t): Promise<PaginatedList<Code>>;\n\n\tfindCodesByType(region: string,\n\t\t\toptions?: { type?: string | undefined, code?: string | undefined, version?: string | undefined, startKey?: any | undefined, startDocumentId?: string | undefined, limit?: number | undefined }): Promise<PaginatedList<Code>>;\n\n\tfindCodesByLink(linkType: string,\n\t\t\toptions?: { linkedId?: string | undefined, startKey?: any | undefined, startDocumentId?: string | undefined, limit?: number | undefined }): Promise<PaginatedList<Code>>;\n\n\tlistCodesByRegionTypeCodeVersion(region: string,\n\t\t\toptions?: { type?: string | undefined, code?: string | undefined, version?: string | undefined }): Promise<Array<Code>>;\n\n\tlistCodeTypesBy(options?: { region?: string | undefined, type?: string | undefined }): Promise<Array<string>>;\n\n\tlistTagTypesBy(options?: { region?: string | undefined, type?: string | undefined }): Promise<Array<string>>;\n\n\tcreateCode(c: Code): Promise<Code>;\n\n\tcreateCodes(codeBatch: Array<Code>): Promise<Array<Code>>;\n\n\tcreateCodes(groupId: string, codeBatch: Array<Code>): Promise<Array<Code>>;\n\n\tisCodeValid(type: string, code: string, version: string | undefined): Promise<BooleanResponse>;\n\n\tgetCodeByRegionLanguageTypeLabel(region: string, label: string, type: string,\n\t\t\tlanguages: string | undefined): Promise<Code | undefined>;\n\n\tgetCodes(codeIds: Array<string>): Promise<Array<Code>>;\n\n\tgetCodes(groupId: string, codeIds: Array<string>): Promise<Array<Code>>;\n\n\tgetCode(codeId: string): Promise<Code>;\n\n\tgetCodeWithParts(type: string, code: string, version: string): Promise<Code>;\n\n\tmodifyCode(codeDto: Code): Promise<Code>;\n\n\tmodifyCodes(codeBatch: Array<Code>): Promise<Array<Code>>;\n\n\tmodifyCodes(groupId: string, codeBatch: Array<Code>): Promise<Array<Code>>;\n\n\tfilterCodesBy(filter: BaseFilterOptions<Code>): Promise<PaginatedListIterator<Code>>;\n\n\tfilterCodesBySorted(filter: BaseSortableFilterOptions<Code>): Promise<PaginatedListIterator<Code>>;\n\n\tmatchCodesBy(filter: BaseFilterOptions<Code>): Promise<Array<string>>;\n\n\tmatchCodesBySorted(filter: BaseSortableFilterOptions<Code>): Promise<Array<string>>;\n\n\timportCodes(codeType: string): Promise<void>;\n\n}\n"]}

package/api/ContactApi.d.mts

@@ -0,0 +1,89 @@
+import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { ContactShareOptions } from '../crypto/entities/ContactShareOptions.mjs';
+import { SecretIdUseOption } from '../crypto/entities/SecretIdUseOption.mjs';
+import { Contact, DecryptedContact, EncryptedContact } from '../model/Contact.mjs';
+import { IcureStub } from '../model/IcureStub.mjs';
+import { PaginatedList } from '../model/PaginatedList.mjs';
+import { Patient } from '../model/Patient.mjs';
+import { User } from '../model/User.mjs';
+import { DocIdentifier } from '../model/couchdb/DocIdentifier.mjs';
+import { LabelledOccurence } from '../model/data/LabelledOccurence.mjs';
+import { AccessLevel } from '../model/embed/AccessLevel.mjs';
+import { DecryptedService, EncryptedService, Service } from '../model/embed/Service.mjs';
+import { HexString } from '../model/specializations/HexString.mjs';
+import { EntitySubscription } from '../subscription/EntitySubscription.mjs';
+import { EntitySubscriptionConfiguration } from '../subscription/EntitySubscriptionConfiguration.mjs';
+import { SubscriptionEventType } from '../subscription/SubscriptionEventType.mjs';
+import { ContactFlavouredApi } from './ContactFlavouredApi.mjs';
+export interface ContactApi {
+    encrypted: ContactFlavouredApi<EncryptedContact, EncryptedService>;
+    tryAndRecover: ContactFlavouredApi<Contact, Service>;
+    matchContactsBy(filter: FilterOptions<Contact>): Promise<Array<string>>;
+    matchServicesBy(filter: FilterOptions<Service>): Promise<Array<string>>;
+    matchContactsBySorted(filter: SortableFilterOptions<Contact>): Promise<Array<string>>;
+    matchServicesBySorted(filter: SortableFilterOptions<Service>): Promise<Array<string>>;
+    createContact(entity: DecryptedContact): Promise<DecryptedContact>;
+    createContacts(entities: Array<DecryptedContact>): Promise<Array<DecryptedContact>>;
+    withEncryptionMetadata(base: DecryptedContact | undefined, patient: Patient, options?: {
+        user?: User | undefined;
+        delegates?: {
+            [key: string]: AccessLevel;
+        };
+        secretId?: SecretIdUseOption;
+    }): Promise<DecryptedContact>;
+    getEncryptionKeysOf(contact: Contact): Promise<Array<HexString>>;
+    hasWriteAccess(contact: Contact): Promise<boolean>;
+    decryptPatientIdOf(contact: Contact): Promise<Array<string>>;
+    createDelegationDeAnonymizationMetadata(entity: Contact, delegates: Array<string>): Promise<void>;
+    decrypt(contact: EncryptedContact): Promise<DecryptedContact>;
+    tryDecrypt(contact: EncryptedContact): Promise<Contact>;
+    decryptService(service: EncryptedService): Promise<DecryptedService>;
+    tryDecryptService(service: EncryptedService): Promise<Service>;
+    subscribeToServiceCreateOrUpdateEvents(filter: FilterOptions<Service>, options?: {
+        subscriptionConfig?: EntitySubscriptionConfiguration | undefined;
+    }): Promise<EntitySubscription<EncryptedService>>;
+    deleteContact(entityId: string): Promise<DocIdentifier>;
+    deleteContacts(entityIds: Array<string>): Promise<Array<DocIdentifier>>;
+    findContactsDelegationsStubsByHcPartyPatientForeignKeys(hcPartyId: string, secretPatientKeys: Array<string>): Promise<Array<IcureStub>>;
+    getServiceCodesOccurrences(codeType: string, minOccurrences: number): Promise<Array<LabelledOccurence>>;
+    shareWith(delegateId: string, contact: DecryptedContact, options?: {
+        options?: ContactShareOptions | undefined;
+    }): Promise<DecryptedContact>;
+    shareWithMany(contact: DecryptedContact, delegates: {
+        [key: string]: ContactShareOptions;
+    }): Promise<DecryptedContact>;
+    findContactsByHcPartyPatient(hcPartyId: string, patient: Patient, options?: {
+        startDate?: number | undefined;
+        endDate?: number | undefined;
+        descending?: boolean | undefined;
+    }): Promise<PaginatedListIterator<DecryptedContact>>;
+    filterContactsBy(filter: FilterOptions<Contact>): Promise<PaginatedListIterator<DecryptedContact>>;
+    filterServicesBy(filter: FilterOptions<Service>): Promise<PaginatedListIterator<DecryptedService>>;
+    filterContactsBySorted(filter: SortableFilterOptions<Contact>): Promise<PaginatedListIterator<DecryptedContact>>;
+    filterServicesBySorted(filter: SortableFilterOptions<Service>): Promise<PaginatedListIterator<DecryptedService>>;
+    modifyContact(entity: DecryptedContact): Promise<DecryptedContact>;
+    modifyContacts(entities: Array<DecryptedContact>): Promise<Array<DecryptedContact>>;
+    getContact(entityId: string): Promise<DecryptedContact>;
+    getContacts(entityIds: Array<string>): Promise<Array<DecryptedContact>>;
+    listContactByHCPartyServiceId(hcPartyId: string, serviceId: string): Promise<Array<DecryptedContact>>;
+    listContactsByExternalId(externalId: string): Promise<Array<DecryptedContact>>;
+    listContactsByHCPartyAndFormId(hcPartyId: string, formId: string): Promise<Array<DecryptedContact>>;
+    listContactsByHCPartyAndFormIds(hcPartyId: string, formIds: Array<string>): Promise<Array<DecryptedContact>>;
+    listContactsByHCPartyAndPatientSecretFKeys(hcPartyId: string, secretPatientKeys: Array<string>, options?: {
+        planOfActionsIds?: string | undefined;
+        skipClosedContacts?: boolean | undefined;
+    }): Promise<Array<DecryptedContact>>;
+    getService(serviceId: string): Promise<DecryptedService>;
+    getServices(entityIds: Array<string>): Promise<Array<DecryptedService>>;
+    getServicesLinkedTo(linkType: string, ids: Array<string>): Promise<Array<DecryptedService>>;
+    listServicesByAssociationId(associationId: string): Promise<Array<DecryptedService>>;
+    listServicesByHealthElementId(hcPartyId: string, healthElementId: string): Promise<Array<DecryptedService>>;
+    findContactsByOpeningDate(startDate: number, endDate: number, hcPartyId: string, options?: {
+        startKey?: any | undefined;
+        startDocumentId?: string | undefined;
+        limit?: number | undefined;
+    }): Promise<PaginatedList<DecryptedContact>>;
+    subscribeToEvents(events: Array<SubscriptionEventType>, filter: FilterOptions<Contact>, options?: {
+        subscriptionConfig?: EntitySubscriptionConfiguration | undefined;
+    }): Promise<EntitySubscription<EncryptedContact>>;
+}

package/api/ContactApi.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ContactApi.mjs.map

package/api/ContactApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContactApi.mjs","sourceRoot":"","sources":["../../tsSourcesProject/api/ContactApi.mts"],"names":[],"mappings":"","sourcesContent":["// auto-generated file\nimport {FilterOptions, PaginatedListIterator, SortableFilterOptions} from '../cardinal-sdk-ts.mjs';\nimport {ContactShareOptions} from '../crypto/entities/ContactShareOptions.mjs';\nimport {SecretIdUseOption} from '../crypto/entities/SecretIdUseOption.mjs';\nimport {Contact, DecryptedContact, EncryptedContact} from '../model/Contact.mjs';\nimport {IcureStub} from '../model/IcureStub.mjs';\nimport {PaginatedList} from '../model/PaginatedList.mjs';\nimport {Patient} from '../model/Patient.mjs';\nimport {User} from '../model/User.mjs';\nimport {DocIdentifier} from '../model/couchdb/DocIdentifier.mjs';\nimport {LabelledOccurence} from '../model/data/LabelledOccurence.mjs';\nimport {AccessLevel} from '../model/embed/AccessLevel.mjs';\nimport {DecryptedService, EncryptedService, Service} from '../model/embed/Service.mjs';\nimport {HexString} from '../model/specializations/HexString.mjs';\nimport {EntitySubscription} from '../subscription/EntitySubscription.mjs';\nimport {EntitySubscriptionConfiguration} from '../subscription/EntitySubscriptionConfiguration.mjs';\nimport {SubscriptionEventType} from '../subscription/SubscriptionEventType.mjs';\nimport {ContactFlavouredApi} from './ContactFlavouredApi.mjs';\n\n\nexport interface ContactApi {\n\n\tencrypted: ContactFlavouredApi<EncryptedContact, EncryptedService>;\n\n\ttryAndRecover: ContactFlavouredApi<Contact, Service>;\n\n\tmatchContactsBy(filter: FilterOptions<Contact>): Promise<Array<string>>;\n\n\tmatchServicesBy(filter: FilterOptions<Service>): Promise<Array<string>>;\n\n\tmatchContactsBySorted(filter: SortableFilterOptions<Contact>): Promise<Array<string>>;\n\n\tmatchServicesBySorted(filter: SortableFilterOptions<Service>): Promise<Array<string>>;\n\n\tcreateContact(entity: DecryptedContact): Promise<DecryptedContact>;\n\n\tcreateContacts(entities: Array<DecryptedContact>): Promise<Array<DecryptedContact>>;\n\n\twithEncryptionMetadata(base: DecryptedContact | undefined, patient: Patient,\n\t\t\toptions?: { user?: User | undefined, delegates?: { [ key: string ]: AccessLevel }, secretId?: SecretIdUseOption }): Promise<DecryptedContact>;\n\n\tgetEncryptionKeysOf(contact: Contact): Promise<Array<HexString>>;\n\n\thasWriteAccess(contact: Contact): Promise<boolean>;\n\n\tdecryptPatientIdOf(contact: Contact): Promise<Array<string>>;\n\n\tcreateDelegationDeAnonymizationMetadata(entity: Contact, delegates: Array<string>): Promise<void>;\n\n\tdecrypt(contact: EncryptedContact): Promise<DecryptedContact>;\n\n\ttryDecrypt(contact: EncryptedContact): Promise<Contact>;\n\n\tdecryptService(service: EncryptedService): Promise<DecryptedService>;\n\n\ttryDecryptService(service: EncryptedService): Promise<Service>;\n\n\tsubscribeToServiceCreateOrUpdateEvents(filter: FilterOptions<Service>,\n\t\t\toptions?: { subscriptionConfig?: EntitySubscriptionConfiguration | undefined }): Promise<EntitySubscription<EncryptedService>>;\n\n\tdeleteContact(entityId: string): Promise<DocIdentifier>;\n\n\tdeleteContacts(entityIds: Array<string>): Promise<Array<DocIdentifier>>;\n\n\tfindContactsDelegationsStubsByHcPartyPatientForeignKeys(hcPartyId: string,\n\t\t\tsecretPatientKeys: Array<string>): Promise<Array<IcureStub>>;\n\n\tgetServiceCodesOccurrences(codeType: string,\n\t\t\tminOccurrences: number): Promise<Array<LabelledOccurence>>;\n\n\tshareWith(delegateId: string, contact: DecryptedContact,\n\t\t\toptions?: { options?: ContactShareOptions | undefined }): Promise<DecryptedContact>;\n\n\tshareWithMany(contact: DecryptedContact,\n\t\t\tdelegates: { [ key: string ]: ContactShareOptions }): Promise<DecryptedContact>;\n\n\tfindContactsByHcPartyPatient(hcPartyId: string, patient: Patient,\n\t\t\toptions?: { startDate?: number | undefined, endDate?: number | undefined, descending?: boolean | undefined }): Promise<PaginatedListIterator<DecryptedContact>>;\n\n\tfilterContactsBy(filter: FilterOptions<Contact>): Promise<PaginatedListIterator<DecryptedContact>>;\n\n\tfilterServicesBy(filter: FilterOptions<Service>): Promise<PaginatedListIterator<DecryptedService>>;\n\n\tfilterContactsBySorted(filter: SortableFilterOptions<Contact>): Promise<PaginatedListIterator<DecryptedContact>>;\n\n\tfilterServicesBySorted(filter: SortableFilterOptions<Service>): Promise<PaginatedListIterator<DecryptedService>>;\n\n\tmodifyContact(entity: DecryptedContact): Promise<DecryptedContact>;\n\n\tmodifyContacts(entities: Array<DecryptedContact>): Promise<Array<DecryptedContact>>;\n\n\tgetContact(entityId: string): Promise<DecryptedContact>;\n\n\tgetContacts(entityIds: Array<string>): Promise<Array<DecryptedContact>>;\n\n\tlistContactByHCPartyServiceId(hcPartyId: string,\n\t\t\tserviceId: string): Promise<Array<DecryptedContact>>;\n\n\tlistContactsByExternalId(externalId: string): Promise<Array<DecryptedContact>>;\n\n\tlistContactsByHCPartyAndFormId(hcPartyId: string,\n\t\t\tformId: string): Promise<Array<DecryptedContact>>;\n\n\tlistContactsByHCPartyAndFormIds(hcPartyId: string,\n\t\t\tformIds: Array<string>): Promise<Array<DecryptedContact>>;\n\n\tlistContactsByHCPartyAndPatientSecretFKeys(hcPartyId: string, secretPatientKeys: Array<string>,\n\t\t\toptions?: { planOfActionsIds?: string | undefined, skipClosedContacts?: boolean | undefined }): Promise<Array<DecryptedContact>>;\n\n\tgetService(serviceId: string): Promise<DecryptedService>;\n\n\tgetServices(entityIds: Array<string>): Promise<Array<DecryptedService>>;\n\n\tgetServicesLinkedTo(linkType: string, ids: Array<string>): Promise<Array<DecryptedService>>;\n\n\tlistServicesByAssociationId(associationId: string): Promise<Array<DecryptedService>>;\n\n\tlistServicesByHealthElementId(hcPartyId: string,\n\t\t\thealthElementId: string): Promise<Array<DecryptedService>>;\n\n\tfindContactsByOpeningDate(startDate: number, endDate: number, hcPartyId: string,\n\t\t\toptions?: { startKey?: any | undefined, startDocumentId?: string | undefined, limit?: number | undefined }): Promise<PaginatedList<DecryptedContact>>;\n\n\tsubscribeToEvents(events: Array<SubscriptionEventType>, filter: FilterOptions<Contact>,\n\t\t\toptions?: { subscriptionConfig?: EntitySubscriptionConfiguration | undefined }): Promise<EntitySubscription<EncryptedContact>>;\n\n}\n"]}

package/api/ContactBasicApi.d.mts

@@ -0,0 +1,52 @@
+import { BaseFilterOptions, BaseSortableFilterOptions, PaginatedListIterator } from '../cardinal-sdk-ts.mjs';
+import { Contact, EncryptedContact } from '../model/Contact.mjs';
+import { IcureStub } from '../model/IcureStub.mjs';
+import { PaginatedList } from '../model/PaginatedList.mjs';
+import { DocIdentifier } from '../model/couchdb/DocIdentifier.mjs';
+import { LabelledOccurence } from '../model/data/LabelledOccurence.mjs';
+import { EncryptedService, Service } from '../model/embed/Service.mjs';
+import { EntitySubscription } from '../subscription/EntitySubscription.mjs';
+import { EntitySubscriptionConfiguration } from '../subscription/EntitySubscriptionConfiguration.mjs';
+import { SubscriptionEventType } from '../subscription/SubscriptionEventType.mjs';
+export interface ContactBasicApi {
+    matchContactsBy(filter: BaseFilterOptions<Contact>): Promise<Array<string>>;
+    matchServicesBy(filter: BaseFilterOptions<Service>): Promise<Array<string>>;
+    matchContactsBySorted(filter: BaseSortableFilterOptions<Contact>): Promise<Array<string>>;
+    matchServicesBySorted(filter: BaseSortableFilterOptions<Service>): Promise<Array<string>>;
+    filterContactsBy(filter: BaseFilterOptions<Contact>): Promise<PaginatedListIterator<EncryptedContact>>;
+    filterServicesBy(filter: BaseFilterOptions<Service>): Promise<PaginatedListIterator<EncryptedService>>;
+    filterContactsBySorted(filter: BaseSortableFilterOptions<Contact>): Promise<PaginatedListIterator<EncryptedContact>>;
+    filterServicesBySorted(filter: BaseSortableFilterOptions<Service>): Promise<PaginatedListIterator<EncryptedService>>;
+    subscribeToServiceCreateOrUpdateEvents(filter: BaseFilterOptions<Service>, options?: {
+        subscriptionConfig?: EntitySubscriptionConfiguration | undefined;
+    }): Promise<EntitySubscription<EncryptedService>>;
+    deleteContact(entityId: string): Promise<DocIdentifier>;
+    deleteContacts(entityIds: Array<string>): Promise<Array<DocIdentifier>>;
+    findContactsDelegationsStubsByHcPartyPatientForeignKeys(hcPartyId: string, secretPatientKeys: Array<string>): Promise<Array<IcureStub>>;
+    getServiceCodesOccurrences(codeType: string, minOccurrences: number): Promise<Array<LabelledOccurence>>;
+    modifyContact(entity: EncryptedContact): Promise<EncryptedContact>;
+    modifyContacts(entities: Array<EncryptedContact>): Promise<Array<EncryptedContact>>;
+    getContact(entityId: string): Promise<EncryptedContact>;
+    getContacts(entityIds: Array<string>): Promise<Array<EncryptedContact>>;
+    listContactByHCPartyServiceId(hcPartyId: string, serviceId: string): Promise<Array<EncryptedContact>>;
+    listContactsByExternalId(externalId: string): Promise<Array<EncryptedContact>>;
+    listContactsByHCPartyAndFormId(hcPartyId: string, formId: string): Promise<Array<EncryptedContact>>;
+    listContactsByHCPartyAndFormIds(hcPartyId: string, formIds: Array<string>): Promise<Array<EncryptedContact>>;
+    listContactsByHCPartyAndPatientSecretFKeys(hcPartyId: string, secretPatientKeys: Array<string>, options?: {
+        planOfActionsIds?: string | undefined;
+        skipClosedContacts?: boolean | undefined;
+    }): Promise<Array<EncryptedContact>>;
+    getService(serviceId: string): Promise<EncryptedService>;
+    getServices(entityIds: Array<string>): Promise<Array<EncryptedService>>;
+    getServicesLinkedTo(linkType: string, ids: Array<string>): Promise<Array<EncryptedService>>;
+    listServicesByAssociationId(associationId: string): Promise<Array<EncryptedService>>;
+    listServicesByHealthElementId(hcPartyId: string, healthElementId: string): Promise<Array<EncryptedService>>;
+    findContactsByOpeningDate(startDate: number, endDate: number, hcPartyId: string, options?: {
+        startKey?: any | undefined;
+        startDocumentId?: string | undefined;
+        limit?: number | undefined;
+    }): Promise<PaginatedList<EncryptedContact>>;
+    subscribeToEvents(events: Array<SubscriptionEventType>, filter: BaseFilterOptions<Contact>, options?: {
+        subscriptionConfig?: EntitySubscriptionConfiguration | undefined;
+    }): Promise<EntitySubscription<EncryptedContact>>;
+}

package/api/ContactBasicApi.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ContactBasicApi.mjs.map

package/api/ContactBasicApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContactBasicApi.mjs","sourceRoot":"","sources":["../../tsSourcesProject/api/ContactBasicApi.mts"],"names":[],"mappings":"","sourcesContent":["// auto-generated file\nimport {BaseFilterOptions, BaseSortableFilterOptions, PaginatedListIterator} from '../cardinal-sdk-ts.mjs';\nimport {Contact, EncryptedContact} from '../model/Contact.mjs';\nimport {IcureStub} from '../model/IcureStub.mjs';\nimport {PaginatedList} from '../model/PaginatedList.mjs';\nimport {DocIdentifier} from '../model/couchdb/DocIdentifier.mjs';\nimport {LabelledOccurence} from '../model/data/LabelledOccurence.mjs';\nimport {EncryptedService, Service} from '../model/embed/Service.mjs';\nimport {EntitySubscription} from '../subscription/EntitySubscription.mjs';\nimport {EntitySubscriptionConfiguration} from '../subscription/EntitySubscriptionConfiguration.mjs';\nimport {SubscriptionEventType} from '../subscription/SubscriptionEventType.mjs';\n\n\nexport interface ContactBasicApi {\n\n\tmatchContactsBy(filter: BaseFilterOptions<Contact>): Promise<Array<string>>;\n\n\tmatchServicesBy(filter: BaseFilterOptions<Service>): Promise<Array<string>>;\n\n\tmatchContactsBySorted(filter: BaseSortableFilterOptions<Contact>): Promise<Array<string>>;\n\n\tmatchServicesBySorted(filter: BaseSortableFilterOptions<Service>): Promise<Array<string>>;\n\n\tfilterContactsBy(filter: BaseFilterOptions<Contact>): Promise<PaginatedListIterator<EncryptedContact>>;\n\n\tfilterServicesBy(filter: BaseFilterOptions<Service>): Promise<PaginatedListIterator<EncryptedService>>;\n\n\tfilterContactsBySorted(filter: BaseSortableFilterOptions<Contact>): Promise<PaginatedListIterator<EncryptedContact>>;\n\n\tfilterServicesBySorted(filter: BaseSortableFilterOptions<Service>): Promise<PaginatedListIterator<EncryptedService>>;\n\n\tsubscribeToServiceCreateOrUpdateEvents(filter: BaseFilterOptions<Service>,\n\t\t\toptions?: { subscriptionConfig?: EntitySubscriptionConfiguration | undefined }): Promise<EntitySubscription<EncryptedService>>;\n\n\tdeleteContact(entityId: string): Promise<DocIdentifier>;\n\n\tdeleteContacts(entityIds: Array<string>): Promise<Array<DocIdentifier>>;\n\n\tfindContactsDelegationsStubsByHcPartyPatientForeignKeys(hcPartyId: string,\n\t\t\tsecretPatientKeys: Array<string>): Promise<Array<IcureStub>>;\n\n\tgetServiceCodesOccurrences(codeType: string,\n\t\t\tminOccurrences: number): Promise<Array<LabelledOccurence>>;\n\n\tmodifyContact(entity: EncryptedContact): Promise<EncryptedContact>;\n\n\tmodifyContacts(entities: Array<EncryptedContact>): Promise<Array<EncryptedContact>>;\n\n\tgetContact(entityId: string): Promise<EncryptedContact>;\n\n\tgetContacts(entityIds: Array<string>): Promise<Array<EncryptedContact>>;\n\n\tlistContactByHCPartyServiceId(hcPartyId: string,\n\t\t\tserviceId: string): Promise<Array<EncryptedContact>>;\n\n\tlistContactsByExternalId(externalId: string): Promise<Array<EncryptedContact>>;\n\n\tlistContactsByHCPartyAndFormId(hcPartyId: string,\n\t\t\tformId: string): Promise<Array<EncryptedContact>>;\n\n\tlistContactsByHCPartyAndFormIds(hcPartyId: string,\n\t\t\tformIds: Array<string>): Promise<Array<EncryptedContact>>;\n\n\tlistContactsByHCPartyAndPatientSecretFKeys(hcPartyId: string, secretPatientKeys: Array<string>,\n\t\t\toptions?: { planOfActionsIds?: string | undefined, skipClosedContacts?: boolean | undefined }): Promise<Array<EncryptedContact>>;\n\n\tgetService(serviceId: string): Promise<EncryptedService>;\n\n\tgetServices(entityIds: Array<string>): Promise<Array<EncryptedService>>;\n\n\tgetServicesLinkedTo(linkType: string, ids: Array<string>): Promise<Array<EncryptedService>>;\n\n\tlistServicesByAssociationId(associationId: string): Promise<Array<EncryptedService>>;\n\n\tlistServicesByHealthElementId(hcPartyId: string,\n\t\t\thealthElementId: string): Promise<Array<EncryptedService>>;\n\n\tfindContactsByOpeningDate(startDate: number, endDate: number, hcPartyId: string,\n\t\t\toptions?: { startKey?: any | undefined, startDocumentId?: string | undefined, limit?: number | undefined }): Promise<PaginatedList<EncryptedContact>>;\n\n\tsubscribeToEvents(events: Array<SubscriptionEventType>, filter: BaseFilterOptions<Contact>,\n\t\t\toptions?: { subscriptionConfig?: EntitySubscriptionConfiguration | undefined }): Promise<EntitySubscription<EncryptedContact>>;\n\n}\n"]}

package/api/ContactFlavouredApi.d.mts

@@ -0,0 +1,45 @@
+import { FilterOptions, PaginatedListIterator, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { ContactShareOptions } from '../crypto/entities/ContactShareOptions.mjs';
+import { Contact } from '../model/Contact.mjs';
+import { PaginatedList } from '../model/PaginatedList.mjs';
+import { Patient } from '../model/Patient.mjs';
+import { Service } from '../model/embed/Service.mjs';
+export interface ContactFlavouredApi<E extends Contact, S extends Service> {
+    shareWith(delegateId: string, contact: E, options?: {
+        options?: ContactShareOptions | undefined;
+    }): Promise<E>;
+    shareWithMany(contact: E, delegates: {
+        [key: string]: ContactShareOptions;
+    }): Promise<E>;
+    findContactsByHcPartyPatient(hcPartyId: string, patient: Patient, options?: {
+        startDate?: number | undefined;
+        endDate?: number | undefined;
+        descending?: boolean | undefined;
+    }): Promise<PaginatedListIterator<E>>;
+    filterContactsBy(filter: FilterOptions<Contact>): Promise<PaginatedListIterator<E>>;
+    filterServicesBy(filter: FilterOptions<Service>): Promise<PaginatedListIterator<S>>;
+    filterContactsBySorted(filter: SortableFilterOptions<Contact>): Promise<PaginatedListIterator<E>>;
+    filterServicesBySorted(filter: SortableFilterOptions<Service>): Promise<PaginatedListIterator<S>>;
+    modifyContact(entity: E): Promise<E>;
+    modifyContacts(entities: Array<E>): Promise<Array<E>>;
+    getContact(entityId: string): Promise<E>;
+    getContacts(entityIds: Array<string>): Promise<Array<E>>;
+    listContactByHCPartyServiceId(hcPartyId: string, serviceId: string): Promise<Array<E>>;
+    listContactsByExternalId(externalId: string): Promise<Array<E>>;
+    listContactsByHCPartyAndFormId(hcPartyId: string, formId: string): Promise<Array<E>>;
+    listContactsByHCPartyAndFormIds(hcPartyId: string, formIds: Array<string>): Promise<Array<E>>;
+    listContactsByHCPartyAndPatientSecretFKeys(hcPartyId: string, secretPatientKeys: Array<string>, options?: {
+        planOfActionsIds?: string | undefined;
+        skipClosedContacts?: boolean | undefined;
+    }): Promise<Array<E>>;
+    getService(serviceId: string): Promise<S>;
+    getServices(entityIds: Array<string>): Promise<Array<S>>;
+    getServicesLinkedTo(linkType: string, ids: Array<string>): Promise<Array<S>>;
+    listServicesByAssociationId(associationId: string): Promise<Array<S>>;
+    listServicesByHealthElementId(hcPartyId: string, healthElementId: string): Promise<Array<S>>;
+    findContactsByOpeningDate(startDate: number, endDate: number, hcPartyId: string, options?: {
+        startKey?: any | undefined;
+        startDocumentId?: string | undefined;
+        limit?: number | undefined;
+    }): Promise<PaginatedList<E>>;
+}

package/api/ContactFlavouredApi.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ContactFlavouredApi.mjs.map

package/api/ContactFlavouredApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContactFlavouredApi.mjs","sourceRoot":"","sources":["../../tsSourcesProject/api/ContactFlavouredApi.mts"],"names":[],"mappings":"","sourcesContent":["// auto-generated file\nimport {FilterOptions, PaginatedListIterator, SortableFilterOptions} from '../cardinal-sdk-ts.mjs';\nimport {ContactShareOptions} from '../crypto/entities/ContactShareOptions.mjs';\nimport {Contact} from '../model/Contact.mjs';\nimport {PaginatedList} from '../model/PaginatedList.mjs';\nimport {Patient} from '../model/Patient.mjs';\nimport {Service} from '../model/embed/Service.mjs';\n\n\nexport interface ContactFlavouredApi<E extends Contact, S extends Service> {\n\n\tshareWith(delegateId: string, contact: E,\n\t\t\toptions?: { options?: ContactShareOptions | undefined }): Promise<E>;\n\n\tshareWithMany(contact: E, delegates: { [ key: string ]: ContactShareOptions }): Promise<E>;\n\n\tfindContactsByHcPartyPatient(hcPartyId: string, patient: Patient,\n\t\t\toptions?: { startDate?: number | undefined, endDate?: number | undefined, descending?: boolean | undefined }): Promise<PaginatedListIterator<E>>;\n\n\tfilterContactsBy(filter: FilterOptions<Contact>): Promise<PaginatedListIterator<E>>;\n\n\tfilterServicesBy(filter: FilterOptions<Service>): Promise<PaginatedListIterator<S>>;\n\n\tfilterContactsBySorted(filter: SortableFilterOptions<Contact>): Promise<PaginatedListIterator<E>>;\n\n\tfilterServicesBySorted(filter: SortableFilterOptions<Service>): Promise<PaginatedListIterator<S>>;\n\n\tmodifyContact(entity: E): Promise<E>;\n\n\tmodifyContacts(entities: Array<E>): Promise<Array<E>>;\n\n\tgetContact(entityId: string): Promise<E>;\n\n\tgetContacts(entityIds: Array<string>): Promise<Array<E>>;\n\n\tlistContactByHCPartyServiceId(hcPartyId: string, serviceId: string): Promise<Array<E>>;\n\n\tlistContactsByExternalId(externalId: string): Promise<Array<E>>;\n\n\tlistContactsByHCPartyAndFormId(hcPartyId: string, formId: string): Promise<Array<E>>;\n\n\tlistContactsByHCPartyAndFormIds(hcPartyId: string, formIds: Array<string>): Promise<Array<E>>;\n\n\tlistContactsByHCPartyAndPatientSecretFKeys(hcPartyId: string, secretPatientKeys: Array<string>,\n\t\t\toptions?: { planOfActionsIds?: string | undefined, skipClosedContacts?: boolean | undefined }): Promise<Array<E>>;\n\n\tgetService(serviceId: string): Promise<S>;\n\n\tgetServices(entityIds: Array<string>): Promise<Array<S>>;\n\n\tgetServicesLinkedTo(linkType: string, ids: Array<string>): Promise<Array<S>>;\n\n\tlistServicesByAssociationId(associationId: string): Promise<Array<S>>;\n\n\tlistServicesByHealthElementId(hcPartyId: string, healthElementId: string): Promise<Array<S>>;\n\n\tfindContactsByOpeningDate(startDate: number, endDate: number, hcPartyId: string,\n\t\t\toptions?: { startKey?: any | undefined, startDocumentId?: string | undefined, limit?: number | undefined }): Promise<PaginatedList<E>>;\n\n}\n"]}

package/api/CryptoApi.d.mts

@@ -0,0 +1,5 @@
+import { ShamirKeysManagerApi } from './ShamirKeysManagerApi.mjs';
+export interface CryptoApi {
+    shamirKeysManager: ShamirKeysManagerApi;
+    forceReload(): Promise<void>;
+}

package/api/CryptoApi.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=CryptoApi.mjs.map

package/api/CryptoApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CryptoApi.mjs","sourceRoot":"","sources":["../../tsSourcesProject/api/CryptoApi.mts"],"names":[],"mappings":"","sourcesContent":["// auto-generated file\nimport {ShamirKeysManagerApi} from './ShamirKeysManagerApi.mjs';\n\n\nexport interface CryptoApi {\n\n\tshamirKeysManager: ShamirKeysManagerApi;\n\n\tforceReload(): Promise<void>;\n\n}\n"]}

package/api/DataOwnerApi.d.mts

@@ -0,0 +1,16 @@
+import { CryptoActorStubWithType } from '../model/CryptoActorStubWithType.mjs';
+import { DataOwnerType } from '../model/DataOwnerType.mjs';
+import { DataOwnerWithType } from '../model/DataOwnerWithType.mjs';
+export interface DataOwnerApi {
+    getCurrentDataOwner(): Promise<DataOwnerWithType>;
+    getCurrentDataOwnerStub(): Promise<CryptoActorStubWithType>;
+    getCurrentDataOwnerId(): Promise<string>;
+    getCurrentDataOwnerHierarchyIds(): Promise<Array<string>>;
+    getDataOwner(ownerId: string): Promise<DataOwnerWithType>;
+    getCryptoActorStub(ownerId: string): Promise<CryptoActorStubWithType>;
+    getCurrentDataOwnerHierarchyIdsFrom(parentId: string): Promise<Array<string>>;
+    getCurrentDataOwnerHierarchy(): Promise<Array<DataOwnerWithType>>;
+    modifyDataOwnerStub(cryptoActorStubWithTypeDto: CryptoActorStubWithType): Promise<CryptoActorStubWithType>;
+    getCurrentDataOwnerType(): Promise<DataOwnerType>;
+    clearCurrentDataOwnerIdsCache(): void;
+}

package/api/DataOwnerApi.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DataOwnerApi.mjs.map

package/api/DataOwnerApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataOwnerApi.mjs","sourceRoot":"","sources":["../../tsSourcesProject/api/DataOwnerApi.mts"],"names":[],"mappings":"","sourcesContent":["// auto-generated file\nimport {CryptoActorStubWithType} from '../model/CryptoActorStubWithType.mjs';\nimport {DataOwnerType} from '../model/DataOwnerType.mjs';\nimport {DataOwnerWithType} from '../model/DataOwnerWithType.mjs';\n\n\nexport interface DataOwnerApi {\n\n\tgetCurrentDataOwner(): Promise<DataOwnerWithType>;\n\n\tgetCurrentDataOwnerStub(): Promise<CryptoActorStubWithType>;\n\n\tgetCurrentDataOwnerId(): Promise<string>;\n\n\tgetCurrentDataOwnerHierarchyIds(): Promise<Array<string>>;\n\n\tgetDataOwner(ownerId: string): Promise<DataOwnerWithType>;\n\n\tgetCryptoActorStub(ownerId: string): Promise<CryptoActorStubWithType>;\n\n\tgetCurrentDataOwnerHierarchyIdsFrom(parentId: string): Promise<Array<string>>;\n\n\tgetCurrentDataOwnerHierarchy(): Promise<Array<DataOwnerWithType>>;\n\n\tmodifyDataOwnerStub(cryptoActorStubWithTypeDto: CryptoActorStubWithType): Promise<CryptoActorStubWithType>;\n\n\tgetCurrentDataOwnerType(): Promise<DataOwnerType>;\n\n\tclearCurrentDataOwnerIdsCache(): void;\n\n}\n"]}

package/api/DeviceApi.d.mts

@@ -0,0 +1,24 @@
+import { BaseFilterOptions, BaseSortableFilterOptions, PaginatedListIterator } from '../cardinal-sdk-ts.mjs';
+import { Device } from '../model/Device.mjs';
+import { IdWithRev } from '../model/IdWithRev.mjs';
+import { DocIdentifier } from '../model/couchdb/DocIdentifier.mjs';
+export interface DeviceApi {
+    getDevice(deviceId: string): Promise<Device>;
+    getDevices(deviceIds: Array<string>): Promise<Array<Device>>;
+    createDevice(p: Device): Promise<Device>;
+    modifyDevice(device: Device): Promise<Device>;
+    createDevices(devices: Array<Device>): Promise<Array<IdWithRev>>;
+    modifyDevices(devices: Array<Device>): Promise<Array<IdWithRev>>;
+    filterDevicesBy(filter: BaseFilterOptions<Device>): Promise<PaginatedListIterator<Device>>;
+    filterDevicesBySorted(filter: BaseSortableFilterOptions<Device>): Promise<PaginatedListIterator<Device>>;
+    matchDevicesBy(filter: BaseFilterOptions<Device>): Promise<Array<string>>;
+    matchDevicesBySorted(filter: BaseSortableFilterOptions<Device>): Promise<Array<string>>;
+    deleteDevice(deviceId: string): Promise<DocIdentifier>;
+    deleteDevices(deviceIds: Array<string>): Promise<Array<DocIdentifier>>;
+    getDevicesInGroup(groupId: string, options?: {
+        deviceIds?: Array<string> | undefined;
+    }): Promise<Array<Device>>;
+    modifyDeviceInGroup(groupId: string, device: Device): Promise<Device>;
+    createDeviceInGroup(groupId: string, device: Device): Promise<Device>;
+    deleteDevicesInGroup(groupId: string, deviceIds: string): Promise<Array<DocIdentifier>>;
+}

package/api/DeviceApi.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DeviceApi.mjs.map

package/api/DeviceApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeviceApi.mjs","sourceRoot":"","sources":["../../tsSourcesProject/api/DeviceApi.mts"],"names":[],"mappings":"","sourcesContent":["// auto-generated file\nimport {BaseFilterOptions, BaseSortableFilterOptions, PaginatedListIterator} from '../cardinal-sdk-ts.mjs';\nimport {Device} from '../model/Device.mjs';\nimport {IdWithRev} from '../model/IdWithRev.mjs';\nimport {DocIdentifier} from '../model/couchdb/DocIdentifier.mjs';\n\n\nexport interface DeviceApi {\n\n\tgetDevice(deviceId: string): Promise<Device>;\n\n\tgetDevices(deviceIds: Array<string>): Promise<Array<Device>>;\n\n\tcreateDevice(p: Device): Promise<Device>;\n\n\tmodifyDevice(device: Device): Promise<Device>;\n\n\tcreateDevices(devices: Array<Device>): Promise<Array<IdWithRev>>;\n\n\tmodifyDevices(devices: Array<Device>): Promise<Array<IdWithRev>>;\n\n\tfilterDevicesBy(filter: BaseFilterOptions<Device>): Promise<PaginatedListIterator<Device>>;\n\n\tfilterDevicesBySorted(filter: BaseSortableFilterOptions<Device>): Promise<PaginatedListIterator<Device>>;\n\n\tmatchDevicesBy(filter: BaseFilterOptions<Device>): Promise<Array<string>>;\n\n\tmatchDevicesBySorted(filter: BaseSortableFilterOptions<Device>): Promise<Array<string>>;\n\n\tdeleteDevice(deviceId: string): Promise<DocIdentifier>;\n\n\tdeleteDevices(deviceIds: Array<string>): Promise<Array<DocIdentifier>>;\n\n\tgetDevicesInGroup(groupId: string,\n\t\t\toptions?: { deviceIds?: Array<string> | undefined }): Promise<Array<Device>>;\n\n\tmodifyDeviceInGroup(groupId: string, device: Device): Promise<Device>;\n\n\tcreateDeviceInGroup(groupId: string, device: Device): Promise<Device>;\n\n\tdeleteDevicesInGroup(groupId: string, deviceIds: string): Promise<Array<DocIdentifier>>;\n\n}\n"]}