@icure/cardinal-sdk 3.0.0-PREVIEW.7 → 3.0.0-PREVIEW.8

package/crypto/entities/DelegateShareOptions.d.mts

@@ -0,0 +1,9 @@
+import { RequestedPermission } from '../../model/requests/RequestedPermission.mjs';
+import { HexString } from '../../model/specializations/HexString.mjs';
+export declare class DelegateShareOptions {
+    shareSecretIds: Array<string>;
+    shareEncryptionKeys: Array<HexString>;
+    shareOwningEntityIds: Array<string>;
+    requestedPermissions: RequestedPermission;
+    constructor(partial: Partial<DelegateShareOptions> & Pick<DelegateShareOptions, "shareSecretIds" | "shareEncryptionKeys" | "shareOwningEntityIds" | "requestedPermissions">);
+}

package/crypto/entities/DelegateShareOptions.mjs

@@ -0,0 +1,8 @@
+export class DelegateShareOptions {
+    constructor(partial) {
+        this.shareSecretIds = partial.shareSecretIds;
+        this.shareEncryptionKeys = partial.shareEncryptionKeys;
+        this.shareOwningEntityIds = partial.shareOwningEntityIds;
+        this.requestedPermissions = partial.requestedPermissions;
+    }
+}

package/crypto/entities/ShareAllPatientDataOptions.d.mts

@@ -0,0 +1,49 @@
+import { EncryptedPatient } from '../../model/Patient.mjs';
+import { FailedRequestDetails } from './FailedRequestDetails.mjs';
+import { ShareAllPatientDataOptions as ShareAllPatientDataOptions_ } from './ShareAllPatientDataOptions.mjs';
+export declare namespace ShareAllPatientDataOptions {
+    /**
+     *
+     *  Specifies which entities related to a Patient will be shared by [PatientApi.shareAllDataOfPatient].
+     */
+    enum Tag {
+        All = "All",
+        MedicalInformation = "MedicalInformation",
+        FinancialInformation = "FinancialInformation"
+    }
+    enum ShareableEntity {
+        CalendarItem = "CalendarItem",
+        Contact = "Contact",
+        Classification = "Classification",
+        Document = "Document",
+        Form = "Form",
+        HealthElement = "HealthElement",
+        Invoice = "Invoice",
+        Patient = "Patient"
+    }
+    class EntityResult {
+        success: boolean | undefined;
+        error: ShareAllPatientDataOptions_.SharePatientDataError | undefined;
+        modified: number;
+        constructor(partial: Partial<EntityResult> & Pick<EntityResult, "modified">);
+    }
+    class Result {
+        patient: EncryptedPatient;
+        statuses: {
+            [key in ShareAllPatientDataOptions_.ShareableEntity]?: ShareAllPatientDataOptions_.EntityResult;
+        };
+        constructor(partial: Partial<Result> & Pick<Result, "patient" | "statuses">);
+    }
+    type SharePatientDataError = BulkShareFailure | FailedRequest;
+    class BulkShareFailure {
+        errors: Array<FailedRequestDetails>;
+        message: string;
+        readonly $ktClass: 'com.icure.cardinal.sdk.crypto.entities.ShareAllPatientDataOptions.BulkShareFailure';
+        constructor(partial: Partial<BulkShareFailure> & Pick<BulkShareFailure, "errors" | "message">);
+    }
+    class FailedRequest {
+        description: string;
+        readonly $ktClass: 'com.icure.cardinal.sdk.crypto.entities.ShareAllPatientDataOptions.FailedRequest';
+        constructor(partial: Partial<FailedRequest> & Pick<FailedRequest, "description">);
+    }
+}

package/crypto/entities/ShareAllPatientDataOptions.mjs

