@digitalservicebund/a2j-xjustiz-bridge 0.7.1 → 0.8.0

package/dist/nachricht/zahlungsklage.d.ts

@@ -22,6 +22,7 @@ import { StandardSchemaV1 } from "@standard-schema/spec";
 type InferCodeliste<Liste extends Codeliste<Codelisteneintraege>> = Liste[keyof Liste];
 type Codelisteneintraege = Record<string, string>;
 type Codeliste<Eintraege extends Codelisteneintraege> = { readonly [Name in keyof Eintraege]: Eintraege[Name] extends (infer Code) ? Codelisteneintrag<Name & string, Code & string> : never; };
+type IsCodeliste<MaybeCodeliste> = [MaybeCodeliste] extends [Codelisteneintrag<string, string>] ? [keyof MaybeCodeliste] extends [keyof Codelisteneintrag<string, string>] ? true : false : false;
 /**
  * Prettifies the display of Codelisteinträge, conserving the name to improve
  * comprehensibility.
@@ -2655,20 +2656,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 +2718,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 +2785,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 +2853,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;
@@ -3101,9 +3115,15 @@ interface UuidGenerator<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 +3159,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 +3273,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
 /**
@@ -3544,7 +3573,7 @@ type ExcessPropertiesError<ExcessProperties> = TypeError & "Found properties in
   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>;
+type FindExcessProperties<Nachricht, MessageProfile> = IsCodeliste<MessageProfile> extends true ? [Nachricht] extends [object] ? Exclude<keyof Nachricht, keyof MessageProfile> : StructuralIncompatibilityIssues : 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
@@ -3703,6 +3732,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 +3843,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.8.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
@@ -3287,12 +3341,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.8.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"
   }
 }