@icure/cardinal-sdk 3.0.0-PREVIEW-4 → 3.0.0-PREVIEW.6

package/model/base/CryptoActor.d.mts

@@ -8,8 +8,7 @@ import { Versionable } from './Versionable.mjs';
  *
  *
  *   Interface for entities that participate in the iCure end-to-end encryption system.
- *   A CryptoActor holds the cryptographic keys and key exchange material needed for secure data
- *  sharing.
+ *   A CryptoActor holds the cryptographic keys and key exchange material needed for secure data sharing.
  */
 export interface CryptoActor extends Versionable<string> {
     hcPartyKeys: {
@@ -35,149 +34,113 @@ export interface CryptoActor extends Versionable<string> {
     /**
      *
      *
-     *   The links to the data owners representing the organizations, administrative units or other
-     *  loose groups of
+     *   The links to the data owners representing the organizations, administrative units or other loose groups of
      *   healthcare parties this crypto actor belongs to.
-     *   There are different types of links, which have different implication on access control and
-     *  requirements for
+     *   There are different types of links, which have different implication on access control and requirements for
      *   sharing data among all members of the group.
      *
-     *   This list should be considered as unordered, and it may not contain two links pointing to the
-     *  same data owner,
+     *   This list should be considered as unordered, and it may not contain two links pointing to the same data owner,
      *   regardless of type.
      *
      *   # Membership propagation
      *
-     *   All links are transitive, whatever their type: every directly linked group is a group of the
-     *  actor, and the groups
-     *   of a group are also groups of the actor (applied recursively). An actor is therefore a member
-     *  of every group
+     *   All links are transitive, whatever their type: every directly linked group is a group of the actor, and the groups
+     *   of a group are also groups of the actor (applied recursively). An actor is therefore a member of every group
      *   reachable through a path of links.
      *
-     *   For example with `hcp -parent-> department -simple-> building -simple-> campus`: the groups of
-     *  `hcp` are
+     *   For example with `hcp -parent-> department -simple-> building -simple-> campus`: the groups of `hcp` are
      *   `department`, `building` and `campus`.
      *
-     *   There may however be restrictions in place on how propagation when the link type changes:
-     *  propagation from a
+     *   There may however be restrictions in place on how propagation when the link type changes: propagation from a
      *   parent link to a simple link is allowed, but the opposite is not.
-     *   A group membership such as `hcp -parent-> department -simple-> building -parent-> campus` is
-     *  not allowed: while
-     *   the relationships of `building` are technically valid the full membership for `department` or
-     *  `hcp` is invalid,
+     *   A group membership such as `hcp -parent-> department -simple-> building -parent-> campus` is not allowed: while
+     *   the relationships of `building` are technically valid the full membership for `department` or `hcp` is invalid,
      *   and a user associated with a data owner that has invalid membership is not allowed to login.
      *
      *   # Why groups instead of direct sharing with members
      *
-     *   By using groups of data owners instead of directly sharing data with each data owner in a group
-     *  you gain two
+     *   By using groups of data owners instead of directly sharing data with each data owner in a group you gain two
      *   major advantages:
      *   - Reduced size of metadata on entities
-     *   - Possibility of dynamically adding peoples to a group without having to update all the
-     *  entities that they should
+     *   - Possibility of dynamically adding peoples to a group without having to update all the entities that they should
      *     be able to access
      *
-     *   In a full-scale system where data is massively shared between groups of users using data owner
-     *  groups is the
+     *   In a full-scale system where data is massively shared between groups of users using data owner groups is the
      *   only realistic choice available.
      */
     dataOwnerGroups: Array<DataOwnerGroupLink>;
     /**
      *
-     *  The links to the data owners representing the organizations, administrative units or other loose
-     *  groups of
+     *  The links to the data owners representing the organizations, administrative units or other loose groups of
      *  healthcare parties this crypto actor belongs to.
-     *  There are different types of links, which have different implication on access control and
-     *  requirements for
+     *  There are different types of links, which have different implication on access control and requirements for
      *  sharing data among all members of the group.
      *
-     *  This list should be considered as unordered, and it may not contain two links pointing to the
-     *  same data owner,
+     *  This list should be considered as unordered, and it may not contain two links pointing to the same data owner,
      *  regardless of type.
      *
      *  # Membership propagation
      *
-     *  All links are transitive, whatever their type: every directly linked group is a group of the
-     *  actor, and the groups
-     *  of a group are also groups of the actor (applied recursively). An actor is therefore a member of
-     *  every group
+     *  All links are transitive, whatever their type: every directly linked group is a group of the actor, and the groups
+     *  of a group are also groups of the actor (applied recursively). An actor is therefore a member of every group
      *  reachable through a path of links.
      *
-     *  For example with `hcp -parent-> department -simple-> building -simple-> campus`: the groups of
-     *  `hcp` are
+     *  For example with `hcp -parent-> department -simple-> building -simple-> campus`: the groups of `hcp` are
      *  `department`, `building` and `campus`.
      *
-     *  There may however be restrictions in place on how propagation when the link type changes:
-     *  propagation from a
+     *  There may however be restrictions in place on how propagation when the link type changes: propagation from a
      *  parent link to a simple link is allowed, but the opposite is not.
-     *  A group membership such as `hcp -parent-> department -simple-> building -parent-> campus` is not
-     *  allowed: while
-     *  the relationships of `building` are technically valid the full membership for `department` or
-     *  `hcp` is invalid,
+     *  A group membership such as `hcp -parent-> department -simple-> building -parent-> campus` is not allowed: while
+     *  the relationships of `building` are technically valid the full membership for `department` or `hcp` is invalid,
      *  and a user associated with a data owner that has invalid membership is not allowed to login.
      *
      *  # Why groups instead of direct sharing with members
      *
-     *  By using groups of data owners instead of directly sharing data with each data owner in a group
-     *  you gain two
+     *  By using groups of data owners instead of directly sharing data with each data owner in a group you gain two
      *  major advantages:
      *  - Reduced size of metadata on entities
-     *  - Possibility of dynamically adding peoples to a group without having to update all the entities
-     *  that they should
+     *  - Possibility of dynamically adding peoples to a group without having to update all the entities that they should
      *  be able to access
      *
-     *  In a full-scale system where data is massively shared between groups of users using data owner
-     *  groups is the
+     *  In a full-scale system where data is massively shared between groups of users using data owner groups is the
      *  only realistic choice available.
      *  /
      */
     groupLinkType: DataOwnerGroupLinkType | undefined;
     /**
      *
-     *  The links to the data owners representing the organizations, administrative units or other loose
-     *  groups of
+     *  The links to the data owners representing the organizations, administrative units or other loose groups of
      *  healthcare parties this crypto actor belongs to.
-     *  There are different types of links, which have different implication on access control and
-     *  requirements for
+     *  There are different types of links, which have different implication on access control and requirements for
      *  sharing data among all members of the group.
      *
-     *  This list should be considered as unordered, and it may not contain two links pointing to the
-     *  same data owner,
+     *  This list should be considered as unordered, and it may not contain two links pointing to the same data owner,
      *  regardless of type.
      *
      *  # Membership propagation
      *
-     *  All links are transitive, whatever their type: every directly linked group is a group of the
-     *  actor, and the groups
-     *  of a group are also groups of the actor (applied recursively). An actor is therefore a member of
-     *  every group
+     *  All links are transitive, whatever their type: every directly linked group is a group of the actor, and the groups
+     *  of a group are also groups of the actor (applied recursively). An actor is therefore a member of every group
      *  reachable through a path of links.
      *
-     *  For example with `hcp -parent-> department -simple-> building -simple-> campus`: the groups of
-     *  `hcp` are
+     *  For example with `hcp -parent-> department -simple-> building -simple-> campus`: the groups of `hcp` are
      *  `department`, `building` and `campus`.
      *
-     *  There may however be restrictions in place on how propagation when the link type changes:
-     *  propagation from a
+     *  There may however be restrictions in place on how propagation when the link type changes: propagation from a
      *  parent link to a simple link is allowed, but the opposite is not.
-     *  A group membership such as `hcp -parent-> department -simple-> building -parent-> campus` is not
-     *  allowed: while
-     *  the relationships of `building` are technically valid the full membership for `department` or
-     *  `hcp` is invalid,
+     *  A group membership such as `hcp -parent-> department -simple-> building -parent-> campus` is not allowed: while
+     *  the relationships of `building` are technically valid the full membership for `department` or `hcp` is invalid,
      *  and a user associated with a data owner that has invalid membership is not allowed to login.
      *
      *  # Why groups instead of direct sharing with members
      *
-     *  By using groups of data owners instead of directly sharing data with each data owner in a group
-     *  you gain two
+     *  By using groups of data owners instead of directly sharing data with each data owner in a group you gain two
      *  major advantages:
      *  - Reduced size of metadata on entities
-     *  - Possibility of dynamically adding peoples to a group without having to update all the entities
-     *  that they should
+     *  - Possibility of dynamically adding peoples to a group without having to update all the entities that they should
      *  be able to access
      *
-     *  In a full-scale system where data is massively shared between groups of users using data owner
-     *  groups is the
+     *  In a full-scale system where data is massively shared between groups of users using data owner groups is the
      *  only realistic choice available.
      *  /
      */

package/model/base/DataOwner.d.mts

@@ -3,8 +3,7 @@ import { PropertyStub } from '../PropertyStub.mjs';
  *
  *
  *   Interface for entities that own and control access to encrypted data in the iCure system.
- *   Data owners (such as healthcare parties, patients, and devices) can grant access to their data
- *  through delegations.
+ *   Data owners (such as healthcare parties, patients, and devices) can grant access to their data through delegations.
  */
 export interface DataOwner {
     properties: Array<PropertyStub>;

package/model/base/DataOwnerGroupLink.d.mts

@@ -1,10 +1,8 @@
 /**
  *
  *
- *   A link from a crypto actor to a data owner that represents a group it belongs to. The type of
- *  the link is not
- *   declared here: it is intrinsic to the linked data owner itself, see
- *  [CryptoActorDto.groupLinkType].
+ *   A link from a crypto actor to a data owner that represents a group it belongs to. The type of the link is not
+ *   declared here: it is intrinsic to the linked data owner itself, see [CryptoActorDto.groupLinkType].
  */
 export declare class DataOwnerGroupLink {
     /**

package/model/base/DataOwnerGroupLink.mjs

@@ -3,10 +3,8 @@ import { expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 /**
  *
  *
- *   A link from a crypto actor to a data owner that represents a group it belongs to. The type of
- *  the link is not
- *   declared here: it is intrinsic to the linked data owner itself, see
- *  [CryptoActorDto.groupLinkType].
+ *   A link from a crypto actor to a data owner that represents a group it belongs to. The type of the link is not
+ *   declared here: it is intrinsic to the linked data owner itself, see [CryptoActorDto.groupLinkType].
  */
 export class DataOwnerGroupLink {
     constructor(partial) {

package/model/base/DataOwnerGroupLinkType.d.mts

@@ -3,8 +3,7 @@
  *
  *   The nature of the link between a crypto actor and a data owner representing one of its groups.
  *
- *   This is intrinsic to the *target* of the link (see [CryptoActorDto.groupLinkType]): every link
- *  pointing at a
+ *   This is intrinsic to the *target* of the link (see [CryptoActorDto.groupLinkType]): every link pointing at a
  *   given data owner has the same type, whoever declares it.
  */
 export declare enum DataOwnerGroupLinkType {

package/model/base/DataOwnerGroupLinkType.mjs

@@ -4,8 +4,7 @@
  *
  *   The nature of the link between a crypto actor and a data owner representing one of its groups.
  *
- *   This is intrinsic to the *target* of the link (see [CryptoActorDto.groupLinkType]): every link
- *  pointing at a
+ *   This is intrinsic to the *target* of the link (see [CryptoActorDto.groupLinkType]): every link pointing at a
  *   given data owner has the same type, whoever declares it.
  */
 export var DataOwnerGroupLinkType;

package/model/base/DataOwnerHierarchyInfo.d.mts

@@ -20,10 +20,8 @@ export declare class DataOwnerHierarchyInfo {
     /**
      *
      *
-     *   One node for each group the data owner is directly linked to, through the legacy parentId or a
-     *  dataOwnerGroups
-     *   link, in the declaration order of the links. A group reachable through multiple paths appears
-     *  in each path.
+     *   One node for each group the data owner is directly linked to, through the legacy parentId or a dataOwnerGroups
+     *   link, in the declaration order of the links. A group reachable through multiple paths appears in each path.
      */
     links: Array<DataOwnerHierarchyInfo.HierarchyNode>;
     constructor(partial: Partial<DataOwnerHierarchyInfo> & Pick<DataOwnerHierarchyInfo, "dataOwnerType">);

package/model/base/DataOwnerHierarchyInfo.mjs

@@ -14,10 +14,8 @@ export class DataOwnerHierarchyInfo {
         /**
          *
          *
-         *   One node for each group the data owner is directly linked to, through the legacy parentId or a
-         *  dataOwnerGroups
-         *   link, in the declaration order of the links. A group reachable through multiple paths appears
-         *  in each path.
+         *   One node for each group the data owner is directly linked to, through the legacy parentId or a dataOwnerGroups
+         *   link, in the declaration order of the links. A group reachable through multiple paths appears in each path.
          */
         this.links = [];
         this.id = (_a = partial.id) !== null && _a !== void 0 ? _a : randomUuid();

package/model/base/HasCodes.d.mts

@@ -2,8 +2,7 @@ import { CodeStub } from './CodeStub.mjs';
 /**
  *
  *
- *   Interface for entities that can be qualified with codes from codification systems such as
- *  SNOMED-CT, ICPC-2, or ICD-10.
+ *   Interface for entities that can be qualified with codes from codification systems such as SNOMED-CT, ICPC-2, or ICD-10.
  */
 export interface HasCodes {
     codes: Array<CodeStub>;

package/model/base/HasEncryptionMetadata.d.mts

@@ -4,8 +4,7 @@ import { Versionable } from './Versionable.mjs';
 /**
  *
  *
- *   Interface for entities that hold encryption metadata used for end-to-end encryption and access
- *  control.
+ *   Interface for entities that hold encryption metadata used for end-to-end encryption and access control.
  *   This includes delegation keys, encrypted foreign keys, and security metadata.
  */
 export interface HasEncryptionMetadata extends Versionable<string> {

package/model/base/HasIdentifier.d.mts

@@ -2,8 +2,7 @@ import { Identifier } from './Identifier.mjs';
 /**
  *
  *
- *   Interface for entities that can be identified uniquely and unambiguously by a set of
- *  identifiers.
+ *   Interface for entities that can be identified uniquely and unambiguously by a set of identifiers.
  */
 export interface HasIdentifier {
     identifier: Array<Identifier>;

package/model/base/HasTags.d.mts

@@ -2,8 +2,7 @@ import { CodeStub } from './CodeStub.mjs';
 /**
  *
  *
- *   Interface for entities that can be classified using tags from codification systems such as
- *  LOINC.
+ *   Interface for entities that can be classified using tags from codification systems such as LOINC.
  *   Tags qualify an entity as belonging to a certain class regardless of its value.
  */
 export interface HasTags {

package/model/base/ICureDocument.d.mts

@@ -5,8 +5,7 @@ import { Identifiable } from './Identifiable.mjs';
  *
  *
  *   Interface for iCure document entities that track creation and modification metadata.
- *   Extends [IdentifiableDto], [HasTagsDto], and [HasCodesDto] to provide a common base for all
- *  medical documents.
+ *   Extends [IdentifiableDto], [HasTagsDto], and [HasCodesDto] to provide a common base for all medical documents.
  */
 export interface ICureDocument<T> extends Identifiable<T>, HasTags, HasCodes {
     created: number | undefined;

package/model/base/LinkQualification.d.mts

@@ -5,29 +5,19 @@
  *
  *   - [narrower] means that the linked codes have a narrower interpretation
  *   - [parent] means that the linked code(s) is the parent of this code
- *   - [sequence] means that the linked codes are a sequence of codes that are part of the current
- *  code
- *   - [basedOn] means a plan, proposal or order that is fulfilled in whole or in part by this event.
- *  For example, a MedicationRequest may require a patient to have laboratory test performed before it
- *  is dispensed.
- *   - [derivedFrom] means the target resource that represents a measurement from which the service
- *  value is derived. For example, a calculated anion gap or a fetal measurement based on an ultrasound
- *  image.
+ *   - [sequence] means that the linked codes are a sequence of codes that are part of the current code
+ *   - [basedOn] means a plan, proposal or order that is fulfilled in whole or in part by this event. For example, a MedicationRequest may require a patient to have laboratory test performed before it is dispensed.
+ *   - [derivedFrom] means the target resource that represents a measurement from which the service value is derived. For example, a calculated anion gap or a fetal measurement based on an ultrasound image.
  *   - [device] means the device used to generate the service data
- *   - [focus] means the actual focus of a service when it is not the patient of record representing
- *  something or someone associated with the patient such as a spouse, parent, fetus, or donor. For
- *  example, fetus observations in a mother's record.
- *   - [hasMember] means this service is a group service (e.g. a battery, a panel of tests, a set of
- *  vital sign measurements) that includes the target as a member of the group
+ *   - [focus] means the actual focus of a service when it is not the patient of record representing something or someone associated with the patient such as a spouse, parent, fetus, or donor. For example, fetus observations in a mother's record.
+ *   - [hasMember] means this service is a group service (e.g. a battery, a panel of tests, a set of vital sign measurements) that includes the target as a member of the group
  *   - [performer] means who was responsible for asserting the observed value as "true".
  *   - [specimen] means the specimen that was used when this service was made
  *   - [request] why the specimen was collected
  *
- *   When creating a link, we encourage creating single direction links. The reverse link can be
- *  found through a view
+ *   When creating a link, we encourage creating single direction links. The reverse link can be found through a view
  *
- *   Favour parent over child as it is better (for conflicts) to change 5 different documents once
- *  instead of changing 5 times the same document
+ *   Favour parent over child as it is better (for conflicts) to change 5 different documents once instead of changing 5 times the same document
  */
 export declare enum LinkQualification {
     Exact = "Exact",

package/model/base/LinkQualification.mjs

@@ -6,29 +6,19 @@
  *
  *   - [narrower] means that the linked codes have a narrower interpretation
  *   - [parent] means that the linked code(s) is the parent of this code
- *   - [sequence] means that the linked codes are a sequence of codes that are part of the current
- *  code
- *   - [basedOn] means a plan, proposal or order that is fulfilled in whole or in part by this event.
- *  For example, a MedicationRequest may require a patient to have laboratory test performed before it
- *  is dispensed.
- *   - [derivedFrom] means the target resource that represents a measurement from which the service
- *  value is derived. For example, a calculated anion gap or a fetal measurement based on an ultrasound
- *  image.
+ *   - [sequence] means that the linked codes are a sequence of codes that are part of the current code
+ *   - [basedOn] means a plan, proposal or order that is fulfilled in whole or in part by this event. For example, a MedicationRequest may require a patient to have laboratory test performed before it is dispensed.
+ *   - [derivedFrom] means the target resource that represents a measurement from which the service value is derived. For example, a calculated anion gap or a fetal measurement based on an ultrasound image.
  *   - [device] means the device used to generate the service data
- *   - [focus] means the actual focus of a service when it is not the patient of record representing
- *  something or someone associated with the patient such as a spouse, parent, fetus, or donor. For
- *  example, fetus observations in a mother's record.
- *   - [hasMember] means this service is a group service (e.g. a battery, a panel of tests, a set of
- *  vital sign measurements) that includes the target as a member of the group
+ *   - [focus] means the actual focus of a service when it is not the patient of record representing something or someone associated with the patient such as a spouse, parent, fetus, or donor. For example, fetus observations in a mother's record.
+ *   - [hasMember] means this service is a group service (e.g. a battery, a panel of tests, a set of vital sign measurements) that includes the target as a member of the group
  *   - [performer] means who was responsible for asserting the observed value as "true".
  *   - [specimen] means the specimen that was used when this service was made
  *   - [request] why the specimen was collected
  *
- *   When creating a link, we encourage creating single direction links. The reverse link can be
- *  found through a view
+ *   When creating a link, we encourage creating single direction links. The reverse link can be found through a view
  *
- *   Favour parent over child as it is better (for conflicts) to change 5 different documents once
- *  instead of changing 5 times the same document
+ *   Favour parent over child as it is better (for conflicts) to change 5 different documents once instead of changing 5 times the same document
  */
 export var LinkQualification;
 (function (LinkQualification) {

package/model/base/StoredDocument.d.mts

@@ -2,8 +2,7 @@ import { Versionable } from './Versionable.mjs';
 /**
  *
  *
- *   Interface for entities that are persisted as CouchDB documents and support hard deletion via a
- *  deletion timestamp.
+ *   Interface for entities that are persisted as CouchDB documents and support hard deletion via a deletion timestamp.
  */
 export interface StoredDocument extends Versionable<string> {
     deletionDate: number | undefined;

package/model/couchdb/Basic.d.mts

@@ -1,7 +1,6 @@
 /**
  *
- *  Data transfer object representing basic authentication credentials for a CouchDB remote
- *  connection.
+ *  Data transfer object representing basic authentication credentials for a CouchDB remote connection.
  *  /
  */
 export declare class Basic {

package/model/couchdb/Basic.mjs

@@ -2,8 +2,7 @@
 import { expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 /**
  *
- *  Data transfer object representing basic authentication credentials for a CouchDB remote
- *  connection.
+ *  Data transfer object representing basic authentication credentials for a CouchDB remote connection.
  *  /
  */
 export class Basic {

package/model/couchdb/DatabaseInfo.d.mts

@@ -1,7 +1,6 @@
 /**
  *
- *  Data transfer object containing information about a CouchDB database, including size metrics and
- *  cluster configuration.
+ *  Data transfer object containing information about a CouchDB database, including size metrics and cluster configuration.
  *  /
  */
 export declare class DatabaseInfo {

package/model/couchdb/DatabaseInfo.mjs

@@ -3,8 +3,7 @@ import { expectNumber, expectString, extractEntry } from '../../internal/JsonDec
 import { randomUuid } from '../../utils/Id.mjs';
 /**
  *
- *  Data transfer object containing information about a CouchDB database, including size metrics and
- *  cluster configuration.
+ *  Data transfer object containing information about a CouchDB database, including size metrics and cluster configuration.
  *  /
  */
 export class DatabaseInfo {

package/model/couchdb/DesignDocument.d.mts

@@ -2,8 +2,7 @@ import { View } from './View.mjs';
 /**
  *
  *
- *   Data transfer object representing a CouchDB design document, which contains views, lists, shows,
- *  filters,
+ *   Data transfer object representing a CouchDB design document, which contains views, lists, shows, filters,
  *   and update handlers used for querying and transforming data.
  */
 export declare class DesignDocument {

package/model/couchdb/DesignDocument.mjs

@@ -5,8 +5,7 @@ import { View } from './View.mjs';
 /**
  *
  *
- *   Data transfer object representing a CouchDB design document, which contains views, lists, shows,
- *  filters,
+ *   Data transfer object representing a CouchDB design document, which contains views, lists, shows, filters,
  *   and update handlers used for querying and transforming data.
  */
 export class DesignDocument {

package/model/couchdb/GroupDatabasesInfo.d.mts

@@ -1,8 +1,7 @@
 import { DatabaseInfo } from './DatabaseInfo.mjs';
 /**
  *
- *  Data transfer object aggregating database information for all databases belonging to a specific
- *  group,
+ *  Data transfer object aggregating database information for all databases belonging to a specific group,
  *  including their storage sizes and GCP storage usage.
  *  /
  */

package/model/couchdb/GroupDatabasesInfo.mjs

@@ -3,8 +3,7 @@ import { expectArray, expectNumber, expectObject, expectString, extractEntry } f
 import { DatabaseInfo } from './DatabaseInfo.mjs';
 /**
  *
- *  Data transfer object aggregating database information for all databases belonging to a specific
- *  group,
+ *  Data transfer object aggregating database information for all databases belonging to a specific group,
  *  including their storage sizes and GCP storage usage.
  *  /
  */

package/model/couchdb/Remote.d.mts

@@ -1,8 +1,7 @@
 import { RemoteAuthentication } from './RemoteAuthentication.mjs';
 /**
  *
- *  Data transfer object representing a remote CouchDB endpoint with its URL and optional
- *  authentication.
+ *  Data transfer object representing a remote CouchDB endpoint with its URL and optional authentication.
  *  /
  */
 export declare class Remote {

package/model/couchdb/Remote.mjs

@@ -3,8 +3,7 @@ import { expectObject, expectString, extractEntry } from '../../internal/JsonDec
 import { RemoteAuthentication } from './RemoteAuthentication.mjs';
 /**
  *
- *  Data transfer object representing a remote CouchDB endpoint with its URL and optional
- *  authentication.
+ *  Data transfer object representing a remote CouchDB endpoint with its URL and optional authentication.
  *  /
  */
 export class Remote {

package/model/couchdb/ReplicatorDocument.d.mts

@@ -3,8 +3,7 @@ import { Remote } from './Remote.mjs';
 import { ReplicationStats } from './ReplicationStats.mjs';
 /**
  *
- *  Data transfer object representing a CouchDB replicator document that tracks the state of a
- *  replication task.
+ *  Data transfer object representing a CouchDB replicator document that tracks the state of a replication task.
  *  /
  */
 export declare class ReplicatorDocument implements Versionable<string> {

package/model/couchdb/ReplicatorDocument.mjs

@@ -5,8 +5,7 @@ import { Remote } from './Remote.mjs';
 import { ReplicationStats } from './ReplicationStats.mjs';
 /**
  *
- *  Data transfer object representing a CouchDB replicator document that tracks the state of a
- *  replication task.
+ *  Data transfer object representing a CouchDB replicator document that tracks the state of a replication task.
  *  /
  */
 export class ReplicatorDocument {

package/model/data/LabelledOccurence.d.mts

@@ -1,7 +1,6 @@
 /**
  *
- *  Data transfer object representing a labelled occurrence count, typically used for aggregation
- *  results.
+ *  Data transfer object representing a labelled occurrence count, typically used for aggregation results.
  *  /
  */
 export declare class LabelledOccurence {

package/model/data/LabelledOccurence.mjs

@@ -2,8 +2,7 @@
 import { expectNumber, expectString, extractEntry } from '../../internal/JsonDecodeUtils.mjs';
 /**
  *
- *  Data transfer object representing a labelled occurrence count, typically used for aggregation
- *  results.
+ *  Data transfer object representing a labelled occurrence count, typically used for aggregation results.
  *  /
  */
 export class LabelledOccurence {

package/model/embed/AdministrationQuantity.d.mts

@@ -1,8 +1,7 @@
 import { CodeStub } from '../base/CodeStub.mjs';
 /**
  *
- *  Represents a quantity for medication administration, including the numeric amount and the unit of
- *  administration.
+ *  Represents a quantity for medication administration, including the numeric amount and the unit of administration.
  *  /
  */
 export declare class AdministrationQuantity {

package/model/embed/AdministrationQuantity.mjs

@@ -3,8 +3,7 @@ import { expectNumber, expectObject, expectString, extractEntry } from '../../in
 import { CodeStub } from '../base/CodeStub.mjs';
 /**
  *
- *  Represents a quantity for medication administration, including the numeric amount and the unit of
- *  administration.
+ *  Represents a quantity for medication administration, including the numeric amount and the unit of administration.
  *  /
  */
 export class AdministrationQuantity {

package/model/embed/AgendaSlottingAlgorithm.d.mts

@@ -3,8 +3,7 @@ export declare namespace AgendaSlottingAlgorithm {
     /**
      *
      *
-     *   The appointments can be taken at fixed intervals of [intervalMinutes] starting from the
-     *  beginning of the
+     *   The appointments can be taken at fixed intervals of [intervalMinutes] starting from the beginning of the
      *   scheduled working hours for the available timetable item.
      *   # Example
      *   - Time table item scheduled 09:30-12:00, 12:45-14:00

package/model/embed/AgendaSlottingAlgorithm.mjs

@@ -5,8 +5,7 @@ export var AgendaSlottingAlgorithm;
     /**
      *
      *
-     *   The appointments can be taken at fixed intervals of [intervalMinutes] starting from the
-     *  beginning of the
+     *   The appointments can be taken at fixed intervals of [intervalMinutes] starting from the beginning of the
      *   scheduled working hours for the available timetable item.
      *   # Example
      *   - Time table item scheduled 09:30-12:00, 12:45-14:00