@@ -0,0 +1,58 @@
+export var ShareAllPatientDataOptions;
+(function (ShareAllPatientDataOptions) {
+    /**
+     *
+     *  Specifies which entities related to a Patient will be shared by [PatientApi.shareAllDataOfPatient].
+     */
+    let Tag;
+    (function (Tag) {
+        Tag["All"] = "All";
+        Tag["MedicalInformation"] = "MedicalInformation";
+        Tag["FinancialInformation"] = "FinancialInformation";
+    })(Tag = ShareAllPatientDataOptions.Tag || (ShareAllPatientDataOptions.Tag = {}));
+    let ShareableEntity;
+    (function (ShareableEntity) {
+        ShareableEntity["CalendarItem"] = "CalendarItem";
+        ShareableEntity["Contact"] = "Contact";
+        ShareableEntity["Classification"] = "Classification";
+        ShareableEntity["Document"] = "Document";
+        ShareableEntity["Form"] = "Form";
+        ShareableEntity["HealthElement"] = "HealthElement";
+        ShareableEntity["Invoice"] = "Invoice";
+        ShareableEntity["Patient"] = "Patient";
+    })(ShareableEntity = ShareAllPatientDataOptions.ShareableEntity || (ShareAllPatientDataOptions.ShareableEntity = {}));
+    class EntityResult {
+        constructor(partial) {
+            this.success = undefined;
+            this.error = undefined;
+            if ('success' in partial)
+                this.success = partial.success;
+            if ('error' in partial)
+                this.error = partial.error;
+            this.modified = partial.modified;
+        }
+    }
+    ShareAllPatientDataOptions.EntityResult = EntityResult;
+    class Result {
+        constructor(partial) {
+            this.patient = partial.patient;
+            this.statuses = partial.statuses;
+        }
+    }
+    ShareAllPatientDataOptions.Result = Result;
+    class BulkShareFailure {
+        constructor(partial) {
+            this.$ktClass = 'com.icure.cardinal.sdk.crypto.entities.ShareAllPatientDataOptions.BulkShareFailure';
+            this.errors = partial.errors;
+            this.message = partial.message;
+        }
+    }
+    ShareAllPatientDataOptions.BulkShareFailure = BulkShareFailure;
+    class FailedRequest {
+        constructor(partial) {
+            this.$ktClass = 'com.icure.cardinal.sdk.crypto.entities.ShareAllPatientDataOptions.FailedRequest';
+            this.description = partial.description;
+        }
+    }
+    ShareAllPatientDataOptions.FailedRequest = FailedRequest;
+})(ShareAllPatientDataOptions || (ShareAllPatientDataOptions = {}));

package/filters/ClassificationFilters.d.mts

