@digitalservicebund/a2j-xjustiz-bridge 0.7.1 → 0.9.0

package/dist/nachricht/zahlungsklage.d.ts

@@ -2403,33 +2403,6 @@ type ConsumeCharactersFrom<Input extends string, SetOfCharactersToConsume extend
  * Typically used to ensure the true identity of a base type.
  */
 type Invariant<Basis> = (basis: Basis) => Basis;
-type IsTuple<MaybeTuple> = MaybeTuple extends readonly unknown[] ? number extends MaybeTuple["length"] ? false : true : false;
-type NTuple<Item, Length extends number, NMinusOneTuple extends readonly Item[] = []> = NMinusOneTuple["length"] extends Length ? NMinusOneTuple : NTuple<Item, Length, [...NMinusOneTuple, Item]>;
-/**
- * Increment a given literal number type by one.
- * Intended to by used without unions. In case of a union, it will increment the
- * smallest literal number type in the union
- *
- * @example
- * ```typescript
- * Increment<1> // 2
- * Increment<99> // 100
- * Increment<99, 5, 27> // 6
- * Increment<number> // 1
- * ```
- */
-type Increment<Operand extends number> = [...NTuple<unknown, Operand>, unknown]["length"] extends (infer Incremented extends number) ? Incremented : never;
-type IsEqualTo<Left, Right> = (<Probe>() => Probe extends Left ? 1 : 2) extends (<Probe>() => Probe extends Right ? 1 : 2) ? true : false;
-/**
- * Just the clean numerical indices of the tuple entries. Exclude symbols for
- * iterator etc.
- *
- * @example
- * ```typescript
- * IndicesOfTuple<["a", "b", "c"]> // 1 | 2 | 3
- * ```
- */
-type IndicesOfTuple<Tuple extends readonly unknown[]> = Extract<keyof Tuple, `${number}`> extends `${infer Indices extends number}` ? Indices : never;
 //#endregion
 //#region src/xjustiz-schemata/shared-kernel/refined-types.d.ts
 /**
@@ -2655,20 +2628,21 @@ declare const datatypeA: RefinedTypeFactory<string, DatatypeA, <Value extends st
 }>;
 /**
  * Adapted version of the default {@link Array.prototype.join} operation that
- * maintains the invariants of {@link DatatypeA}.
- *
+ * maintains the invariants of {@link DatatypeA}. Any `undefined` entry in
+ * `segments` is filtered automatically.
  * @example
  * ```typescript
  * const fullName = join(
  *   datatypeA(" ").value,
  *   datatypeA("Frau").value,
  *   datatypeA("Erika").value,
+ *   undefined,
  *   datatypeA("Musterfrau").value,
  * );
  * // "Frau Erika Musterfrau" - still DatatypeA no plain string
  * ```
  */
-declare function join(separator: DatatypeA, ...segments: readonly DatatypeA[]): DatatypeA;
+declare function join(separator: DatatypeA, ...segments: readonly (DatatypeA | undefined)[]): DatatypeA;
 type DatatypeACharacterIncomplete = LateinischeBuchstabenIncomplete | NichtBuchstabenN1;
 type GuaranteedInvalidCharacter = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "#" | "$" | "%" | "&" | "*" | "+" | "/" | "<" | "=" | ">" | "@" | "\\" | "^" | "_" | "|" | "!" | '"' | "(" | ")" | ":" | ";" | "?" | "[" | "]" | "{" | "}";
 //#endregion
@@ -2716,20 +2690,24 @@ declare const datatypeB: RefinedTypeFactory<string, DatatypeB, <Value extends st
 }>;
 /**
  * Adapted version of the default {@link Array.prototype.join} operation that
- * maintains the invariants of {@link DatatypeB}.
+ * maintains the invariants of {@link DatatypeB}. Also supports passing
+ * and mixing {@link DatatypeA} values, as any {@link DatentypA} is also a valid
+ * {@link DatatypeB}. Any `undefined` entry in `segments` is filtered
+ * automatically.
  *
  * @example
  * ```typescript
  * const fullAddress = join(
- *   datatypeB(" ").value,
+ *   datatypeA(" ").value,
  *   datatypeB("Musterstraße").value,
  *   datatypeB("1A").value,
+ *   undefined,
  *   datatypeB("Musterstadt").value,
  * );
  * // "Musterstraße 1A Musterstadt" - still DatatypeB no plain string
  * ```
  */
-declare function join$1(separator: DatatypeB, ...segments: readonly DatatypeB[]): DatatypeB;
+declare function join$1(separator: DatatypeA | DatatypeB, ...segments: readonly (DatatypeA | DatatypeB | undefined)[]): DatatypeB;
 type DatatypeBCharacterIncomplete = LateinischeBuchstabenIncomplete | NichtBuchstabenN1 | NichtBuchstabenN2;
 //#endregion
 //#region src/xjustiz-schemata/din-91379/datatypeC.d.ts
@@ -2779,20 +2757,24 @@ declare const datatypeC: RefinedTypeFactory<string, DatatypeC, <Value extends st
 }>;
 /**
  * Adapted version of the default {@link Array.prototype.join} operation that
- * maintains the invariants of {@link DatatypeC}.
+ * maintains the invariants of {@link DatatypeC}. Also supports passing
+ * and mixing {@link DatatypeA} and {@link DatatypeB} values, as any of them is
+ * also a valid {@link DatatypeC}. Any `undefined` entry in `segments` is
+ * filtered automatically.
  *
  * @example
  * ```typescript
- * const fullName = join(
- *   datatypeC(" ").value,
+ * const output = join(
+ *   datatypeA(" ").value,
  *   datatypeC("Lorem").value,
- *   datatypeC("ipsum").value,
+ *   datatypeB("ipsum").value,
+ *   undefined,
  *   datatypeC("dolor").value,
  * );
  * // "Lorem ipsum dolor" - still DatatypeC no plain string
  * ```
  */
-declare function join$2(separator: DatatypeC, ...segments: readonly DatatypeC[]): DatatypeC;
+declare function join$2(separator: DatatypeA | DatatypeB | DatatypeC, ...segments: readonly (DatatypeA | DatatypeB | DatatypeC | undefined)[]): DatatypeC;
 //#endregion
 //#region src/xjustiz-schemata/din-91379/datatypeD.d.ts
 declare const TAG$9: unique symbol;
@@ -2843,20 +2825,24 @@ declare const datatypeD: RefinedTypeFactory<string, DatatypeD, <Value extends st
 }>;
 /**
  * Adapted version of the default {@link Array.prototype.join} operation that
- * maintains the invariants of {@link DatatypeD}.
+ * maintains the invariants of {@link DatatypeD}. Also supports passing
+ * and mixing {@link DatatypeA} and {@link DatatypeB} values, as any of them is
+ * also a valid {@link DatatypeD}. Any `undefined` entry in `segments` is
+ * filtered automatically.
  *
  * @example
  * ```typescript
- * const fullName = join(
- *   datatypeD(" ").value,
+ * const output = join(
+ *   datatypeA(" ").value,
  *   datatypeD("Lorem").value,
- *   datatypeD("ipsum").value,
+ *   datatypeB("ipsum").value,
+ *   undefined,
  *   datatypeD("dolor").value,
  * );
  * // "Lorem ipsum dolor" - still DatatypeD no plain string
  * ```
  */
-declare function join$3(separator: DatatypeD, ...segments: readonly DatatypeD[]): DatatypeD;
+declare function join$3(separator: DatatypeA | DatatypeB | DatatypeD, ...segments: readonly (DatatypeA | DatatypeB | DatatypeD | undefined)[]): DatatypeD;
 //#endregion
 //#region src/xjustiz-schemata/xml-schema-definition/decimal.d.ts
 declare const TAG$8: unique symbol;
@@ -2898,9 +2884,6 @@ interface DistinctiveMarker<Value, Ordinal extends number> {
   readonly [DISTINCTIVE_MARKER]: readonly [Value, Ordinal];
 }
 declare const DISTINCTIVE_MARKER: unique symbol;