@@ -0,0 +1,114 @@
+import { BaseSortableFilterOptions, SortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { Classification } from '../model/Classification.mjs';
+import { Patient } from '../model/Patient.mjs';
+interface ClassificationFiltersFactory {
+    /**
+     *
+     *  Options for classification filtering which match all classifications shared directly (i.e. ignoring hierarchies) with a specific data owner
+     *  that are linked with one of the provided patients.
+     *  This Options also allows to restrict the classifications based on [Classification.created]:
+     *  - if the [from] timestamp is not null, only the classifications where [Classification.created] is greater than or equal to [from] will be returned.
+     *  - if the [to] timestamp is not null, only the classifications where [Classification.created] is less than or equal to [to] will be returned.
+     *
+     *  When using these options the sdk will automatically extract the secret ids from the provided patients and use
+     *  those for filtering.
+     *  If you already have the secret ids of the patient you may instead use [byPatientSecretIdsCreatedForDataOwner].
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *  Note that these may not be used in methods of apis from [CardinalBaseApis].
+     *
+     *  These options are sortable. When sorting using these options the classifications will be sorted by [Classification.created] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param dataOwnerId a data owner id
+     *  @param patients a list of patients.
+     *  @param from the minimum timestamp for [Classification.created] (default: no limit).
+     *  @param to the maximum timestamp for [Classification.created] (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [Classification.created] (default: ascending).
+     */
+    byPatientsCreatedForDataOwner(dataOwnerId: string, patients: Array<Patient>, options?: {
+        from?: number | undefined;
+        to?: number | undefined;
+        descending?: boolean;
+    }): SortableFilterOptions<Classification>;
+    /**
+     *
+     *  Options for classification filtering which match all classifications shared directly (i.e. ignoring hierarchies) with the current data owner
+     *  that are linked with one of the provided patients.
+     *  This Options also allows to restrict the classifications based on [Classification.created]:
+     *  - if the [from] timestamp is not null, only the classifications where [Classification.created] is greater than or equal to [from] will be returned.
+     *  - if the [to] timestamp is not null, only the classifications where [Classification.created] is less than or equal to [to] will be returned.
+     *
+     *  When using these options the sdk will automatically extract the secret ids from the provided patients and use
+     *  those for filtering.
+     *  If you already have the secret ids of the patient you may instead use [byPatientSecretIdsCreatedForSelf].
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *  Note that these may not be used in methods of apis from [CardinalBaseApis].
+     *
+     *  These options are sortable. When sorting using these options the classifications will be sorted by [Classification.created] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param patients a list of patients.
+     *  @param from the minimum timestamp for [Classification.created] (default: no limit).
+     *  @param to the maximum timestamp for [Classification.created] (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [Classification.created] (default: ascending).
+     */
+    byPatientsCreatedForSelf(patients: Array<Patient>, options?: {
+        from?: number | undefined;
+        to?: number | undefined;
+        descending?: boolean;
+    }): SortableFilterOptions<Classification>;
+    /**
+     *
+     *  Options for classification filtering which match all classifications shared directly (i.e. ignoring hierarchies) with a specific data owner
+     *  that are linked with one of the provided patients through one of the provided secret ids.
+     *  This Options also allows to restrict the classifications based on [Classification.created]:
+     *  - if the [from] timestamp is not null, only the classifications where [Classification.created] is greater than or equal to [from] will be returned.
+     *  - if the [to] timestamp is not null, only the classifications where [Classification.created] is less than or equal to [to] will be returned.
+     *
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *
+     *  These options are sortable. When sorting using these options the classifications will be sorted by [Classification.created] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param dataOwnerId a data owner id.
+     *  @param secretIds a list of secret ids from one or more patients.
+     *  @param from the minimum timestamp for [Classification.created] (default: no limit).
+     *  @param to the maximum timestamp for [Classification.created] (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [Classification.created] (default: ascending).
+     */
+    byPatientSecretIdsCreatedForDataOwner(dataOwnerId: string, secretIds: Array<string>, options?: {
+        from?: number | undefined;
+        to?: number | undefined;
+        descending?: boolean;
+    }): BaseSortableFilterOptions<Classification>;
+    /**
+     *
+     *  Options for classification filtering which match all classifications shared directly (i.e. ignoring hierarchies) with the current data owner
+     *  that are linked with one of the provided patients through one of the provided secret ids.
+     *  This Options also allows to restrict the classifications based on [Classification.created]:
+     *  - if the [from] timestamp is not null, only the classifications where [Classification.created] is greater than or equal to [from] will be returned.
+     *  - if the [to] timestamp is not null, only the classifications where [Classification.created] is less than or equal to [to] will be returned.
+     *
+     *  If the current data owner does not have access to any secret id of one of the provide patients the patient will
+     *  simply be ignored.
+     *  Note that these may not be used in methods of apis from [CardinalBaseApis].
+     *
+     *  These options are sortable. When sorting using these options the classifications will be sorted by [Classification.created] in ascending or
+     *  descending order according to the value of the [descending] parameter.
+     *
+     *  @param secretIds a list of secret ids from one or more patients.
+     *  @param from the minimum timestamp for [Classification.created] (default: no limit).
+     *  @param to the maximum timestamp for [Classification.created] (default: no limit).
+     *  @param descending whether to sort the result in descending or ascending order by [Classification.created] (default: ascending).
+     */
+    byPatientSecretIdsCreatedForSelf(secretIds: Array<string>, options?: {
+        from?: number | undefined;
+        to?: number | undefined;
+        descending?: boolean;
+    }): SortableFilterOptions<Classification>;
+}
+export declare const ClassificationFilters: ClassificationFiltersFactory;
+export {};

package/filters/ClassificationFilters.mjs

@@ -0,0 +1,8 @@
+// auto-generated file
+import { InternalClassificationFiltersObj } from '../cardinal-sdk-ts.mjs';
+export const ClassificationFilters = {
+    byPatientsCreatedForDataOwner: (dataOwnerId, patients, options) => InternalClassificationFiltersObj.getInstance().byPatientsCreatedForDataOwner(dataOwnerId, patients, options),
+    byPatientsCreatedForSelf: (patients, options) => InternalClassificationFiltersObj.getInstance().byPatientsCreatedForSelf(patients, options),
+    byPatientSecretIdsCreatedForDataOwner: (dataOwnerId, secretIds, options) => InternalClassificationFiltersObj.getInstance().byPatientSecretIdsCreatedForDataOwner(dataOwnerId, secretIds, options),
+    byPatientSecretIdsCreatedForSelf: (secretIds, options) => InternalClassificationFiltersObj.getInstance().byPatientSecretIdsCreatedForSelf(secretIds, options)
+};

package/filters/MedicalLocationFilters.d.mts

@@ -0,0 +1,8 @@
+import { BaseFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { MedicalLocation } from '../model/MedicalLocation.mjs';
+interface MedicalLocationFiltersFactory {
+    all(): BaseFilterOptions<MedicalLocation>;
+    byPostCode(postCode: string): BaseFilterOptions<MedicalLocation>;
+}
+export declare const MedicalLocationFilters: MedicalLocationFiltersFactory;
+export {};

package/filters/MedicalLocationFilters.mjs

@@ -0,0 +1,6 @@
+// auto-generated file
+import { InternalMedicalLocationFiltersObj } from '../cardinal-sdk-ts.mjs';
+export const MedicalLocationFilters = {
+    all: () => InternalMedicalLocationFiltersObj.getInstance().all(),
+    byPostCode: (postCode) => InternalMedicalLocationFiltersObj.getInstance().byPostCode(postCode)
+};

package/filters/TimeTableFilters.d.mts

@@ -0,0 +1,12 @@
+import { BaseFilterOptions, BaseSortableFilterOptions } from '../cardinal-sdk-ts.mjs';
+import { TimeTable } from '../model/TimeTable.mjs';
+interface TimeTableFiltersFactory {
+    byAgendaId(agendaId: string): BaseFilterOptions<TimeTable>;
+    byPeriodAndAgendaId(agendaId: string, options?: {
+        from?: number | undefined;
+        to?: number | undefined;
+        descending?: boolean;
+    }): BaseSortableFilterOptions<TimeTable>;
+}
+export declare const TimeTableFilters: TimeTableFiltersFactory;
+export {};

package/filters/TimeTableFilters.mjs

@@ -0,0 +1,6 @@
+// auto-generated file
+import { InternalTimeTableFiltersObj } from '../cardinal-sdk-ts.mjs';
+export const TimeTableFilters = {
+    byAgendaId: (agendaId) => InternalTimeTableFiltersObj.getInstance().byAgendaId(agendaId),
+    byPeriodAndAgendaId: (agendaId, options) => InternalTimeTableFiltersObj.getInstance().byPeriodAndAgendaId(agendaId, options)
+};

package/kotlin-kotlin-stdlib.mjs

@@ -93,8 +93,8 @@ initMetadataForInterface(Entry, 'Entry');
 initMetadataForInterface(KtMap, 'Map');
 initMetadataForInterface(KtSet, 'Set', VOID, VOID, [Collection]);
 initMetadataForInterface(MutableIterable, 'MutableIterable');
-initMetadataForInterface(KtMutableSet, 'MutableSet', VOID, VOID, [KtSet, MutableIterable, Collection]);
-initMetadataForInterface(KtMutableList, 'MutableList', VOID, VOID, [KtList, MutableIterable, Collection]);
+initMetadataForInterface(KtMutableSet, 'MutableSet', VOID, VOID, [KtSet, Collection, MutableIterable]);
+initMetadataForInterface(KtMutableList, 'MutableList', VOID, VOID, [KtList, Collection, MutableIterable]);
 initMetadataForInterface(KtMutableMap, 'MutableMap', VOID, VOID, [KtMap]);
 initMetadataForCompanion(Companion_0);
 initMetadataForClass(Enum, 'Enum', VOID, VOID, [Comparable]);
@@ -115,7 +115,7 @@ initMetadataForInterface(AutoCloseable, 'AutoCloseable');
 initMetadataForInterface(Comparator, 'Comparator');
 initMetadataForObject(Unit, 'Unit');
 initMetadataForClass(AbstractCollection, 'AbstractCollection', VOID, VOID, [Collection]);
-initMetadataForClass(AbstractMutableCollection, 'AbstractMutableCollection', VOID, AbstractCollection, [MutableIterable, Collection]);
+initMetadataForClass(AbstractMutableCollection, 'AbstractMutableCollection', VOID, AbstractCollection, [Collection, MutableIterable]);
 initMetadataForClass(IteratorImpl, 'IteratorImpl');
 initMetadataForClass(ListIteratorImpl, 'ListIteratorImpl', VOID, IteratorImpl);
 initMetadataForClass(AbstractMutableList, 'AbstractMutableList', VOID, AbstractMutableCollection, [KtMutableList]);
@@ -128,7 +128,7 @@ initMetadataForCompanion(Companion_2);
 initMetadataForClass(ArrayList, 'ArrayList', ArrayList_init_$Create$, AbstractMutableList, [KtMutableList, RandomAccess]);
 initMetadataForClass(HashMap, 'HashMap', HashMap_init_$Create$, AbstractMutableMap, [KtMutableMap]);
 initMetadataForClass(HashMapKeys, 'HashMapKeys', VOID, AbstractMutableSet, [KtMutableSet]);
-initMetadataForClass(HashMapValues, 'HashMapValues', VOID, AbstractMutableCollection, [MutableIterable, Collection]);
+initMetadataForClass(HashMapValues, 'HashMapValues', VOID, AbstractMutableCollection, [Collection, MutableIterable]);
 initMetadataForClass(HashMapEntrySetBase, 'HashMapEntrySetBase', VOID, AbstractMutableSet, [KtMutableSet]);
 initMetadataForClass(HashMapEntrySet, 'HashMapEntrySet', VOID, HashMapEntrySetBase);
 initMetadataForClass(HashMapKeysDefault$iterator$1);

package/kotlinx-coroutines-core.mjs

@@ -294,7 +294,7 @@ initMetadataForClass(ContextScope, 'ContextScope', VOID, VOID, [CoroutineScope])
 initMetadataForClass(Symbol, 'Symbol');
 initMetadataForInterface(SelectInstance, 'SelectInstance');
 initMetadataForClass(ClauseData, 'ClauseData', VOID, VOID, VOID, [1]);
-initMetadataForClass(SelectImplementation, 'SelectImplementation', VOID, VOID, [CancelHandler, SelectInstance, Waiter], [0, 2]);
+initMetadataForClass(SelectImplementation, 'SelectImplementation', VOID, VOID, [CancelHandler, Waiter, SelectInstance], [0, 2]);
 initMetadataForClass(TrySelectDetailedResult, 'TrySelectDetailedResult', VOID, Enum);
 initMetadataForClass(CancellableContinuationWithOwner, 'CancellableContinuationWithOwner', VOID, VOID, [CancellableContinuation, Waiter]);
 initMetadataForClass(SemaphoreAndMutexImpl, 'SemaphoreAndMutexImpl', VOID, VOID, VOID, [0]);

package/model/ApplicationSettings.d.mts

@@ -0,0 +1,87 @@
+import { CodeStub } from './base/CodeStub.mjs';
+import { HasEncryptionMetadata } from './base/HasEncryptionMetadata.mjs';
+import { HasEndOfLife } from './base/HasEndOfLife.mjs';
+import { ICureDocument } from './base/ICureDocument.mjs';
+import { StoredDocument } from './base/StoredDocument.mjs';
+import { Delegation } from './embed/Delegation.mjs';
+import { Encryptable } from './embed/Encryptable.mjs';
+import { SecurityMetadata } from './embed/SecurityMetadata.mjs';
+import { Base64String } from './specializations/Base64String.mjs';
+export interface ApplicationSettings extends StoredDocument, ICureDocument<string>, HasEncryptionMetadata, Encryptable, HasEndOfLife {
+    settings: {
+        [key: string]: string;
+    };
+    encryptedSettings: {
+        [key: string]: string;
+    };
+    readonly isEncrypted: boolean;
+    toJSON(): object;
+}
+export declare class DecryptedApplicationSettings {
+    id: string;
+    rev: string | undefined;
+    created: number | undefined;
+    modified: number | undefined;
+    author: string | undefined;
+    responsible: string | undefined;
+    tags: Array<CodeStub>;
+    codes: Array<CodeStub>;
+    endOfLife: number | undefined;
+    deletionDate: number | undefined;
+    settings: {
+        [key: string]: string;
+    };
+    encryptedSettings: {
+        [key: string]: string;
+    };
+    secretForeignKeys: Array<string>;
+    cryptedForeignKeys: {
+        [key: string]: Array<Delegation>;
+    };
+    delegations: {
+        [key: string]: Array<Delegation>;
+    };
+    encryptionKeys: {
+        [key: string]: Array<Delegation>;
+    };
+    securityMetadata: SecurityMetadata | undefined;
+    encryptedSelf: Base64String | undefined;
+    readonly isEncrypted: false;
+    constructor(partial: Partial<DecryptedApplicationSettings>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): DecryptedApplicationSettings;
+}
+export declare class EncryptedApplicationSettings {
+    id: string;
+    rev: string | undefined;
+    created: number | undefined;
+    modified: number | undefined;
+    author: string | undefined;
+    responsible: string | undefined;
+    tags: Array<CodeStub>;
+    codes: Array<CodeStub>;
+    endOfLife: number | undefined;
+    deletionDate: number | undefined;
+    settings: {
+        [key: string]: string;
+    };
+    encryptedSettings: {
+        [key: string]: string;
+    };
+    secretForeignKeys: Array<string>;
+    cryptedForeignKeys: {
+        [key: string]: Array<Delegation>;
+    };
+    delegations: {
+        [key: string]: Array<Delegation>;
+    };
+    encryptionKeys: {
+        [key: string]: Array<Delegation>;
+    };
+    securityMetadata: SecurityMetadata | undefined;
+    encryptedSelf: Base64String | undefined;
+    readonly isEncrypted: true;
+    constructor(partial: Partial<EncryptedApplicationSettings>);
+    toJSON(): object;
+    static fromJSON(json: any, ignoreUnknownKeys?: boolean, path?: Array<string>): EncryptedApplicationSettings;
+}