-type GetDistinctValueFrom<MaybeDistinctivelyMarked> = MaybeDistinctivelyMarked extends {
-  readonly [DISTINCTIVE_MARKER]: readonly [infer Value, infer Ordinal];
-} ? [Value, Ordinal] : MaybeDistinctivelyMarked;
 //#endregion
 //#region src/xjustiz-schemata/shared-kernel/identifiers/occurrences.d.ts
 interface IdentifierDeclaration {
@@ -2917,39 +2900,6 @@ interface Reference<Identifier extends IdentifierDeclaration> {
   readonly [IDENTIFIER_REFERENCE_MARKER]: Identifier;
 }
 declare const IDENTIFIER_REFERENCE_MARKER: unique symbol;
-type FindAllIdentifierDeclarations<DocumentPart> = DocumentPart extends IdentifierDeclaration ? DocumentPart : DocumentPart extends Reference<IdentifierDeclaration> ? never : DocumentPart extends readonly (infer Entry)[] ? FindAllIdentifierDeclarations<Entry> : DocumentPart extends object ? FindAllIdentifierDeclarations<DocumentPart[keyof DocumentPart]> : never;
-type FindAllIdentifierReferences<DocumentPart> = DocumentPart extends Reference<IdentifierDeclaration> ? ExtractIdentifierDeclarationFrom<DocumentPart> : DocumentPart extends readonly (infer Entry)[] ? FindAllIdentifierReferences<Entry> : DocumentPart extends object ? FindAllIdentifierReferences<DocumentPart[keyof DocumentPart]> : never;
-type ExtractIdentifierDeclarationFrom<SomeReference extends Reference<IdentifierDeclaration>> = SomeReference extends {
-  readonly [IDENTIFIER_REFERENCE_MARKER]: infer Declaration;
-} ? Declaration : never;
-//#endregion
-//#region src/xjustiz-schemata/shared-kernel/identifiers/referential-integrity.d.ts
-type VerifyReferentialIntegrity<Document> = FindMissingIdentifierDeclarations<Document> extends (infer MissingIdentifierDeclarations) ? IsEmpty$2<MissingIdentifierDeclarations> extends true ? AllGood$2 : DanglingReferencesError<MissingIdentifierDeclarations> : Unreachable$2;
-type FindMissingIdentifierDeclarations<Document> = Exclude<FindAllIdentifierReferences<Document>, FindAllIdentifierDeclarations<Document>>;
-type DanglingReferencesError<MissingIdentifierDeclarations> = TypeError & "Found dangling references. Add all missing elements that are referenced." & {
-  readonly missingIdentifierReferences: MissingIdentifierDeclarations;
-};
-type IsEmpty$2<MaybeEmpty> = [MaybeEmpty] extends [never] ? true : false;
-type AllGood$2 = never;
-type Unreachable$2 = never;
-//#endregion
-//#region src/xjustiz-schemata/shared-kernel/identifiers/uniqueness.d.ts
-type VerifyUniquenessOfIdentifierDeclarations<Document> = FindUncheckableCollectionsWithIdentifiers<Document> extends (infer UncheckableCollectionsWithIdentifiers) ? IsEmpty$1<UncheckableCollectionsWithIdentifiers> extends false ? UncheckableCollectionsWithIdentifiersError<UncheckableCollectionsWithIdentifiers> : FindDuplicateIdentifierDeclarations<Document> extends (infer DuplicateIdentifierDeclarations) ? IsEmpty$1<DuplicateIdentifierDeclarations> extends false ? DuplicateIdentifierDeclarationsError<DuplicateIdentifierDeclarations> : AllGood$1 : Unreachable$1 : Unreachable$1;
-type FindUncheckableCollectionsWithIdentifiers<DocumentPart> = DocumentPart extends readonly (infer Entry)[] ? IsTuple<DocumentPart> extends true ? FindUncheckableCollectionsWithIdentifiers<Entry> : IncludesIdentifierDeclarations<Entry> extends true ? Entry : AllGood$1 : DocumentPart extends object ? FindUncheckableCollectionsWithIdentifiers<DocumentPart[keyof DocumentPart]> : AllGood$1;
-type IncludesIdentifierDeclarations<DocumentPart> = IsEmpty$1<FindAllIdentifierDeclarations<DocumentPart>> extends true ? false : true;
-type UncheckableCollectionsWithIdentifiersError<UncheckableCollectionsWithIdentifiers> = TypeError & "Found collection including identifiers that can't be verified for uniqueness. Try to use the `satisfies` operator." & {
-  readonly uncheckableCollectionsWithIdentifiers: UncheckableCollectionsWithIdentifiers;
-};
-type FindDuplicateIdentifierDeclarations<DocumentPart> = DocumentPart extends readonly unknown[] ? FindDuplicateIdentifierDeclarationsAmongSiblings<DocumentPart, IndicesOfTuple<DocumentPart>> : DocumentPart extends object ? FindDuplicateIdentifierDeclarationsAmongSiblings<DocumentPart, keyof DocumentPart> : NoDuplicates;
-type FindDuplicateIdentifierDeclarationsAmongSiblings<DocumentPart, Keys extends keyof DocumentPart> = { [Key in Keys]: FindDuplicateIdentifierDeclarations<DocumentPart[Key]> | (Exclude<Keys, Key> extends (infer SiblingKeys extends keyof DocumentPart) ? IsEmpty$1<SiblingKeys> extends true ? NoDuplicates : FindDuplicateIdentifierDeclarationsBetweenGroups<FindAllIdentifierDeclarations<DocumentPart[Key]>, FindAllIdentifierDeclarations<DocumentPart[SiblingKeys]>> : Unreachable$1); }[Keys];
-type FindDuplicateIdentifierDeclarationsBetweenGroups<Left, Right> = Left extends unknown ? Right extends unknown ? IsEqualTo<GetDistinctValueFrom<Left>, GetDistinctValueFrom<Right>> extends true ? Left : NoDuplicates : Unreachable$1 : Unreachable$1;
-type DuplicateIdentifierDeclarationsError<DuplicateIdentifierDeclarations> = TypeError & "Found duplicate identifier declarations. Remove duplicate element or generate separate identifier." & {
-  readonly duplicateIdentifierDeclarations: DuplicateIdentifierDeclarations;
-};
-type IsEmpty$1<MaybeEmpty> = [MaybeEmpty] extends [never] ? true : false;
-type AllGood$1 = never;
-type NoDuplicates = never;
-type Unreachable$1 = never;
 //#endregion
 //#region src/xjustiz-schemata/shared-kernel/scoping.d.ts
 /**
@@ -3000,7 +2950,6 @@ type ScopeGuard<Scope> = Invariant<Scope>;
 //#endregion
 //#region src/xjustiz-schemata/shared-kernel/identifiers/index.d.ts
 interface WithIdentifierCapabilities<Value, Scope, Ordinal extends number> extends IdentifierDeclaration, DistinctiveMarker<Value, Ordinal>, WithScope<Scope> {}
-type VerifyIdentityConstraints<Document> = VerifyUniquenessOfIdentifierDeclarations<Document> | VerifyReferentialIntegrity<Document>;
 //#endregion
 //#region src/xjustiz-schemata/grunddatensatz/rollennummer.d.ts
 /**
@@ -3055,9 +3004,14 @@ declare const ZUGEHOERIGE_ROLLENBEZEICHNUNG: unique symbol;
  * ```
  */
 declare function createRollennummerGenerator<NachrichtenScope>(scope: ScopeToken<NachrichtenScope>): RollennummerGenerator<NachrichtenScope>;
+/**
+ * **ATTENTION:**
+ * Incrementing ordinals for generated identifiers are currently turned off,
+ * because of technical limitations to enable dynamic input lists.
+ */
 interface RollennummerGenerator<NachrichtenScope> {
-  first: <ZugehoerigeRollenbezeichnung extends Rollenbezeichnung>(zugehoerigeRollenbezeichnung: ZugehoerigeRollenbezeichnung) => Rollennummer<NachrichtenScope, ZugehoerigeRollenbezeichnung, 0>;
-  next: <ZugehoerigeRollenbezeichnung extends Rollenbezeichnung, Ordinal extends number>(previous: Rollennummer<NachrichtenScope, Rollenbezeichnung, Ordinal>, zugehoerigeRollenbezeichnung: ZugehoerigeRollenbezeichnung) => Rollennummer<NachrichtenScope, ZugehoerigeRollenbezeichnung, Increment<Ordinal>>;
+  first: <ZugehoerigeRollenbezeichnung extends Rollenbezeichnung>(zugehoerigeRollenbezeichnung: ZugehoerigeRollenbezeichnung) => Rollennummer<NachrichtenScope, ZugehoerigeRollenbezeichnung>;
+  next: <ZugehoerigeRollenbezeichnung extends Rollenbezeichnung, Ordinal extends number>(previous: Rollennummer<NachrichtenScope, Rollenbezeichnung, Ordinal>, zugehoerigeRollenbezeichnung: ZugehoerigeRollenbezeichnung) => Rollennummer<NachrichtenScope, ZugehoerigeRollenbezeichnung>;
 }
 //#endregion
 //#region src/xjustiz-schemata/grunddatensatz/uuid.d.ts
@@ -3095,15 +3049,26 @@ declare const TAG$5: unique symbol;
  * ```
  */
 declare function createUuidGenerator<NachrichtenScope>(scope: ScopeToken<NachrichtenScope>): UuidGenerator<NachrichtenScope>;
+/**
+ * **ATTENTION:**
+ * Incrementing ordinals for generated identifiers are currently turned off,
+ * because of technical limitations to enable dynamic input lists.
+ */
 interface UuidGenerator<NachrichtenScope> {
-  first: () => UUID<NachrichtenScope, 0>;
-  next: <Ordinal extends number>(previous: UUID<NachrichtenScope, Ordinal>) => UUID<NachrichtenScope, Increment<Ordinal>>;
+  first: () => UUID<NachrichtenScope>;
+  next: <Ordinal extends number>(previous: UUID<NachrichtenScope, Ordinal>) => UUID<NachrichtenScope>;
 }
 //#endregion
 //#region src/xjustiz-schemata/grunddatensatz/composites.d.ts
+/**
+ * The Herstellerinformationen are fixed agreed on with the Bundesministerium
+ * der Justiz und für Verbraucherschutz. The `version` is expected to be the one
+ * of the XJustiz-Bridge. It can be constructed ergonomically with the
+ * {@link herstellerinformation} constructor function.
+ */
 interface Herstellerinformation {
-  nameDesProdukts: DatatypeD;
-  herstellerDesProdukts: DatatypeD;
+  nameDesProdukts: "Justizportal XJustiz Services";
+  herstellerDesProdukts: "Bundesministerium der Justiz und für Verbraucherschutz, ausgeführt durch DigitalService GmbH des Bundes";
   version: DatatypeC;
 }
 interface NatuerlichePerson {
@@ -3139,6 +3104,10 @@ interface Anschrift {
   postleitzahl?: DatatypeC;
   ort?: DatatypeB;
 }
+/**
+ * Can be constructed ergonomically with the {@link email} and {@link telefon}
+ * constructor functions.
+ */
 interface Kommunikation {
   telekommunikationsart: Telekommunikationsart;
   verbindung: DatatypeC;
@@ -3249,20 +3218,25 @@ declare const datatypeE: RefinedTypeFactory<string, DatatypeE, <Value extends st
 }>;
 /**
  * Adapted version of the default {@link Array.prototype.join} operation that
- * maintains the invariants of {@link DatatypeE}.
+ * maintains the invariants of {@link DatatypeE}. Also supports passing
+ * and mixing {@link DatatypeA}, {@link DatatypeB}, {@link DatatypeC} and
+ * {@link DatatypeD} values, as any of them is also a valid {@link DatatypeE}.
+ * Any `undefined` entry in `segments` is filtered automatically.
  *
  * @example
  * ```typescript
- * const fullName = join(
- *   datatypeE(" ").value,
- *   datatypeE("Lorem").value,
- *   datatypeE("ipsum").value,
- *   datatypeE("dolor").value,
+ * const output = join(
+ *   datatypeA(" ").value,
+ *   datatypeB("Lorem").value,
+ *   datatypeC("ipsum").value,
+ *   datatypeD("dolor").value,
+ *   undefined,
+ *   datatypeE("sit").value,
  * );
- * // "Lorem ipsum dolor" - still DatatypeE no plain string
+ * // "Lorem ipsum dolor sit" - still DatatypeE no plain string
  * ```
  */
-declare function join$4(separator: DatatypeE, ...segments: readonly DatatypeE[]): DatatypeE;
+declare function join$4(separator: DatatypeA | DatatypeB | DatatypeC | DatatypeD | DatatypeE, ...segments: readonly (DatatypeA | DatatypeB | DatatypeC | DatatypeD | DatatypeE | undefined)[]): DatatypeE;
 //#endregion
 //#region src/xjustiz-schemata/klaver/fortlaufende-nummer.d.ts
 /**
@@ -3309,9 +3283,14 @@ type ArtVonBezugselement = "Anspruch" | "Zinsanspruch";
  * ```
  */
 declare function createFortlaufendeNummerGenerator<NachrichtenScope>(scope: ScopeToken<NachrichtenScope>): FortlaufendeNummerGenerator<NachrichtenScope>;
+/**
+ * **ATTENTION:**
+ * Incrementing ordinals for generated identifiers are currently turned off,
+ * because of technical limitations to enable dynamic input lists.
+ */
 interface FortlaufendeNummerGenerator<NachrichtenScope> {
-  first: <Bezugselement extends ArtVonBezugselement>(bezugselement: Bezugselement) => FortlaufendeNummer<NachrichtenScope, Bezugselement, 0>;
-  next: <Bezugselement extends ArtVonBezugselement, Ordinal extends number>(previous: FortlaufendeNummer<NachrichtenScope, ArtVonBezugselement, Ordinal>, bezugselement: Bezugselement) => FortlaufendeNummer<NachrichtenScope, Bezugselement, Increment<Ordinal>>;
+  first: <Bezugselement extends ArtVonBezugselement>(bezugselement: Bezugselement) => FortlaufendeNummer<NachrichtenScope, Bezugselement>;
+  next: <Bezugselement extends ArtVonBezugselement, Ordinal extends number>(previous: FortlaufendeNummer<NachrichtenScope, ArtVonBezugselement, Ordinal>, bezugselement: Bezugselement) => FortlaufendeNummer<NachrichtenScope, Bezugselement>;
 }
 //#endregion
 //#region src/xjustiz-schemata/klaver/composites.d.ts
@@ -3535,59 +3514,18 @@ type VerifiedNachricht<MessageProfile> = MessageProfile & {
 };
 declare const TAG: unique symbol;
 /**
+ * **!!! WARNING !!!**
+ * Verification of constraints on a type-level is currently turned off due to
+ * technical limitations on dynamic input lists. You **MUST** take great care to
+ * not use the same identifier multiple times (uniqueness constraint) and include
+ * any referenced identifier declaration in the final message (referential
+ * integrity constraint). Until further updates, any violation passes silently.
+ *
  * Type-level verification of multiple constraints on `Nachricht`, based on the
  * related `MessageProfile`. The resolved type can either be a successfully
  * {@link VerifiedNachricht} or all the detected errors.
  */
-type VerifiedNachrichtOrErrors<Nachricht, MessageProfile> = VerifyIdentityConstraints<Nachricht> | VerifyNoExcessProperties<Nachricht, MessageProfile> extends (infer Errors) ? [Errors] extends [never] ? VerifiedNachricht<Nachricht> : Errors : never;
-type ExcessPropertiesError<ExcessProperties> = TypeError & "Found properties in Nachricht not allowed by the message profile. Remove excess properties." & {
-  readonly excessProperties: ExcessProperties;
-};
-type VerifyNoExcessProperties<Nachricht, MessageProfile> = FindExcessProperties<Nachricht, MessageProfile> extends (infer ExcessProperties) ? IsEmpty<ExcessProperties> extends false ? ExcessPropertiesError<ExcessProperties> : AllGood : Unreachable;
-type FindExcessProperties<Nachricht, MessageProfile> = HasMatchingVariantOfMessageProfileWithoutExcessProperties<Nachricht, MessageProfile> extends true ? AllGood : Exclude<FindExcessPropertiesAgainst<Nachricht, MessageProfile>, StructuralIncompatibilityIssues>;
-/**
- * A `MessageProfile` can define type unions on different levels in the
- * document tree structure. Unions of objects with different key sets are
- * especially tricky in the context of finding excess properties.
- *
- * This predicate evaluates if there is any variant of the `MessageProfile`,
- * that cleanly matches the `Nachricht` without excess properties. Because
- * {@link FindMatchingVariantOfMessageProfileWithoutExcessProperties} must
- * distribute over the union of variants, this predicate type interprets the
- * result of it — a union of by itself.
- *
- * Because of dealing with unions, there is no way to implement it so excess
- * properties are collected, while trying to find a clean variant. In case this
- * predicate evaluates to `false`, the actual excess properties must be found
- * separate.
- */
-type HasMatchingVariantOfMessageProfileWithoutExcessProperties<Nachricht, MessageProfile> = [FindMatchingVariantOfMessageProfileWithoutExcessProperties<Nachricht, MessageProfile>] extends [never] ? false : true;
-/**
- * This type distributes over the variants of the `MessageProfile`. In case the
- * `MessageProfile` is not a union, there is always only one variant. If the
- * `Nachricht` matches one of the variants, meaning it has no excess properties
- * in comparison, this variant is returned as clean match.
- */
-type FindMatchingVariantOfMessageProfileWithoutExcessProperties<Nachricht, MessageProfile> = MessageProfile extends (infer VariantOfMessageProfile) ? FindExcessPropertiesAgainst<Nachricht, VariantOfMessageProfile> extends (infer ExcessProperties) ? IsEmpty<ExcessProperties> extends true ? VariantOfMessageProfile : never : Unreachable : Unreachable;
-type FindExcessPropertiesAgainst<Nachricht, MessageProfile> = Nachricht extends readonly unknown[] ? MessageProfile extends readonly unknown[] ? IsTuple<Nachricht> extends true ? IsTuple<MessageProfile> extends true ? FindExcessPropertiesBetweenTuples<Nachricht, MessageProfile> : FindExcessPropertiesBetweenTupleAndArray<Nachricht, MessageProfile> : FindExcessPropertiesBetweenArrays<Nachricht, MessageProfile> : StructuralIncompatibilityIssues : Nachricht extends object ? MessageProfile extends object ? FindExcessPropertiesBetweenObjects<Nachricht, MessageProfile> : StructuralIncompatibilityIssues : AllGood;
-type FindExcessPropertiesBetweenTuples<Nachricht extends readonly unknown[], MessageProfile extends readonly unknown[]> = { [Index in IndicesOfTuple<Nachricht>]: Index extends IndicesOfTuple<MessageProfile> ? FindExcessProperties<Nachricht[Index], MessageProfile[Index]> : Index; }[IndicesOfTuple<Nachricht>];
-type FindExcessPropertiesBetweenTupleAndArray<Nachricht extends readonly unknown[], MessageProfile extends readonly unknown[]> = { [Index in IndicesOfTuple<Nachricht>]: FindExcessProperties<Nachricht[Index], MessageProfile[number]>; }[IndicesOfTuple<Nachricht>];
-type FindExcessPropertiesBetweenArrays<Nachricht extends readonly unknown[], MessageProfile extends readonly unknown[]> = FindExcessProperties<Nachricht[number], MessageProfile[number]>;
-type FindExcessPropertiesBetweenObjects<Nachricht extends object, MessageProfile extends object> = Exclude<keyof Nachricht, keyof MessageProfile> | FindExcessPropertiesInSharedKeys<Nachricht, MessageProfile>;
-type FindExcessPropertiesInSharedKeys<Nachricht extends object, MessageProfile extends object> = { [Key in keyof Nachricht & keyof MessageProfile]: FindExcessProperties<Nachricht[Key], MessageProfile[Key]>; }[keyof Nachricht & keyof MessageProfile];
-type IsEmpty<MaybeEmpty> = [MaybeEmpty] extends [never] ? true : false;
-type AllGood = never;
-type Unreachable = never;
-/**
- * Nachricht and MessageProfile differ in a way they can't be compared with each
- * other to find excess properties. This is a separate and deeper issue to excess
- * properties. It is not a concern of the verification for no excess properties.
- * However, it must be distinctive in the type-level computation with a plain
- * `never` case, which in some cases indicates a positive match. Without, a
- * structural incompatible Nachricht would be reported as correct.
- */
-type StructuralIncompatibilityIssues = typeof StructuralIncompatibilityIssues;
-declare const StructuralIncompatibilityIssues: unique symbol;
+type VerifiedNachrichtOrErrors<Nachricht, _MessageProfile> = VerifiedNachricht<Nachricht>;
 //#endregion
 //#region src/generate-xml-document.d.ts
 type XjustizToolsConnectionParameter = {
@@ -3613,6 +3551,13 @@ type XjustizMessageXmlResult = {
  */
 declare function zahlungsklage(compose: <NachrichtenScope>(scope: ScopeToken<NachrichtenScope>) => VerifiedNachricht<Zahlungsklage<NachrichtenScope>>, xjustizToolsConnectionParameter: XjustizToolsConnectionParameter): Promise<XjustizMessageXmlResult>;
 /**
+ * **!!! WARNING !!!**
+ * Verification of constraints on a type-level is currently turned off due to
+ * technical limitations on dynamic input lists. You **MUST** take great care to
+ * not use the same identifier multiple times (uniqueness constraint) and include
+ * any referenced identifier declaration in the final message (referential
+ * integrity constraint). Until further updates, any violation passes silently.
+ *
  * Used as last step of composing a `Zahlungsklage` with the {@link zahlungsklage}
  * orchestrator to output a valid {@link VerifiedNachricht}. It will apply
  * multiple type-level computations to verify constraints like for identities or
@@ -3703,6 +3648,43 @@ declare function antragAufVersaeumnisurteil(): AntragAufVersaeumnisurteil;
  */
 declare function weitererAntrag(antragInTextform: DatatypeE): WeitererAntrag;
 //#endregion
+//#region src/nachricht/zahlungsklage/ergonomics/nachrichtenkopf.d.ts
+/**
+ * Constructs a {@link NachrichtenkopfFuerZahlungsklage} with the `klaeger` as
+ * Absender and `gericht` as Empfänger.
+ *
+ * The `erstellungszeitpunkt` will be current date-time at the call.
+ *
+ * The `klaeger` will be formatted based on their Geschlecht, Titel, Vorname and
+ * Nachname. For example: `"Frau Dr. Erika Musterfrau"`. A Titel which can't be
+ * parsed from {@link DatatypeC} to {@link DatatypeD} will be discarded. Any
+ * Geschlecht but männlich or weiblich will also be discarded for the Anrede.
+ */
+declare function nachrichtenkopf<NachrichtenScope, const EigeneNachrichtenID extends UUID<NachrichtenScope>, const Gericht extends Gerichte>(_scope: ScopeToken<NachrichtenScope>, eigeneNachrichtenID: EigeneNachrichtenID, klaeger: Klaeger<NachrichtenScope> // oxlint-disable-line typescript/prefer-readonly-parameter-types -- false positive
+, gericht: Gericht): {
+  xjustizVersion: "3.6.2";
+  erstellungszeitpunkt: Temporal.Instant;
+  absender: {
+    informationen: {
+      auswahlKommunikationspartner: {
+        sonstige: DatatypeD;
+      };
+    };
+    eigeneNachrichtenID: EigeneNachrichtenID;
+  };
+  empfaenger: {
+    informationen: {
+      auswahlKommunikationspartner: {
+        gericht: Gerichte;
+      };
+    };
+    auswahlAktenzeichen: {
+      aktenzeichenNeu: true;
+    };
+  };
+  herstellerinformation: Herstellerinformation;
+};
+//#endregion
 //#region src/xjustiz-schemata/klaver/ergonomics/beweis.d.ts
 /**
  * Constructs a {@link Beweis} with Zeugen as Beweismittel. The referenced
@@ -3777,8 +3759,27 @@ declare function parteivernehmung<NachrichtenScope, const Nummer extends BeweisN
  * ```
  */
 declare function geldbetrag(zahl: Double): Geldbetrag;
+//#endregion
+//#region src/xjustiz-schemata/grunddatensatz/ergonomics/herstellerinformation.d.ts
+/**
+ * Constructs the static {@link Herstellerinformationen} with the version of the
+ * XJustiz-Bridge in use.
+ */
+declare function herstellerinformation(): Herstellerinformation;
+//#endregion
+//#region src/xjustiz-schemata/grunddatensatz/ergonomics/kommunikation.d.ts
+/**
+ * Constructs a {@link Kommunikation} with {@link Telekommunikationsart.EMail}
+ * as `telekommunikationsart`.
+ */
+declare function email(address: DatatypeC): Kommunikation;
+/**
+ * Constructs a {@link Kommunikation} with {@link Telekommunikationsart.Telefon}
+ * as `telekommunikationsart`.
+ */
+declare function telefon(number: DatatypeC): Kommunikation;
 declare namespace index_d_exports {
-  export { antragAufAnwaltskosten, antragAufVersaeumnisurteil, geldbetrag, parteivernehmung, weitererAntrag, zeuge };
+  export { antragAufAnwaltskosten, antragAufVersaeumnisurteil, email, geldbetrag, herstellerinformation, nachrichtenkopf, parteivernehmung, telefon, weitererAntrag, zeuge };
 }
 //#endregion
 export { type AnspruchFuerZahlungsklage, Anspruchsart, type AntraegeFuerZahlungsklage, type AntragAufAnwaltskosten, type AntragAufVersaeumnisurteil, AntragCodeliste, type AusfuehrungenFuerZahlungsklage, type BegruendetheitFuerZahlungsklage, type BeklagteOrganisation, type BeklagtePerson, type Beklagter, type DatatypeA, type DatatypeB, type DatatypeC, type DatatypeD, type DatatypeE, type Decimal, Gerichte, Geschlecht, type GesetzlicherVertreter, type GrunddatenFuerZahlungsklage, Kanzleiform, type Klaeger, type NachrichtenkopfFuerZahlungsklage, type Prozessbevollmaechtiger, Rollenbezeichnung, type ScopeToken, type SonstigerAntragFuerZahlungsklage, Telekommunikationsart, type VortragZurBegruendetheitFuerZahlungsklage, Waehrung, type WeitererAntrag, type Zahlungsklage, type Zeuge, Zinsmethode, createFortlaufendeNummerGenerator, createRollennummerGenerator, createUuidGenerator, datatypeA, datatypeB, datatypeC, datatypeD, datatypeE, decimal, index_d_exports as ergonomics, join as joinDatatyeA, join$1 as joinDatatyeB, join$2 as joinDatatyeC, join$3 as joinDatatyeD, join$4 as joinDatatyeE, verifyZahlungsklage, zahlungsklage };

package/dist/nachricht/zahlungsklage.js

@@ -2351,6 +2351,35 @@ const Gerichte = defineCodeliste({
 	"Der Generalbundesanwalt beim Bundesgerichtshof Ref. IV 3 AZ. IV 29 H 2/90": "Z7350"
 });
 //#endregion
+//#region src/xjustiz-schemata/grunddatensatz/ergonomics/geldbetrag.ts
+/**
+* Constructs a {@link Geldbetrag} from an amount in Euro.
+*
+* @example
+* ```typescript
+* const betrag = geldbetrag(5_000);
+* ```
+*/
+function geldbetrag(zahl) {
+	return {
+		zahl,
+		auswahlWaehrung: { waehrung: Waehrung.Euro }
+	};
+}
+//#endregion
+//#region src/xjustiz-schemata/grunddatensatz/ergonomics/herstellerinformation.ts
+/**
+* Constructs the static {@link Herstellerinformationen} with the version of the
+* XJustiz-Bridge in use.
+*/
+function herstellerinformation() {
+	return {
+		nameDesProdukts: "Justizportal XJustiz Services",
+		herstellerDesProdukts: "Bundesministerium der Justiz und für Verbraucherschutz, ausgeführt durch DigitalService GmbH des Bundes",
+		version: "\"0.9.0\""
+	};
+}
+//#endregion
 //#region src/xjustiz-schemata/shared-kernel/refined-types.ts
 /**
 * Produce a factory to construct valid instanced for a refined type.
@@ -2555,21 +2584,23 @@ invalidCharacters: (characters) => `Contains characters not allowed by DIN 91379
 const datatypeA = defineRefinedType(isString, parseDatatypeA);
 /**
 * Adapted version of the default {@link Array.prototype.join} operation that
-* maintains the invariants of {@link DatatypeA}.
-*
+* maintains the invariants of {@link DatatypeA}. Any `undefined` entry in
+* `segments` is filtered automatically.
+
 * @example
 * ```typescript
 * const fullName = join(
 *   datatypeA(" ").value,
 *   datatypeA("Frau").value,
 *   datatypeA("Erika").value,
+*   undefined,
 *   datatypeA("Musterfrau").value,
 * );
 * // "Frau Erika Musterfrau" - still DatatypeA no plain string
 * ```
 */
 function join(separator, ...segments) {
-	return segments.join(separator);
+	return segments.filter((segment) => segment !== void 0).join(separator);
 }
 const DATATYPE_A_PATTERN = transformXsdPatternToJavaScriptExpression(String.raw`( |'|[,-\.]|[A-Z]|[`-z]|~|¨|´|·|[À-Ö]|[Ø-ö]|[ø-ž]|[Ƈ-ƈ]|Ə|Ɨ|[Ơ-ơ]|[Ư-ư]|Ʒ|[Ǎ-ǜ]|[Ǟ-ǟ]|[Ǣ-ǰ]|[Ǵ-ǵ]|[Ǹ-ǿ]|[Ȓ-ȓ]|[Ș-ț]|[Ȟ-ȟ]|[ȧ-ȳ]|ə|ɨ|ʒ|[ʹ-ʺ]|[ʾ-ʿ]|ˈ|ˌ|[Ḃ-ḃ]|[Ḇ-ḇ]|[Ḋ-ḑ]|ḗ|[Ḝ-ḫ]|[ḯ-ḷ]|[Ḻ-ḻ]|[Ṁ-ṉ]|[Ṓ-ṛ]|[Ṟ-ṣ]|[Ṫ-ṯ]|[Ẁ-ẇ]|[Ẍ-ẗ]|ẞ|[Ạ-ỹ]|’|‡|A̋|C(̀|̄|̆|̈|̕|̣|̦|̨̆)|D̂|F(̀|̄)|G̀|H(̄|̦|̱)|J(́|̌)|K(̀|̂|̄|̇|̕|̛|̦|͟H|͟h)|L(̂|̥|̥̄|̦)|M(̀|̂|̆|̐)|N(̂|̄|̆|̦)|P(̀|̄|̕|̣)|R(̆|̥|̥̄)|S(̀|̄|̛̄|̱)|T(̀|̄|̈|̕|̛)|U̇|Z(̀|̄|̆|̈|̧)|a̋|c(̀|̄|̆|̈|̕|̣|̦|̨̆)|d̂|f(̀|̄)|g̀|h(̄|̦)|j́|k(̀|̂|̄|̇|̕|̛|̦|͟h)|l(̂|̥|̥̄|̦)|m(̀|̂|̆|̐)|n(̂|̄|̆|̦)|p(̀|̄|̕|̣)|r(̆|̥|̥̄)|s(̀|̄|̛̄|̱)|t(̀|̄|̕|̛)|u̇|z(̀|̄|̆|̈|̧)|Ç̆|Û̄|ç̆|û̄|ÿ́|Č(̕|̣)|č(̕|̣)|ē̍|Ī́|ī́|ō̍|Ž(̦|̧)|ž(̦|̧)|Ḳ̄|ḳ̄|Ṣ̄|ṣ̄|Ṭ̄|ṭ̄|Ạ̈|ạ̈|Ọ̈|ọ̈|Ụ(̄|̈)|ụ(̄|̈))*`);
 //#endregion
@@ -2612,21 +2643,25 @@ invalidCharacters: (characters) => `Contains characters not allowed by DIN 91379
 const datatypeB = defineRefinedType(isString, parseDatatypeB);
 /**
 * Adapted version of the default {@link Array.prototype.join} operation that
-* maintains the invariants of {@link DatatypeB}.
+* maintains the invariants of {@link DatatypeB}. Also supports passing
+* and mixing {@link DatatypeA} values, as any {@link DatentypA} is also a valid
+* {@link DatatypeB}. Any `undefined` entry in `segments` is filtered
+* automatically.
 *
 * @example
 * ```typescript
 * const fullAddress = join(
-*   datatypeB(" ").value,
+*   datatypeA(" ").value,
 *   datatypeB("Musterstraße").value,
 *   datatypeB("1A").value,
+*   undefined,
 *   datatypeB("Musterstadt").value,
 * );
 * // "Musterstraße 1A Musterstadt" - still DatatypeB no plain string
 * ```
 */
 function join$1(separator, ...segments) {
-	return segments.join(separator);
+	return segments.filter((segment) => segment !== void 0).join(separator);
 }
 const DATATYPE_B_PATTERN = transformXsdPatternToJavaScriptExpression(String.raw`([ -~]|[¡-£]|¥|[§-¬]|[®-·]|[¹-»]|[¿-ž]|[Ƈ-ƈ]|Ə|Ɨ|[Ơ-ơ]|[Ư-ư]|Ʒ|[Ǎ-ǜ]|[Ǟ-ǟ]|[Ǣ-ǰ]|[Ǵ-ǵ]|[Ǹ-ǿ]|[Ȓ-ȓ]|[Ș-ț]|[Ȟ-ȟ]|[ȧ-ȳ]|ə|ɨ|ʒ|[ʹ-ʺ]|[ʾ-ʿ]|ˈ|ˌ|[Ḃ-ḃ]|[Ḇ-ḇ]|[Ḋ-ḑ]|ḗ|[Ḝ-ḫ]|[ḯ-ḷ]|[Ḻ-ḻ]|[Ṁ-ṉ]|[Ṓ-ṛ]|[Ṟ-ṣ]|[Ṫ-ṯ]|[Ẁ-ẇ]|[Ẍ-ẗ]|ẞ|[Ạ-ỹ]|’|‡|€|A̋|C(̀|̄|̆|̈|̕|̣|̦|̨̆)|D̂|F(̀|̄)|G̀|H(̄|̦|̱)|J(́|̌)|K(̀|̂|̄|̇|̕|̛|̦|͟H|͟h)|L(̂|̥|̥̄|̦)|M(̀|̂|̆|̐)|N(̂|̄|̆|̦)|P(̀|̄|̕|̣)|R(̆|̥|̥̄)|S(̀|̄|̛̄|̱)|T(̀|̄|̈|̕|̛)|U̇|Z(̀|̄|̆|̈|̧)|a̋|c(̀|̄|̆|̈|̕|̣|̦|̨̆)|d̂|f(̀|̄)|g̀|h(̄|̦)|j́|k(̀|̂|̄|̇|̕|̛|̦|͟h)|l(̂|̥|̥̄|̦)|m(̀|̂|̆|̐)|n(̂|̄|̆|̦)|p(̀|̄|̕|̣)|r(̆|̥|̥̄)|s(̀|̄|̛̄|̱)|t(̀|̄|̕|̛)|u̇|z(̀|̄|̆|̈|̧)|Ç̆|Û̄|ç̆|û̄|ÿ́|Č(̕|̣)|č(̕|̣)|ē̍|Ī́|ī́|ō̍|Ž(̦|̧)|ž(̦|̧)|Ḳ̄|ḳ̄|Ṣ̄|ṣ̄|Ṭ̄|ṭ̄|Ạ̈|ạ̈|Ọ̈|ọ̈|Ụ(̄|̈)|ụ(̄|̈))*`);
 //#endregion
@@ -2669,24 +2704,50 @@ invalidCharacters: (characters) => `Contains characters not allowed by DIN 91379
 const datatypeC = defineRefinedType(isString, parseDatatypeC);
 /**
 * Adapted version of the default {@link Array.prototype.join} operation that
-* maintains the invariants of {@link DatatypeC}.
+* maintains the invariants of {@link DatatypeC}. Also supports passing
+* and mixing {@link DatatypeA} and {@link DatatypeB} values, as any of them is
+* also a valid {@link DatatypeC}. Any `undefined` entry in `segments` is
+* filtered automatically.
 *
 * @example
 * ```typescript
-* const fullName = join(
-*   datatypeC(" ").value,
+* const output = join(
+*   datatypeA(" ").value,
 *   datatypeC("Lorem").value,
-*   datatypeC("ipsum").value,
+*   datatypeB("ipsum").value,
+*   undefined,
 *   datatypeC("dolor").value,
 * );
 * // "Lorem ipsum dolor" - still DatatypeC no plain string
 * ```
 */
 function join$2(separator, ...segments) {
-	return segments.join(separator);
+	return segments.filter((segment) => segment !== void 0).join(separator);
 }
 const DATATYPE_C_PATTERN = transformXsdPatternToJavaScriptExpression(String.raw`([	-
]|
|[ -~]|[ -¬]|[®-ž]|[Ƈ-ƈ]|Ə|Ɨ|[Ơ-ơ]|[Ư-ư]|Ʒ|[Ǎ-ǜ]|[Ǟ-ǟ]|[Ǣ-ǰ]|[Ǵ-ǵ]|[Ǹ-ǿ]|[Ȓ-ȓ]|[Ș-ț]|[Ȟ-ȟ]|[ȧ-ȳ]|ə|ɨ|ʒ|[ʹ-ʺ]|[ʾ-ʿ]|ˈ|ˌ|[Ḃ-ḃ]|[Ḇ-ḇ]|[Ḋ-ḑ]|ḗ|[Ḝ-ḫ]|[ḯ-ḷ]|[Ḻ-ḻ]|[Ṁ-ṉ]|[Ṓ-ṛ]|[Ṟ-ṣ]|[Ṫ-ṯ]|[Ẁ-ẇ]|[Ẍ-ẗ]|ẞ|[Ạ-ỹ]|’|‡|€|A̋|C(̀|̄|̆|̈|̕|̣|̦|̨̆)|D̂|F(̀|̄)|G̀|H(̄|̦|̱)|J(́|̌)|K(̀|̂|̄|̇|̕|̛|̦|͟H|͟h)|L(̂|̥|̥̄|̦)|M(̀|̂|̆|̐)|N(̂|̄|̆|̦)|P(̀|̄|̕|̣)|R(̆|̥|̥̄)|S(̀|̄|̛̄|̱)|T(̀|̄|̈|̕|̛)|U̇|Z(̀|̄|̆|̈|̧)|a̋|c(̀|̄|̆|̈|̕|̣|̦|̨̆)|d̂|f(̀|̄)|g̀|h(̄|̦)|j́|k(̀|̂|̄|̇|̕|̛|̦|͟h)|l(̂|̥|̥̄|̦)|m(̀|̂|̆|̐)|n(̂|̄|̆|̦)|p(̀|̄|̕|̣)|r(̆|̥|̥̄)|s(̀|̄|̛̄|̱)|t(̀|̄|̕|̛)|u̇|z(̀|̄|̆|̈|̧)|Ç̆|Û̄|ç̆|û̄|ÿ́|Č(̕|̣)|č(̕|̣)|ē̍|Ī́|ī́|ō̍|Ž(̦|̧)|ž(̦|̧)|Ḳ̄|ḳ̄|Ṣ̄|ṣ̄|Ṭ̄|ṭ̄|Ạ̈|ạ̈|Ọ̈|ọ̈|Ụ(̄|̈)|ụ(̄|̈))*`);
 //#endregion
+//#region src/xjustiz-schemata/grunddatensatz/ergonomics/kommunikation.ts
+/**
+* Constructs a {@link Kommunikation} with {@link Telekommunikationsart.EMail}
+* as `telekommunikationsart`.
+*/
+function email(address) {
+	return {
+		verbindung: address,
+		telekommunikationsart: Telekommunikationsart.EMail
+	};
+}
+/**
+* Constructs a {@link Kommunikation} with {@link Telekommunikationsart.Telefon}
+* as `telekommunikationsart`.
+*/
+function telefon(number) {
+	return {
+		verbindung: number,
+		telekommunikationsart: Telekommunikationsart.Telefon
+	};
+}
+//#endregion
 //#region src/xjustiz-schemata/din-91379/datatypeD.ts
 function parseDatatypeD(issueMessages = DEFAULT_ISSUE_MESSAGES$3) {
 	return function parse(input) {
@@ -2726,21 +2787,25 @@ invalidCharacters: (characters) => `Contains characters not allowed by DIN 91379
 const datatypeD = defineRefinedType(isString, parseDatatypeD);
 /**
 * Adapted version of the default {@link Array.prototype.join} operation that
-* maintains the invariants of {@link DatatypeD}.
+* maintains the invariants of {@link DatatypeD}. Also supports passing
+* and mixing {@link DatatypeA} and {@link DatatypeB} values, as any of them is
+* also a valid {@link DatatypeD}. Any `undefined` entry in `segments` is
+* filtered automatically.
 *
 * @example
 * ```typescript
-* const fullName = join(
-*   datatypeD(" ").value,
+* const output = join(
+*   datatypeA(" ").value,
 *   datatypeD("Lorem").value,
-*   datatypeD("ipsum").value,
+*   datatypeB("ipsum").value,
+*   undefined,
 *   datatypeD("dolor").value,
 * );
 * // "Lorem ipsum dolor" - still DatatypeD no plain string
 * ```
 */
 function join$3(separator, ...segments) {
-	return segments.join(separator);
+	return segments.filter((segment) => segment !== void 0).join(separator);
 }
 const DATATYPE_D_PATTERN = transformXsdPatternToJavaScriptExpression(String.raw`([ -~]|[¡-¬]|[®-ž]|[Ƈ-ƈ]|Ə|ƒ|Ɨ|[Ơ-ơ]|[Ư-ư]|Ʒ|[Ǎ-ǜ]|[Ǟ-ǟ]|[Ǣ-ǰ]|[Ǵ-ǵ]|[Ǹ-ǿ]|[Ȓ-ȓ]|[Ș-ț]|[Ȟ-ȟ]|[ȧ-ȳ]|ə|ɨ|ʒ|ʰ|ʳ|[ʹ-ʺ]|[ʾ-ʿ]|ˆ|ˈ|ˌ|˜|ˢ|Ά|[Έ-Ί]|Ό|[Ύ-Ρ]|[Σ-ώ]|ᵈ|ᵗ|[Ḃ-ḃ]|[Ḇ-ḇ]|[Ḋ-ḑ]|ḗ|[Ḝ-ḫ]|[ḯ-ḷ]|[Ḻ-ḻ]|[Ṁ-ṉ]|[Ṓ-ṛ]|[Ṟ-ṣ]|[Ṫ-ṯ]|[Ẁ-ẇ]|[Ẍ-ẗ]|ẞ|[Ạ-ỹ]|[‘-‚]|[“-„]|[†-‡]|…|‰|[′-″]|[‹-›]|⁰|[⁴-⁹]|[ⁿ-₉]|€|™|∞|[≤-≥]|A̋|C(̀|̄|̆|̈|̕|̣|̦|̨̆)|D̂|F(̀|̄)|G̀|H(̄|̦|̱)|J(́|̌)|K(̀|̂|̄|̇|̕|̛|̦|͟H|͟h)|L(̂|̥|̥̄|̦)|M(̀|̂|̆|̐)|N(̂|̄|̆|̦)|P(̀|̄|̕|̣)|R(̆|̥|̥̄)|S(̀|̄|̛̄|̱)|T(̀|̄|̈|̕|̛)|U̇|Z(̀|̄|̆|̈|̧)|a̋|c(̀|̄|̆|̈|̕|̣|̦|̨̆)|d̂|f(̀|̄)|g̀|h(̄|̦)|j́|k(̀|̂|̄|̇|̕|̛|̦|͟h)|l(̂|̥|̥̄|̦)|m(̀|̂|̆|̐)|n(̂|̄|̆|̦)|p(̀|̄|̕|̣)|r(̆|̥|̥̄)|s(̀|̄|̛̄|̱)|t(̀|̄|̕|̛)|u̇|z(̀|̄|̆|̈|̧)|Ç̆|Û̄|ç̆|û̄|ÿ́|Č(̕|̣)|č(̕|̣)|ē̍|Ī́|ī́|ō̍|Ž(̦|̧)|ž(̦|̧)|Ḳ̄|ḳ̄|Ṣ̄|ṣ̄|Ṭ̄|ṭ̄|Ạ̈|ạ̈|Ọ̈|ọ̈|Ụ(̄|̈)|ụ(̄|̈))*`);
 //#endregion
@@ -2937,22 +3002,6 @@ function randomUUID() {
 	return globalThis.crypto.randomUUID();
 }
 //#endregion
-//#region src/xjustiz-schemata/grunddatensatz/ergonomics/geldbetrag.ts
-/**
-* Constructs a {@link Geldbetrag} from an amount in Euro.
-*
-* @example
-* ```typescript
-* const betrag = geldbetrag(5_000);
-* ```
-*/
-function geldbetrag(zahl) {
-	return {
-		zahl,
-		auswahlWaehrung: { waehrung: Waehrung.Euro }
-	};
-}
-//#endregion
 //#region src/xjustiz-schemata/din-91379/datatypeE.ts
 function parseDatatypeE(issueMessages = DEFAULT_ISSUE_MESSAGES$1) {
 	return function parse(input) {
@@ -2993,21 +3042,26 @@ invalidCharacters: (characters) => `Contains characters not allowed by DIN 91379
 const datatypeE = defineRefinedType(isString, parseDatatypeE);
 /**
 * Adapted version of the default {@link Array.prototype.join} operation that
-* maintains the invariants of {@link DatatypeE}.
+* maintains the invariants of {@link DatatypeE}. Also supports passing
+* and mixing {@link DatatypeA}, {@link DatatypeB}, {@link DatatypeC} and
+* {@link DatatypeD} values, as any of them is also a valid {@link DatatypeE}.
+* Any `undefined` entry in `segments` is filtered automatically.
 *
 * @example
 * ```typescript
-* const fullName = join(
-*   datatypeE(" ").value,
-*   datatypeE("Lorem").value,
-*   datatypeE("ipsum").value,
-*   datatypeE("dolor").value,
+* const output = join(
+*   datatypeA(" ").value,
+*   datatypeB("Lorem").value,
+*   datatypeC("ipsum").value,
+*   datatypeD("dolor").value,
+*   undefined,
+*   datatypeE("sit").value,
 * );
-* // "Lorem ipsum dolor" - still DatatypeE no plain string
+* // "Lorem ipsum dolor sit" - still DatatypeE no plain string
 * ```
 */
 function join$4(separator, ...segments) {
-	return segments.join(separator);
+	return segments.filter((segment) => segment !== void 0).join(separator);
 }
 const DATATYPE_E_PATTERN = transformXsdPatternToJavaScriptExpression(String.raw`([	-
]|
|[ -~]|[ -¬]|[®-ž]|[Ƈ-ƈ]|Ə|ƒ|Ɨ|[Ơ-ơ]|[Ư-ư]|Ʒ|[Ǎ-ǜ]|[Ǟ-ǟ]|[Ǣ-ǰ]|[Ǵ-ǵ]|[Ǹ-ǿ]|[Ȓ-ȓ]|[Ș-ț]|[Ȟ-ȟ]|[ȧ-ȳ]|ə|ɨ|ʒ|ʰ|ʳ|[ʹ-ʺ]|[ʾ-ʿ]|ˆ|ˈ|ˌ|˜|ˢ|Ά|[Έ-Ί]|Ό|[Ύ-Ρ]|[Σ-ώ]|Ѝ|[А-Ъ]|Ь|[Ю-ъ]|ь|[ю-я]|ѝ|ᵈ|ᵗ|[Ḃ-ḃ]|[Ḇ-ḇ]|[Ḋ-ḑ]|ḗ|[Ḝ-ḫ]|[ḯ-ḷ]|[Ḻ-ḻ]|[Ṁ-ṉ]|[Ṓ-ṛ]|[Ṟ-ṣ]|[Ṫ-ṯ]|[Ẁ-ẇ]|[Ẍ-ẗ]|ẞ|[Ạ-ỹ]|[‘-‚]|[“-„]|[†-‡]|…|‰|[′-″]|[‹-›]|⁰|[⁴-⁹]|[ⁿ-₉]|€|™|∞|[≤-≥]|A̋|C(̀|̄|̆|̈|̕|̣|̦|̨̆)|D̂|F(̀|̄)|G̀|H(̄|̦|̱)|J(́|̌)|K(̀|̂|̄|̇|̕|̛|̦|͟H|͟h)|L(̂|̥|̥̄|̦)|M(̀|̂|̆|̐)|N(̂|̄|̆|̦)|P(̀|̄|̕|̣)|R(̆|̥|̥̄)|S(̀|̄|̛̄|̱)|T(̀|̄|̈|̕|̛)|U̇|Z(̀|̄|̆|̈|̧)|a̋|c(̀|̄|̆|̈|̕|̣|̦|̨̆)|d̂|f(̀|̄)|g̀|h(̄|̦)|j́|k(̀|̂|̄|̇|̕|̛|̦|͟h)|l(̂|̥|̥̄|̦)|m(̀|̂|̆|̐)|n(̂|̄|̆|̦)|p(̀|̄|̕|̣)|r(̆|̥|̥̄)|s(̀|̄|̛̄|̱)|t(̀|̄|̕|̛)|u̇|z(̀|̄|̆|̈|̧)|Ç̆|Û̄|ç̆|û̄|ÿ́|Č(̕|̣)|č(̕|̣)|ē̍|Ī́|ī́|ō̍|Ž(̦|̧)|ž(̦|̧)|Ḳ̄|ḳ̄|Ṣ̄|ṣ̄|Ṭ̄|ṭ̄|Ạ̈|ạ̈|Ọ̈|ọ̈|Ụ(̄|̈)|ụ(̄|̈))*`);
 //#endregion
@@ -3258,6 +3312,13 @@ function zahlungsklage(compose, xjustizToolsConnectionParameter) {
 	});
 }
 /**
+* **!!! WARNING !!!**
+* Verification of constraints on a type-level is currently turned off due to
+* technical limitations on dynamic input lists. You **MUST** take great care to
+* not use the same identifier multiple times (uniqueness constraint) and include
+* any referenced identifier declaration in the final message (referential
+* integrity constraint). Until further updates, any violation passes silently.
+*
 * Used as last step of composing a `Zahlungsklage` with the {@link zahlungsklage}
 * orchestrator to output a valid {@link VerifiedNachricht}. It will apply
 * multiple type-level computations to verify constraints like for identities or
@@ -3287,12 +3348,62 @@ function verifyZahlungsklage(_scope, nachricht) {
 	return nachricht;
 }
 //#endregion
+//#region src/nachricht/zahlungsklage/ergonomics/nachrichtenkopf.ts
+/**
+* Constructs a {@link NachrichtenkopfFuerZahlungsklage} with the `klaeger` as
+* Absender and `gericht` as Empfänger.
+*
+* The `erstellungszeitpunkt` will be current date-time at the call.
+*
+* The `klaeger` will be formatted based on their Geschlecht, Titel, Vorname and
+* Nachname. For example: `"Frau Dr. Erika Musterfrau"`. A Titel which can't be
+* parsed from {@link DatatypeC} to {@link DatatypeD} will be discarded. Any
+* Geschlecht but männlich or weiblich will also be discarded for the Anrede.
+*/
+function nachrichtenkopf(_scope, eigeneNachrichtenID, klaeger, gericht) {
+	return {
+		xjustizVersion: "3.6.2",
+		erstellungszeitpunkt: Temporal.Now.instant(),
+		absender: {
+			informationen: { auswahlKommunikationspartner: { sonstige: formatKlaegerAsAbsender(klaeger.beteiligter.auswahlBeteiligter.natuerlichePerson) } },
+			eigeneNachrichtenID
+		},
+		empfaenger: {
+			informationen: { auswahlKommunikationspartner: { gericht } },
+			auswahlAktenzeichen: { aktenzeichenNeu: true }
+		},
+		herstellerinformation: herstellerinformation()
+	};
+}
+function formatKlaegerAsAbsender(klaeger) {
+	return join$3(datatypeD(" ").value, mapGeschlechtToAndrede(klaeger.geschlecht), tryToParseTitelAsDatatypeD(klaeger.vollerName.titel), klaeger.vollerName.vorname, klaeger.vollerName.nachname);
+}
+function tryToParseTitelAsDatatypeD(titel) {
+	const maybeResult = titel ? datatypeD(titel) : { issues: [] };
+	return maybeResult.issues === void 0 ? maybeResult.value : void 0;
+}
+function mapGeschlechtToAndrede(geschlecht) {
+	switch (geschlecht) {
+		case void 0:
+		case Geschlecht.Unbekannt:
+		case Geschlecht.Divers:
+		case Geschlecht.Saechlich: return;
+		case Geschlecht.Maennlich: return datatypeD("Herr").value;
+		case Geschlecht.Weiblich: return datatypeD("Frau").value;
+		default: return;
+	}
+}
+//#endregion
 //#region src/nachricht/zahlungsklage/ergonomics/index.ts
 var ergonomics_exports = /* @__PURE__ */ __exportAll({
 	antragAufAnwaltskosten: () => antragAufAnwaltskosten,
 	antragAufVersaeumnisurteil: () => antragAufVersaeumnisurteil,
+	email: () => email,
 	geldbetrag: () => geldbetrag,
+	herstellerinformation: () => herstellerinformation,
+	nachrichtenkopf: () => nachrichtenkopf,
 	parteivernehmung: () => parteivernehmung,
+	telefon: () => telefon,
 	weitererAntrag: () => weitererAntrag,
 	zeuge: () => zeuge
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://www.schemastore.org/package.json",
   "name": "@digitalservicebund/a2j-xjustiz-bridge",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "Assisted composition of XJustiz messages that are ensured to be valid.",
   "author": "Team Court Communication (Access to Justice) - DigitalService GmbH des Bundes",
   "license": "MIT",
@@ -28,14 +28,14 @@
   },
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
-    "ky": "^2.0.2",
-    "typescript": "^6.0.3"
+    "ky": "^2.1.0"
   },
   "devDependencies": {
-    "fast-check": "^4.8.0",
-    "publint": "^0.3.21",
+    "fast-check": "^4.9.0",
+    "publint": "^0.3.24",
     "testcontainers": "^12.1.0",
-    "tsdown": "^0.22.0",
-    "vitest": "^4.1.10"
+    "tsdown": "^0.22.14",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11"
   }
 }