@gitcode6/munbyn-pos-sdk 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,2252 @@
+/**
+ * ESC/POS Steuerbyte-Konstanten.
+ * Alle Werte entsprechen direkt dem MUNBYN 80mm Programmer Manual.
+ */
+/** Null */
+declare const NUL = 0;
+/** Horizontal Tab */
+declare const HT = 9;
+/** Line Feed */
+declare const LF = 10;
+/** Form Feed */
+declare const FF = 12;
+/** Carriage Return */
+declare const CR = 13;
+/** Data Link Escape */
+declare const DLE = 16;
+/** Device Control 4 */
+declare const DC4 = 20;
+/** Cancel */
+declare const CAN = 24;
+/** Escape */
+declare const ESC = 27;
+/** File Separator */
+declare const FS = 28;
+/** Group Separator */
+declare const GS = 29;
+/** End of Transmission */
+declare const EOT = 4;
+/** Enquiry */
+declare const ENQ = 5;
+/** Space */
+declare const SP = 32;
+
+/**
+ * Veränderlicher Byte-Akkumulator.
+ * Wird intern von CommandSequence und ReceiptBuilder verwendet,
+ * um Byte-Folgen effizient zusammenzusetzen.
+ * @category Hilfsfunktionen
+ */
+declare class ByteBuilder {
+    private readonly chunks;
+    private totalLength;
+    /** Fügt einzelne Bytes oder Byte-Arrays hinzu. */
+    push(...bytes: (number | Uint8Array | number[])[]): this;
+    /** Fügt einen Text als CP1252-Bytes hinzu. */
+    text(str: string): this;
+    /** Gibt alle gesammelten Bytes als Uint8Array zurück. */
+    build(): Uint8Array;
+    /** Gibt die aktuelle Gesamtlänge zurück. */
+    get length(): number;
+    /** Setzt den Builder zurück. */
+    reset(): this;
+}
+
+/**
+ * Hilfsfunktionen für Little-Endian-Darstellungen
+ * wie sie ESC/POS-Befehle mit nL/nH-Parametern verwenden.
+ * @category Hilfsfunktionen
+ */
+/**
+ * Teilt eine Ganzzahl in zwei Bytes (nL, nH) auf.
+ * n = nL + nH × 256
+ * @category Hilfsfunktionen
+ */
+declare function toUint16LE(n: number): [nL: number, nH: number];
+/**
+ * Berechnet das 16-Bit-Zweierkomplement für eine negative relative Position.
+ * ESC/POS: "Nach links N Einheiten" → 65536 − N
+ * @category Hilfsfunktionen
+ */
+declare function toComplement16(n: number): number;
+/**
+ * Liest nL + nH × 256 zurück in eine Ganzzahl.
+ */
+declare function fromUint16LE(nL: number, nH: number): number;
+
+/**
+ * ESC a n — Textausrichtung
+ * @category Enumerationen
+ */
+declare enum Alignment {
+    Left = 0,
+    Center = 1,
+    Right = 2
+}
+
+/**
+ * ESC M n — Zeichenfont
+ * @category Enumerationen
+ */
+declare enum Font {
+    /** Font A: 12×24 Dots */
+    A = 0,
+    /** Font B: 9×17 Dots */
+    B = 1
+}
+
+/**
+ * ESC – n — Unterstreichungsmodus
+ * @category Enumerationen
+ */
+declare enum UnderlineMode {
+    Off = 0,
+    OneTick = 1,
+    TwoTicks = 2
+}
+
+/**
+ * GS k — Barcode-Systeme.
+ * Form ① (m = 0–6): NUL-terminiert.
+ * Form ② (m = 65–73): Länge vorangestellt.
+ * Hier verwenden wir die Form-②-Werte als kanonisch (Form ① offset = -65).
+ * @category Enumerationen
+ */
+declare enum BarcodeSystem {
+    UPC_A = 65,
+    UPC_E = 66,
+    EAN13 = 67,
+    EAN8 = 68,
+    CODE39 = 69,
+    ITF = 70,
+    CODABAR = 71,
+    CODE93 = 72,
+    CODE128 = 73
+}
+
+/**
+ * GS w n — Barcode-Breite (2–6)
+ * @category Enumerationen
+ */
+declare enum BarcodeWidth {
+    Narrow = 2,
+    Medium = 3,
+    Wide = 4,
+    Wider = 5,
+    Widest = 6
+}
+
+/**
+ * GS H n — Position der Human Readable Interpretation (HRI)
+ * @category Enumerationen
+ */
+declare enum HriPosition {
+    None = 0,
+    Above = 1,
+    Below = 2,
+    Both = 3
+}
+
+/**
+ * GS f n — Schriftart der HRI-Zeichen
+ * @category Enumerationen
+ */
+declare enum HriFont {
+    /** Standard ASCII (12×24) */
+    A = 0,
+    /** Komprimiertes ASCII (9×17) */
+    B = 1
+}
+
+/**
+ * GS V m — Schnittmodus
+ * @category Enumerationen
+ */
+declare enum CutMode {
+    /** Vollschnitt (ein Punkt bleibt) m=0 */
+    Full = 0,
+    /** Teilschnitt m=1 */
+    Partial = 1,
+    /** Teilschnitt nach Vorschub m=66, braucht zusätzliches n */
+    PartialAfterFeed = 66
+}
+
+/**
+ * ESC t n — Zeichencodetabelle
+ * @category Enumerationen
+ */
+declare enum CharacterCodeTable {
+    PC437 = 0,
+    Katakana = 1,
+    PC850 = 2,
+    PC860 = 3,
+    PC863 = 4,
+    PC865 = 5,
+    WestEurope = 6,
+    Greek = 7,
+    Hebrew = 8,
+    PC755 = 9,
+    Iran = 10,
+    WPC1252 = 16,
+    PC866 = 17,
+    PC852 = 18,
+    PC858 = 19,
+    IranII = 20,
+    Latvian = 21
+}
+
+/**
+ * ESC R n — Internationaler Zeichensatz
+ * @category Enumerationen
+ */
+declare enum InternationalCharacterSet {
+    USA = 0,
+    France = 1,
+    Germany = 2,
+    UK = 3,
+    Denmark = 4,
+    Sweden = 5,
+    Italy = 6,
+    Spain = 7,
+    Japan = 8,
+    Norway = 9,
+    Denmark2 = 10,
+    Spain2 = 11,
+    Latin = 12,
+    Korea = 13,
+    SloveniaCroatia = 14,
+    Chinese = 15
+}
+
+/**
+ * ESC T n — Druckrichtung im Page-Modus
+ * @category Enumerationen
+ */
+declare enum PrintDirection {
+    /** Links → Rechts, Startpunkt oben links */
+    LeftToRight = 0,
+    /** Unten → Oben, Startpunkt unten links */
+    BottomToTop = 1,
+    /** Rechts → Links, Startpunkt unten rechts */
+    RightToLeft = 2,
+    /** Oben → Unten, Startpunkt oben rechts */
+    TopToBottom = 3
+}
+
+/**
+ * ESC * m — Bit-Bild-Modus
+ * @category Enumerationen
+ */
+declare enum BitImageMode {
+    /** 8-Dot, einfache Dichte */
+    SingleDensity8 = 0,
+    /** 8-Dot, doppelte Dichte */
+    DoubleDensity8 = 1,
+    /** 24-Dot, einfache Dichte */
+    SingleDensity24 = 32,
+    /** 24-Dot, doppelte Dichte */
+    DoubleDensity24 = 33
+}
+
+/**
+ * GS v 0 m — Raster-Bit-Bild-Modus
+ * Auch für FS p und GS /
+ * @category Enumerationen
+ */
+declare enum RasterMode {
+    Normal = 0,
+    DoubleWidth = 1,
+    DoubleHeight = 2,
+    Quadruple = 3
+}
+
+/**
+ * ESC p m / DLE DC4 n m t — Schubladenimpuls-Pin
+ * @category Enumerationen
+ */
+declare enum DrawerPin {
+    /** Connector Pin 2 */
+    Pin2 = 0,
+    /** Connector Pin 5 */
+    Pin5 = 1
+}
+
+/**
+ * GS ( k — QR-Code-Fehlerkorrektur-Level.
+ *
+ * L =  7% Wiederherstellung
+ * M = 15% Wiederherstellung
+ * Q = 25% Wiederherstellung
+ * H = 30% Wiederherstellung
+ * @category Enumerationen
+ */
+declare enum QrCodeErrorCorrection {
+    L = 48,
+    M = 49,
+    Q = 50,
+    H = 51
+}
+
+/**
+ * Das zentrale Command-Interface (Command-Pattern).
+ *
+ * Jeder ESC/POS-Befehl aus dem Handbuch wird als eigene Klasse implementiert,
+ * die dieses Interface erfüllt. Dadurch ist "was gedruckt wird" vollständig
+ * von "wie gesendet wird" entkoppelt.
+ * @category Befehle
+ */
+interface Command {
+    /** Menschenlesbarer Name des Befehls (z.B. "LineFeed", "PrintBarcode"). */
+    readonly name: string;
+    /**
+     * Kodiert den Befehl in seine ESC/POS-Byte-Repräsentation.
+     * Wirft RangeError wenn Parameter außerhalb der Handbuch-Bereiche liegen.
+     */
+    encode(): Uint8Array;
+}
+
+/**
+ * Template-Method-Basisklasse für alle ESC/POS-Befehle.
+ *
+ * Definiert den Ablauf: validate() → encodeBody().
+ * Unterklassen implementieren nur encodeBody() (und optional validate()).
+ * @category Befehle
+ */
+declare abstract class AbstractCommand implements Command {
+    abstract readonly name: string;
+    /**
+     * Template Method: Validierung, dann Kodierung.
+     * Wirft RangeError wenn validate() fehlschlägt.
+     */
+    encode(): Uint8Array;
+    /**
+     * Implementiert die eigentliche Byte-Erzeugung.
+     * Wird erst nach erfolgreicher Validierung aufgerufen.
+     */
+    protected abstract encodeBody(): Uint8Array;
+    /**
+     * Überprüft Parameter-Bereiche. Wirft RangeError bei Verletzung.
+     * Standard-Implementierung: keine Prüfung (für parameterlose Befehle).
+     */
+    protected validate(): void;
+    /**
+     * Hilfsmethode: Prüft, ob ein Wert im erlaubten Bereich liegt.
+     */
+    protected assertRange(value: number, min: number, max: number, paramName?: string): void;
+}
+
+/**
+ * Composite + Iterator Pattern.
+ *
+ * Eine CommandSequence ist selbst ein Command (Composite) und enthält
+ * beliebig viele Kind-Commands. Ein kompletter Bon = eine CommandSequence.
+ * Ist iterierbar über alle enthaltenen Commands ([Symbol.iterator]).
+ * @category Befehle
+ */
+declare class CommandSequence implements Command {
+    readonly name = "CommandSequence";
+    private readonly commands;
+    constructor(...initial: Command[]);
+    /** Fügt einen oder mehrere Commands ans Ende hinzu. */
+    add(...cmds: Command[]): this;
+    /** Anzahl der enthaltenen Commands. */
+    get size(): number;
+    /**
+     * Iterator über alle Kind-Commands (Iterator-Pattern).
+     * Ermöglicht: for (const cmd of sequence) { ... }
+     */
+    [Symbol.iterator](): Iterator<Command>;
+    /**
+     * Kodiert alle enthaltenen Commands zu einer einzigen Byte-Folge.
+     * Composite-Implementierung: encode() ruft encode() aller Kinder auf.
+     */
+    encode(): Uint8Array;
+}
+
+/**
+ * Escape-Hatch: beliebige Byte-Folge als Command.
+ *
+ * Nützlich für vendor-spezifische Erweiterungen, die nicht im Handbuch
+ * dokumentiert sind, oder für direkte Byte-Eingaben aus externem Code.
+ * @category Befehle
+ */
+declare class RawCommand implements Command {
+    readonly name: string;
+    private readonly bytes;
+    constructor(bytes: Uint8Array | number[], name?: string);
+    encode(): Uint8Array;
+}
+
+/**
+ * Singleton-Registry aller bekannten Command-Typen.
+ *
+ * Ermöglicht Introspektion (z.B. für Hex-Dumps, Logging, Debugging).
+ * Externe Bibliotheken können eigene Command-Typen registrieren.
+ * @category Befehle
+ */
+/**
+ * Registrierungseintrag für einen Command-Typ.
+ * @category Befehle
+ */
+interface CommandRegistration {
+    name: string;
+    description: string;
+    escPosCommand: string;
+}
+declare class CommandRegistry {
+    private static instance;
+    private readonly registrations;
+    private constructor();
+    /** Gibt die einzige Instanz zurück (Singleton-Pattern). */
+    static getInstance(): CommandRegistry;
+    /** Registriert einen Command-Typ. */
+    register(reg: CommandRegistration): void;
+    /** Gibt alle Registrierungen zurück. */
+    getAll(): ReadonlyMap<string, CommandRegistration>;
+    /** Gibt eine Registrierung nach Name zurück. */
+    get(name: string): CommandRegistration | undefined;
+    /** Prüft ob ein Command-Typ registriert ist. */
+    has(name: string): boolean;
+    /** Nur für Tests — setzt den Singleton zurück. */
+    static _reset(): void;
+}
+
+/**
+ * HT — Horizontaler Tabulator
+ * @category Einzelne Befehle
+ */
+declare class HorizontalTabCommand extends AbstractCommand {
+    readonly name = "HorizontalTab";
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * LF — Zeilenvorschub
+ * @category Einzelne Befehle
+ */
+declare class LineFeedCommand extends AbstractCommand {
+    readonly name = "LineFeed";
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * FF — Seitenvorschub / Rückkehr in Standard-Modus aus Page-Modus
+ * @category Einzelne Befehle
+ */
+declare class FormFeedCommand extends AbstractCommand {
+    readonly name = "FormFeed";
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * CR — Wagenrücklauf
+ * @category Einzelne Befehle
+ */
+declare class CarriageReturnCommand extends AbstractCommand {
+    readonly name = "CarriageReturn";
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * CAN — Druckdaten im Page-Modus löschen
+ * @category Einzelne Befehle
+ */
+declare class CancelPageDataCommand extends AbstractCommand {
+    readonly name = "CancelPageData";
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * DLE EOT n — Echtzeit-Status übertragen.
+ * n=1: Druckerstatus, n=2: Offline-Status, n=3: Fehlerstatus, n=4: Papiersensor-Status
+ * @category Einzelne Befehle
+ */
+declare class TransmitRealtimeStatusCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "TransmitRealtimeStatus";
+    constructor(n: 1 | 2 | 3 | 4);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * DLE ENQ n — Echtzeit-Anfrage an Drucker.
+ * n=1: Fehler-Wiederherstellung (neu drucken), n=2: Fehler-Wiederherstellung (Puffer löschen)
+ * @category Einzelne Befehle
+ */
+declare class RealtimeRequestCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "RealtimeRequest";
+    constructor(n: 1 | 2);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * DLE DC4 n m t — Impuls in Echtzeit erzeugen.
+ * n immer 1, m=Pin (0=Pin2, 1=Pin5), t=1–8 (Dauer t×100ms)
+ * @category Einzelne Befehle
+ */
+declare class GeneratePulseRealtimeCommand extends AbstractCommand {
+    private readonly pin;
+    private readonly t;
+    readonly name = "GeneratePulseRealtime";
+    constructor(pin: DrawerPin, t: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC FF — Im Page-Modus drucken (Puffer nicht leeren)
+ * @category Einzelne Befehle
+ */
+declare class PrintPageModeCommand extends AbstractCommand {
+    readonly name = "PrintPageMode";
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC SP n — Rechten Zeichenabstand setzen (0–255)
+ * @category Einzelne Befehle
+ */
+declare class SetRightCharacterSpacingCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "SetRightCharacterSpacing";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * Optionen für SelectPrintModesCommand.
+ * @category Einzelne Befehle
+ */
+interface PrintModesOptions {
+    /** Font B (9×17) statt Font A (12×24) */
+    fontB?: boolean;
+    /** Fett-Druck */
+    emphasized?: boolean;
+    /** Doppelte Höhe */
+    doubleHeight?: boolean;
+    /** Doppelte Breite */
+    doubleWidth?: boolean;
+    /** Unterstrichen */
+    underline?: boolean;
+}
+/**
+ * ESC ! n — Druckmodus(e) auswählen.
+ * Bit 0: Font, Bit 3: Emphasized, Bit 4: DoubleHeight, Bit 5: DoubleWidth, Bit 7: Underline
+ * @category Einzelne Befehle
+ */
+declare class SelectPrintModesCommand extends AbstractCommand {
+    readonly name = "SelectPrintModes";
+    private readonly n;
+    constructor(opts?: PrintModesOptions);
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC $ nL nH — Absolute Druckposition setzen
+ * @category Einzelne Befehle
+ */
+declare class SetAbsolutePositionCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "SetAbsolutePosition";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC % n — Benutzerdefinierter Zeichensatz ein/aus
+ * @category Einzelne Befehle
+ */
+declare class SelectUserCharSetCommand extends AbstractCommand {
+    private readonly enable;
+    readonly name = "SelectUserCharSet";
+    constructor(enable: boolean);
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC & y c1 c2 [x1 d1...d(y×x1)]...[xk d1...d(y×xk)]
+ * Benutzerdefinierte Zeichen definieren.
+ * @category Einzelne Befehle
+ */
+declare class DefineUserCharsCommand extends AbstractCommand {
+    private readonly y;
+    private readonly c1;
+    private readonly c2;
+    private readonly data;
+    readonly name = "DefineUserChars";
+    constructor(y: number, c1: number, c2: number, data: Uint8Array);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC * m nL nH d1...dk — Bit-Bild-Modus auswählen
+ * @category Einzelne Befehle
+ */
+declare class SelectBitImageModeCommand extends AbstractCommand {
+    private readonly mode;
+    private readonly nL;
+    private readonly nH;
+    private readonly data;
+    readonly name = "SelectBitImageMode";
+    constructor(mode: BitImageMode, nL: number, nH: number, data: Uint8Array);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC – n — Unterstreichungsmodus ein/aus
+ * @category Einzelne Befehle
+ */
+declare class SetUnderlineCommand extends AbstractCommand {
+    private readonly mode;
+    readonly name = "SetUnderline";
+    constructor(mode: UnderlineMode);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC 2 — Standard-Zeilenabstand (~4.23mm / 1/6 Zoll)
+ * @category Einzelne Befehle
+ */
+declare class SetDefaultLineSpacingCommand extends AbstractCommand {
+    readonly name = "SetDefaultLineSpacing";
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC 3 n — Zeilenabstand setzen (0–255)
+ * @category Einzelne Befehle
+ */
+declare class SetLineSpacingCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "SetLineSpacing";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC = n — Peripheriegerät auswählen (Bit 0: Drucker aktiv)
+ * @category Einzelne Befehle
+ */
+declare class SetPeripheralDeviceCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "SetPeripheralDevice";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC ? n — Benutzerdefiniertes Zeichen löschen (32–126)
+ * @category Einzelne Befehle
+ */
+declare class CancelUserCharCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "CancelUserChar";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC @ — Drucker initialisieren (Puffer leeren, Modi zurücksetzen)
+ * @category Einzelne Befehle
+ */
+declare class InitializeCommand extends AbstractCommand {
+    readonly name = "Initialize";
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC D n1...nk NUL — Horizontale Tabulatorpositionen setzen (max. 32)
+ * @category Einzelne Befehle
+ */
+declare class SetHorizontalTabPositionsCommand extends AbstractCommand {
+    private readonly positions;
+    readonly name = "SetHorizontalTabPositions";
+    constructor(positions: number[]);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC E n — Fettdruck ein/aus (LSB entscheidet)
+ * @category Einzelne Befehle
+ */
+declare class SetEmphasizedCommand extends AbstractCommand {
+    private readonly on;
+    readonly name = "SetEmphasized";
+    constructor(on: boolean);
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC G n — Doppeldruck ein/aus
+ * @category Einzelne Befehle
+ */
+declare class SetDoubleStrikeCommand extends AbstractCommand {
+    private readonly on;
+    readonly name = "SetDoubleStrike";
+    constructor(on: boolean);
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC J n — Drucken und Papier vorschub um n × Bewegungseinheit
+ * @category Einzelne Befehle
+ */
+declare class PrintAndFeedPaperCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "PrintAndFeedPaper";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC L — In Page-Modus wechseln
+ * @category Einzelne Befehle
+ */
+declare class SelectPageModeCommand extends AbstractCommand {
+    readonly name = "SelectPageMode";
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC M n — Zeichenzeichensatz auswählen (Font A / B)
+ * @category Einzelne Befehle
+ */
+declare class SelectCharacterFontCommand extends AbstractCommand {
+    private readonly font;
+    readonly name = "SelectCharacterFont";
+    constructor(font: Font);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC R n — Internationalen Zeichensatz auswählen (0–15)
+ * @category Einzelne Befehle
+ */
+declare class SelectInternationalCharSetCommand extends AbstractCommand {
+    private readonly charSet;
+    readonly name = "SelectInternationalCharSet";
+    constructor(charSet: InternationalCharacterSet);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC S — In Standard-Modus wechseln (aus Page-Modus)
+ * @category Einzelne Befehle
+ */
+declare class SelectStandardModeCommand extends AbstractCommand {
+    readonly name = "SelectStandardMode";
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC T n — Druckrichtung im Page-Modus auswählen (0–3)
+ * @category Einzelne Befehle
+ */
+declare class SelectPrintDirectionCommand extends AbstractCommand {
+    private readonly direction;
+    readonly name = "SelectPrintDirection";
+    constructor(direction: PrintDirection);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC V n — 90°-Drehung ein/aus
+ * @category Einzelne Befehle
+ */
+declare class SetRotationCommand extends AbstractCommand {
+    private readonly on;
+    readonly name = "SetRotation";
+    constructor(on: boolean);
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC W xL xH yL yH dxL dxH dyL dyH — Druckbereich im Page-Modus setzen
+ * @category Einzelne Befehle
+ */
+declare class SetPrintingAreaPageModeCommand extends AbstractCommand {
+    private readonly xL;
+    private readonly xH;
+    private readonly yL;
+    private readonly yH;
+    private readonly dxL;
+    private readonly dxH;
+    private readonly dyL;
+    private readonly dyH;
+    readonly name = "SetPrintingAreaPageMode";
+    constructor(xL: number, xH: number, yL: number, yH: number, dxL: number, dxH: number, dyL: number, dyH: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC \ nL nH — Relative Druckposition setzen.
+ * Positive Werte bewegen nach rechts, negative nach links (Zweierkomplement).
+ * @category Einzelne Befehle
+ */
+declare class SetRelativePositionCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "SetRelativePosition";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC a n — Textausrichtung (0=Links, 1=Mitte, 2=Rechts)
+ * @category Einzelne Befehle
+ */
+declare class SetJustificationCommand extends AbstractCommand {
+    private readonly alignment;
+    readonly name = "SetJustification";
+    constructor(alignment: Alignment);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC c 3 n — Papierende-Sensoren für Signal-Ausgabe auswählen
+ * @category Einzelne Befehle
+ */
+declare class SelectPaperEndSensorsCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "SelectPaperEndSensors";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC c 4 n — Papierende-Sensoren für Druck-Stopp auswählen
+ * @category Einzelne Befehle
+ */
+declare class SelectPaperStopSensorsCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "SelectPaperStopSensors";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC c 5 n — Bedienfeld-Tasten aktivieren/deaktivieren
+ * @category Einzelne Befehle
+ */
+declare class EnablePanelButtonsCommand extends AbstractCommand {
+    private readonly enable;
+    readonly name = "EnablePanelButtons";
+    constructor(enable: boolean);
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC d n — Drucken und n Zeilen vorschub
+ * @category Einzelne Befehle
+ */
+declare class PrintAndFeedLinesCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "PrintAndFeedLines";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC p m t1 t2 — Impuls erzeugen.
+ * ON-Zeit = t1×2ms, OFF-Zeit = t2×2ms (min. t1×2ms wenn t2<t1)
+ * @category Einzelne Befehle
+ */
+declare class GeneratePulseCommand extends AbstractCommand {
+    private readonly pin;
+    private readonly t1;
+    private readonly t2;
+    readonly name = "GeneratePulse";
+    constructor(pin: DrawerPin, t1: number, t2: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC t n — Zeichencodetabelle auswählen
+ * @category Einzelne Befehle
+ */
+declare class SelectCharacterCodeTableCommand extends AbstractCommand {
+    private readonly table;
+    readonly name = "SelectCharacterCodeTable";
+    constructor(table: CharacterCodeTable);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC { n — Kopfüber-Druck ein/aus
+ * @category Einzelne Befehle
+ */
+declare class SetUpsideDownCommand extends AbstractCommand {
+    private readonly on;
+    readonly name = "SetUpsideDown";
+    constructor(on: boolean);
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC B n t — Einzelnen Piep ausgeben.
+ * n=Anzahl (1–9), t=Dauer je Ton (t×50ms, 1–9)
+ * @category Einzelne Befehle
+ */
+declare class BeepCommand extends AbstractCommand {
+    private readonly count;
+    private readonly duration;
+    readonly name = "Beep";
+    constructor(count: number, duration: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * ESC C m t n — Piep und Alarmlampe blinken.
+ * m=Anzahl (1–20), t=Intervall (t×50ms, 1–20),
+ * n=0: nichts, 1: Piep, 2: Blinken, 3: beides
+ * @category Einzelne Befehle
+ */
+declare class BeepAndFlashCommand extends AbstractCommand {
+    private readonly count;
+    private readonly interval;
+    private readonly mode;
+    readonly name = "BeepAndFlash";
+    constructor(count: number, interval: number, mode: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * FS p n m — NV-Bit-Bild drucken
+ * @category Einzelne Befehle
+ */
+declare class PrintNvBitImageCommand extends AbstractCommand {
+    private readonly n;
+    private readonly mode;
+    readonly name = "PrintNvBitImage";
+    constructor(n: number, mode: RasterMode);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * Bilddaten für DefineNvBitImageCommand.
+ * @category Einzelne Befehle
+ */
+interface NvBitImageData {
+    xL: number;
+    xH: number;
+    yL: number;
+    yH: number;
+    data: Uint8Array;
+}
+/**
+ * FS q n [xL xH yL yH d1…dk]1…n — NV-Bit-Bilder definieren
+ * @category Einzelne Befehle
+ */
+declare class DefineNvBitImageCommand extends AbstractCommand {
+    private readonly n;
+    private readonly images;
+    readonly name = "DefineNvBitImage";
+    constructor(n: number, images: NvBitImageData[]);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * FS ! n — Kanji-Druckmodus setzen.
+ * Bit 2: DoppeltBreit, Bit 3: DoppeltHoch, Bit 7: Unterstrichen
+ * @category Einzelne Befehle
+ */
+declare class SetKanjiPrintModeCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "SetKanjiPrintMode";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * FS & — Kanji-Modus aktivieren
+ * @category Einzelne Befehle
+ */
+declare class SelectKanjiModeCommand extends AbstractCommand {
+    readonly name = "SelectKanjiMode";
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * FS – n — Kanji-Unterstreichungsmodus (0=aus, 1=1 Punkt, 2=2 Punkte)
+ * @category Einzelne Befehle
+ */
+declare class SetKanjiUnderlineCommand extends AbstractCommand {
+    private readonly mode;
+    readonly name = "SetKanjiUnderline";
+    constructor(mode: UnderlineMode);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * FS . — Kanji-Modus deaktivieren
+ * @category Einzelne Befehle
+ */
+declare class CancelKanjiModeCommand extends AbstractCommand {
+    readonly name = "CancelKanjiMode";
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * FS 2 c1 c2 d1...dk — Benutzerdefiniertes Kanji-Zeichen definieren.
+ * k=72 (24×24 Dot, 3 Bytes vertikal × 24 Spalten)
+ * @category Einzelne Befehle
+ */
+declare class DefineKanjiCommand extends AbstractCommand {
+    private readonly c1;
+    private readonly c2;
+    private readonly data;
+    readonly name = "DefineKanji";
+    constructor(c1: number, c2: number, data: Uint8Array);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * FS S n1 n2 — Linken und rechten Kanji-Zeichenabstand setzen
+ * @category Einzelne Befehle
+ */
+declare class SetKanjiSpacingCommand extends AbstractCommand {
+    private readonly n1;
+    private readonly n2;
+    readonly name = "SetKanjiSpacing";
+    constructor(n1: number, n2: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * FS W n — Kanji-Vierfachgröße ein/aus
+ * @category Einzelne Befehle
+ */
+declare class SetKanjiQuadrupleCommand extends AbstractCommand {
+    private readonly on;
+    readonly name = "SetKanjiQuadruple";
+    constructor(on: boolean);
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS ! n — Zeichengröße auswählen.
+ * heightTimes: 1–8 (vertikal), widthTimes: 1–8 (horizontal)
+ * n = (widthTimes-1) << 4 | (heightTimes-1)
+ * @category Einzelne Befehle
+ */
+declare class SelectCharacterSizeCommand extends AbstractCommand {
+    private readonly heightTimes;
+    private readonly widthTimes;
+    readonly name = "SelectCharacterSize";
+    constructor(heightTimes: number, widthTimes: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS $ nL nH — Absolute vertikale Druckposition im Page-Modus setzen
+ * @category Einzelne Befehle
+ */
+declare class SetAbsoluteVerticalPositionCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "SetAbsoluteVerticalPosition";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS * x y d1...d(x×y×8) — Download-Bit-Bild definieren.
+ * x: 1–255, y: 1–48, x×y ≤ 912
+ * @category Einzelne Befehle
+ */
+declare class DefineDownloadedBitImageCommand extends AbstractCommand {
+    private readonly x;
+    private readonly y;
+    private readonly data;
+    readonly name = "DefineDownloadedBitImage";
+    constructor(x: number, y: number, data: Uint8Array);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS / m — Download-Bit-Bild drucken
+ * @category Einzelne Befehle
+ */
+declare class PrintDownloadedBitImageCommand extends AbstractCommand {
+    private readonly mode;
+    readonly name = "PrintDownloadedBitImage";
+    constructor(mode: RasterMode);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS : — Makrodefinition beginnen/beenden
+ * @category Einzelne Befehle
+ */
+declare class MacroStartEndCommand extends AbstractCommand {
+    readonly name = "MacroStartEnd";
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS B n — Schwarz/Weiß-Umkehrdruck ein/aus
+ * @category Einzelne Befehle
+ */
+declare class SetReverseCommand extends AbstractCommand {
+    private readonly on;
+    readonly name = "SetReverse";
+    constructor(on: boolean);
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS H n — HRI-Zeichenposition für Barcodes auswählen
+ * @category Einzelne Befehle
+ */
+declare class SetHriPositionCommand extends AbstractCommand {
+    private readonly position;
+    readonly name = "SetHriPosition";
+    constructor(position: HriPosition);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS L nL nH — Linken Rand setzen
+ * @category Einzelne Befehle
+ */
+declare class SetLeftMarginCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "SetLeftMargin";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS P x y — Horizontale und vertikale Bewegungseinheiten setzen
+ * @category Einzelne Befehle
+ */
+declare class SetMotionUnitsCommand extends AbstractCommand {
+    private readonly x;
+    private readonly y;
+    readonly name = "SetMotionUnits";
+    constructor(x: number, y: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS V m [n] — Papier schneiden.
+ * Form ①: m=0 (voll) oder m=1 (teil), kein n
+ * Form ②: m=66, n=Vorschubpunkte (0–255)
+ * @category Einzelne Befehle
+ */
+declare class CutCommand extends AbstractCommand {
+    private readonly mode;
+    private readonly feedDots?;
+    readonly name = "Cut";
+    constructor(mode: CutMode, feedDots?: number | undefined);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS W nL nH — Druckbereichsbreite setzen
+ * @category Einzelne Befehle
+ */
+declare class SetPrintingAreaWidthCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "SetPrintingAreaWidth";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS \ nL nH — Relative vertikale Druckposition im Page-Modus setzen
+ * @category Einzelne Befehle
+ */
+declare class SetRelativeVerticalPositionCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "SetRelativeVerticalPosition";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS ^ r t m — Makro ausführen.
+ * r=Wiederholungen (0–255), t=Wartezeit (0–255), m=Modus (0=kontinuierlich, 1=FEED-Taste)
+ * @category Einzelne Befehle
+ */
+declare class ExecuteMacroCommand extends AbstractCommand {
+    private readonly r;
+    private readonly t;
+    private readonly m;
+    readonly name = "ExecuteMacro";
+    constructor(r: number, t: number, m: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS a n — Automatischen Status-Rückkanal (ASB) aktivieren/deaktivieren
+ * @category Einzelne Befehle
+ */
+declare class EnableAsbCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "EnableAsb";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS f n — Schriftart für HRI-Zeichen auswählen
+ * @category Einzelne Befehle
+ */
+declare class SetHriFontCommand extends AbstractCommand {
+    private readonly font;
+    readonly name = "SetHriFont";
+    constructor(font: HriFont);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS h n — Barcode-Höhe setzen (1–255 Dots)
+ * @category Einzelne Befehle
+ */
+declare class SetBarcodeHeightCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "SetBarcodeHeight";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * Strategy-Interface für die Barcode-Datenkodierung.
+ *
+ * Implementierungen kapseln das systemspezifische Codierungsprotokoll
+ * (NUL-Terminierung vs. Längenpräfix, Zeichenvalidierung, CODE128-Subsets).
+ * @category Barcode-Strategien
+ */
+interface BarcodeEncodingStrategy {
+    readonly system: BarcodeSystem;
+    /**
+     * Kodiert Barcode-Daten in ESC/POS-Bytes (ohne GS k m Präfix).
+     * Wirft Error/RangeError wenn Daten ungültig sind.
+     */
+    encode(data: Uint8Array | string): Uint8Array;
+}
+
+/**
+ * GS k m n d1...dn — Barcode drucken (Form ②, Längenpräfix).
+ *
+ * Verwendet das Strategy-Pattern für systemspezifische Daten-Kodierung.
+ * Eigene Strategien können von außen injiziert werden (Erweiterbarkeit).
+ * @category Einzelne Befehle
+ */
+declare class PrintBarcodeCommand extends AbstractCommand {
+    private readonly system;
+    private readonly data;
+    readonly name = "PrintBarcode";
+    private readonly strategy;
+    constructor(system: BarcodeSystem, data: Uint8Array | string, strategy?: BarcodeEncodingStrategy);
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS r n — Status übertragen.
+ * n=1/49: Papiersensor-Status, n=2/50: Schubladen-Status
+ * @category Einzelne Befehle
+ */
+declare class TransmitStatusCommand extends AbstractCommand {
+    private readonly n;
+    readonly name = "TransmitStatus";
+    constructor(n: number);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS v 0 m xL xH yL yH d1...dk — Raster-Bit-Bild drucken.
+ * k = (xL + xH×256) × (yL + yH×256)
+ * @category Einzelne Befehle
+ */
+declare class PrintRasterBitImageCommand extends AbstractCommand {
+    private readonly mode;
+    private readonly xL;
+    private readonly xH;
+    private readonly yL;
+    private readonly yH;
+    private readonly data;
+    readonly name = "PrintRasterBitImage";
+    constructor(mode: RasterMode, xL: number, xH: number, yL: number, yH: number, data: Uint8Array);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS w n — Barcode-Breite setzen (2–6)
+ * @category Einzelne Befehle
+ */
+declare class SetBarcodeWidthCommand extends AbstractCommand {
+    private readonly width;
+    readonly name = "SetBarcodeWidth";
+    constructor(width: BarcodeWidth);
+    protected validate(): void;
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * GS ( A pL pH n m — Hex-Dump Testdruck ausführen
+ * @category Einzelne Befehle
+ */
+declare class HexDumpCommand extends AbstractCommand {
+    readonly name = "HexDump";
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * Optionen für PrintQrCodeCommand.
+ * @category Einzelne Befehle
+ */
+interface QrCodeOptions {
+    /** Modulgröße 1–16 (Pixel pro Modul). Standard: 3 */
+    moduleSize?: number;
+    /** Fehlerkorrektur-Level. Standard: M */
+    errorCorrection?: QrCodeErrorCorrection;
+    /** QR-Code-Modell 1 oder 2. Standard: 2 (empfohlen) */
+    model?: 1 | 2;
+}
+/**
+ * GS ( k — QR-Code drucken.
+ *
+ * Sendet die vollständige 5-Schritt-Sequenz:
+ *   1. Modell setzen
+ *   2. Modulgröße setzen
+ *   3. Fehlerkorrektur setzen
+ *   4. Daten speichern
+ *   5. QR-Code drucken
+ * @category Einzelne Befehle
+ */
+declare class PrintQrCodeCommand extends AbstractCommand {
+    readonly name = "PrintQrCode";
+    private readonly data;
+    private readonly moduleSize;
+    private readonly errorCorrection;
+    private readonly model;
+    constructor(data: string | Uint8Array, options?: QrCodeOptions);
+    protected encodeBody(): Uint8Array;
+}
+
+/**
+ * Factory-Pattern: Erzeugt Command-Objekte nach Intention.
+ *
+ * Kapselt die Konstruktordetails aller Command-Klassen und bietet
+ * eine semantisch sprechende API. Erlaubt auch Registrierung eigener
+ * Command-Typen von außen (Erweiterbarkeit).
+ * @category Befehle
+ */
+
+type CustomFactory = (options?: Record<string, unknown>) => Command;
+declare class CommandFactory {
+    private static readonly customFactories;
+    /** Registriert eine eigene Command-Fabrik unter einem Namen. */
+    static register(name: string, factory: CustomFactory): void;
+    /** Erzeugt einen registrierten Custom-Command. */
+    static createCustom(name: string, options?: Record<string, unknown>): Command;
+    static horizontalTab(): HorizontalTabCommand;
+    static lineFeed(): LineFeedCommand;
+    static formFeed(): FormFeedCommand;
+    static carriageReturn(): CarriageReturnCommand;
+    static cancelPageData(): CancelPageDataCommand;
+    static transmitRealtimeStatus(n: 1 | 2 | 3 | 4): TransmitRealtimeStatusCommand;
+    static realtimeRequest(n: 1 | 2): RealtimeRequestCommand;
+    static generatePulseRealtime(pin: DrawerPin, t: number): GeneratePulseRealtimeCommand;
+    static printPageMode(): PrintPageModeCommand;
+    static setRightCharacterSpacing(n: number): SetRightCharacterSpacingCommand;
+    static selectPrintModes(opts: PrintModesOptions): SelectPrintModesCommand;
+    static setAbsolutePosition(n: number): SetAbsolutePositionCommand;
+    static selectUserCharSet(enable: boolean): SelectUserCharSetCommand;
+    static defineUserChars(y: number, c1: number, c2: number, data: Uint8Array): DefineUserCharsCommand;
+    static selectBitImageMode(mode: BitImageMode, nL: number, nH: number, data: Uint8Array): SelectBitImageModeCommand;
+    static setUnderline(mode: UnderlineMode): SetUnderlineCommand;
+    static setDefaultLineSpacing(): SetDefaultLineSpacingCommand;
+    static setLineSpacing(n: number): SetLineSpacingCommand;
+    static setPeripheralDevice(n: number): SetPeripheralDeviceCommand;
+    static cancelUserChar(n: number): CancelUserCharCommand;
+    static initialize(): InitializeCommand;
+    static setHorizontalTabPositions(positions: number[]): SetHorizontalTabPositionsCommand;
+    static setEmphasized(on: boolean): SetEmphasizedCommand;
+    static setDoubleStrike(on: boolean): SetDoubleStrikeCommand;
+    static printAndFeedPaper(n: number): PrintAndFeedPaperCommand;
+    static selectPageMode(): SelectPageModeCommand;
+    static selectCharacterFont(font: Font): SelectCharacterFontCommand;
+    static selectInternationalCharSet(cs: InternationalCharacterSet): SelectInternationalCharSetCommand;
+    static selectStandardMode(): SelectStandardModeCommand;
+    static selectPrintDirection(dir: PrintDirection): SelectPrintDirectionCommand;
+    static setRotation(on: boolean): SetRotationCommand;
+    static setPrintingAreaPageMode(xL: number, xH: number, yL: number, yH: number, dxL: number, dxH: number, dyL: number, dyH: number): SetPrintingAreaPageModeCommand;
+    static setRelativePosition(n: number): SetRelativePositionCommand;
+    static setJustification(align: Alignment): SetJustificationCommand;
+    static selectPaperEndSensors(n: number): SelectPaperEndSensorsCommand;
+    static selectPaperStopSensors(n: number): SelectPaperStopSensorsCommand;
+    static enablePanelButtons(enable: boolean): EnablePanelButtonsCommand;
+    static printAndFeedLines(n: number): PrintAndFeedLinesCommand;
+    static generatePulse(pin: DrawerPin, t1: number, t2: number): GeneratePulseCommand;
+    static selectCharacterCodeTable(table: CharacterCodeTable): SelectCharacterCodeTableCommand;
+    static setUpsideDown(on: boolean): SetUpsideDownCommand;
+    static beep(count: number, duration: number): BeepCommand;
+    static beepAndFlash(count: number, interval: number, mode: number): BeepAndFlashCommand;
+    static printNvBitImage(n: number, mode: RasterMode): PrintNvBitImageCommand;
+    static defineNvBitImage(n: number, images: Array<{
+        xL: number;
+        xH: number;
+        yL: number;
+        yH: number;
+        data: Uint8Array;
+    }>): DefineNvBitImageCommand;
+    static setKanjiPrintMode(n: number): SetKanjiPrintModeCommand;
+    static selectKanjiMode(): SelectKanjiModeCommand;
+    static setKanjiUnderline(mode: UnderlineMode): SetKanjiUnderlineCommand;
+    static cancelKanjiMode(): CancelKanjiModeCommand;
+    static defineKanji(c1: number, c2: number, data: Uint8Array): DefineKanjiCommand;
+    static setKanjiSpacing(n1: number, n2: number): SetKanjiSpacingCommand;
+    static setKanjiQuadruple(on: boolean): SetKanjiQuadrupleCommand;
+    static selectCharacterSize(heightTimes: number, widthTimes: number): SelectCharacterSizeCommand;
+    static setAbsoluteVerticalPosition(n: number): SetAbsoluteVerticalPositionCommand;
+    static defineDownloadedBitImage(x: number, y: number, data: Uint8Array): DefineDownloadedBitImageCommand;
+    static printDownloadedBitImage(mode: RasterMode): PrintDownloadedBitImageCommand;
+    static macroStartEnd(): MacroStartEndCommand;
+    static setReverse(on: boolean): SetReverseCommand;
+    static setHriPosition(pos: HriPosition): SetHriPositionCommand;
+    static setLeftMargin(n: number): SetLeftMarginCommand;
+    static setMotionUnits(x: number, y: number): SetMotionUnitsCommand;
+    static cut(mode: CutMode, feedDots?: number): CutCommand;
+    static setPrintingAreaWidth(n: number): SetPrintingAreaWidthCommand;
+    static setRelativeVerticalPosition(n: number): SetRelativeVerticalPositionCommand;
+    static executeMacro(r: number, t: number, m: number): ExecuteMacroCommand;
+    static enableAsb(n: number): EnableAsbCommand;
+    static setHriFont(font: HriFont): SetHriFontCommand;
+    static setBarcodeHeight(n: number): SetBarcodeHeightCommand;
+    static printBarcode(system: BarcodeSystem, data: Uint8Array | string, strategy?: BarcodeEncodingStrategy): PrintBarcodeCommand;
+    static transmitStatus(n: number): TransmitStatusCommand;
+    static printRasterBitImage(mode: RasterMode, xL: number, xH: number, yL: number, yH: number, data: Uint8Array): PrintRasterBitImageCommand;
+    static setBarcodeWidth(width: BarcodeWidth): SetBarcodeWidthCommand;
+    static hexDump(): HexDumpCommand;
+    static printQrCode(data: string | Uint8Array, options?: QrCodeOptions): PrintQrCodeCommand;
+    static raw(bytes: Uint8Array | number[], name?: string): RawCommand;
+}
+
+/**
+ * Strategie für CODE128 — Form ② (Längenpräfix).
+ *
+ * Subset-Auswahl via Steuerzeichen laut Handbuch:
+ *   {A = Code Set A,  {B = Code Set B,  {C = Code Set C
+ *   {1–{4 = FNC1–FNC4,  {S = SHIFT,  {{ = literal "{"
+ *
+ * Der Eingabestring wird so wie er ist übergeben (inkl. {-Escapes).
+ * Validation: Muss mit einem Subset-Selektor starten ({A, {B oder {C).
+ * @category Barcode-Strategien
+ */
+declare class Code128Strategy implements BarcodeEncodingStrategy {
+    readonly system = BarcodeSystem.CODE128;
+    encode(data: Uint8Array | string): Uint8Array;
+}
+
+/**
+ * Strategie für CODE39 — Form ② (Längenpräfix)
+ * @category Barcode-Strategien
+ */
+declare class Code39Strategy implements BarcodeEncodingStrategy {
+    readonly system = BarcodeSystem.CODE39;
+    encode(data: Uint8Array | string): Uint8Array;
+}
+
+/**
+ * Strategie für ITF (Interleaved 2 of 5) — muss gerade Anzahl Ziffern haben
+ * @category Barcode-Strategien
+ */
+declare class ItfStrategy implements BarcodeEncodingStrategy {
+    readonly system = BarcodeSystem.ITF;
+    encode(data: Uint8Array | string): Uint8Array;
+}
+
+/**
+ * Strategie für CODABAR — Form ② (Längenpräfix)
+ * @category Barcode-Strategien
+ */
+declare class CodabarStrategy implements BarcodeEncodingStrategy {
+    readonly system = BarcodeSystem.CODABAR;
+    encode(data: Uint8Array | string): Uint8Array;
+}
+
+/**
+ * Strategie für numerische Barcodes (UPC-A, UPC-E, EAN13, EAN8, ITF).
+ * Verwendet Form ② (Längenpräfix).
+ * @category Barcode-Strategien
+ */
+declare class SimpleNumericBarcodeStrategy implements BarcodeEncodingStrategy {
+    readonly system: BarcodeSystem;
+    private readonly minLen;
+    private readonly maxLen;
+    constructor(system: BarcodeSystem, minLen: number, maxLen: number);
+    encode(data: Uint8Array | string): Uint8Array;
+}
+
+/**
+ * Aktueller Formatierungszustand des ReceiptBuilders.
+ * Wird als Memento gespeichert und wiederhergestellt.
+ * @category Builder
+ */
+declare class PrintState {
+    alignment: Alignment;
+    font: Font;
+    emphasized: boolean;
+    doubleStrike: boolean;
+    doubleHeight: boolean;
+    doubleWidth: boolean;
+    underline: UnderlineMode;
+    rotation: boolean;
+    upsideDown: boolean;
+    reverse: boolean;
+    codeTable: CharacterCodeTable;
+    rightSpacing: number;
+    lineSpacing: number | null;
+    constructor(alignment?: Alignment, font?: Font, emphasized?: boolean, doubleStrike?: boolean, doubleHeight?: boolean, doubleWidth?: boolean, underline?: UnderlineMode, rotation?: boolean, upsideDown?: boolean, reverse?: boolean, codeTable?: CharacterCodeTable, rightSpacing?: number, lineSpacing?: number | null);
+    /** Erstellt eine unabhängige Kopie des Zustands. */
+    clone(): PrintState;
+}
+
+/**
+ * Builder-Pattern: Fluenter, zustandsbehafteter Bon-Aufbau.
+ *
+ * Baut intern eine CommandSequence auf. Jede Methode gibt `this` zurück
+ * (Fluent Interface). Zustand kann via save()/restore() (Memento) gespeichert
+ * und wiederhergestellt werden. Eigene Commands können via add() eingebettet
+ * werden (Erweiterbarkeit).
+ *
+ * Auch ableitbar: Unterklassen können eigene, domänenspezifische Methoden
+ * hinzufügen (z.B. `receipt.cashierLine(name)`).
+ * @category Builder
+ */
+
+declare class ReceiptBuilder {
+    protected readonly sequence: CommandSequence;
+    protected state: PrintState;
+    private readonly mementoStack;
+    /** Speichert den aktuellen Formatierungszustand auf dem Stack. */
+    save(): this;
+    /** Stellt den zuletzt gespeicherten Zustand wieder her und sendet die nötigen Befehle. */
+    restore(): this;
+    private _syncState;
+    /** Fügt ein beliebiges Command hinzu (Erweiterungspunkt). */
+    add(cmd: Command): this;
+    /**
+     * Wendet eine wiederverwendbare Funktion auf den Builder an.
+     * Ermöglicht komposierbare, parametrisierbare Bon-Bausteine.
+     *
+     * @example builder.use(centerBold("KOPFZEILE"))
+     */
+    use(fn: (builder: this) => void): this;
+    initialize(): this;
+    align(a: Alignment): this;
+    left(): this;
+    center(): this;
+    right(): this;
+    font(f: Font): this;
+    bold(on?: boolean): this;
+    doubleStrike(on?: boolean): this;
+    underline(mode?: UnderlineMode): this;
+    doubleHeight(on?: boolean): this;
+    doubleWidth(on?: boolean): this;
+    rotate(on?: boolean): this;
+    upsideDown(on?: boolean): this;
+    reverse(on?: boolean): this;
+    codeTable(table: CharacterCodeTable): this;
+    rightSpacing(n: number): this;
+    lineSpacing(n: number): this;
+    defaultLineSpacing(): this;
+    /** Fügt Text direkt als Bytes ein. */
+    text(str: string): this;
+    /** Text mit anschließendem Zeilenvorschub. */
+    textLine(str: string): this;
+    /** Zeilenvorschub (LF). */
+    feed(): this;
+    /** Mehrere Zeilen vorschub. */
+    feedLines(n: number): this;
+    /** Papiervorsschub in Dots. */
+    feedDots(n: number): this;
+    /** Trennlinie aus dem Zeichen `char` (Standard: `-`), `cols` Mal. */
+    divider(char?: string, cols?: number): this;
+    absolutePosition(n: number): this;
+    relativePosition(n: number): this;
+    leftMargin(n: number): this;
+    hriPosition(pos: HriPosition): this;
+    hriFont(font: HriFont): this;
+    barcodeHeight(n: number): this;
+    barcode(system: BarcodeSystem, data: string | Uint8Array, strategy?: BarcodeEncodingStrategy): this;
+    qrCode(data: string | Uint8Array, options?: QrCodeOptions): this;
+    cut(mode?: CutMode, feedDots?: number): this;
+    openDrawer(pin?: DrawerPin, t1?: number, t2?: number): this;
+    rasterImage(mode: RasterMode, xL: number, xH: number, yL: number, yH: number, data: Uint8Array): this;
+    beep(count?: number, duration?: number): this;
+    /** Gibt die aufgebaute CommandSequence zurück. */
+    build(): CommandSequence;
+    /** Kodiert alles zu einem einzelnen Uint8Array. */
+    encode(): Uint8Array;
+}
+
+/**
+ * Strategy-Interface für Dithering-Algorithmen.
+ *
+ * Erhält ein Grauwert-Array (0=schwarz, 255=weiß) und liefert
+ * ein Schwellwert-Array (true=Dot drucken, false=leer).
+ * @category Bilder & Dithering
+ */
+interface DitherStrategy {
+    readonly name: string;
+    /**
+     * Wendet das Dithering an.
+     * @param gray   Grauwert-Pixel-Array, row-major, Werte 0–255
+     * @param width  Breite in Pixeln
+     * @param height Höhe in Pixeln
+     * @returns      Boolean-Array mit gleichem Layout (true = Punkt drucken)
+     */
+    dither(gray: Uint8Array, width: number, height: number): Uint8Array;
+}
+
+/**
+ * Spezialisierter Builder für strukturierte Kassenbons / Rechnungen.
+ *
+ * Erweitert ReceiptBuilder um fertige Blöcke:
+ *   - Logo (async, Bilddatei → Rasterdruck)
+ *   - Adressblock (Firma, Straße, PLZ Ort, Zusatzzeile)
+ *   - Artikel-Tabelle mit Menge und Sub-Zeilen (Rabatte, Notizen)
+ *   - Summenzeilen (Gesamt, MwSt, …)
+ *   - QR-Code (geerbt)
+ *   - Fußzeile
+ *
+ * Mengen-Anzeige (quantityDisplay):
+ *   "inline"   → Menge wird in den Artikelnamen eingebettet: "2x Schnitzel"
+ *   "separate" → Menge erscheint als eigene Zeile darunter: "   2x à 12.50 EUR"
+ *
+ * @example
+ *   const b = new InvoiceBuilder({ quantityDisplay: "separate" });
+ *   await b.logo("./logo.png");
+ *   b.address({ company: "Muster GmbH", street: "Hauptstr. 1",
+ *               postalCity: "1010 Wien", extra: "UID: ATU12345678" })
+ *    .separator()
+ *    .itemsHeader()
+ *    .separator()
+ *    .item(1, "Schnitzel", "25.00 EUR", {
+ *      qty: 2, unitPrice: "12.50 EUR",
+ *      subLines: [{ label: "- Treuerabatt 10%", value: "-2.50 EUR" }],
+ *    })
+ *    .item(2, "Cola", "2.80 EUR")
+ *    .separator()
+ *    .total("GESAMT:", "27.80 EUR")
+ *    .taxLine("MwSt 20%:", " 4.63 EUR")
+ *    .qrCode("https://example.at/bon/42")
+ *    .footer(["Danke fuer Ihren Besuch!", "www.example.at"])
+ *    .cut();
+ *   await printer.print(b);
+ * @category Builder
+ */
+
+/**
+ * Wo die Mengenzahl angezeigt wird.
+ * @category Builder
+ */
+type QuantityDisplay = "inline" | "separate";
+/**
+ * Optionen für den InvoiceBuilder.
+ * @category Builder
+ */
+interface InvoiceBuilderOptions {
+    /** Druckbreite in Dots. Standard: 576 (80 mm / 203 dpi) */
+    printWidthDots?: number;
+    /**
+     * Zeichen pro Zeile (Font A).
+     * Standard: 48 (80 mm-Papier).  Für 58 mm-Papier: 32.
+     */
+    charsPerLine?: number;
+    /**
+     * Standard-Anzeige für Mengen.
+     * "inline"   → "2x Schnitzel" in derselben Zeile  (Standard)
+     * "separate" → eigene Zeile darunter: "   2x à 12.50 EUR"
+     */
+    quantityDisplay?: QuantityDisplay;
+}
+/**
+ * Adressblock für den InvoiceBuilder.
+ * @category Builder
+ */
+interface InvoiceAddress {
+    /** Firmenname — wird fett gedruckt */
+    company: string;
+    /** Straße + Hausnummer */
+    street: string;
+    /** PLZ und Ort, z. B. "1010 Wien" */
+    postalCity: string;
+    /** Optionale 4. Zeile, z. B. UID-Nummer oder Telefon */
+    extra?: string;
+}
+/**
+ * Eine Subzeile unterhalb eines Artikels (Rabatt, Notiz, …).
+ * @category Builder
+ */
+interface SubLine {
+    /** Beschriftung, z. B. "- Treuerabatt 10%" oder "Anmerkung: ohne Sauce" */
+    label: string;
+    /** Optionaler rechtsbündiger Wert, z. B. "-1.25 EUR" */
+    value?: string;
+}
+/**
+ * Optionen für eine Artikelzeile im InvoiceBuilder.
+ * @category Builder
+ */
+interface ItemOptions {
+    /** Anzahl der gekauften Einheiten. Standard: 1 (keine Mengenanzeige). */
+    qty?: number;
+    /**
+     * Einzelpreis pro Stück für den "separate"-Modus, z. B. "12.50 EUR".
+     * Wird nur bei quantityDisplay === "separate" und qty > 1 angezeigt.
+     */
+    unitPrice?: string;
+    /**
+     * Überschreibt den globalen quantityDisplay für diesen Artikel.
+     * Wenn nicht gesetzt, gilt die Option aus InvoiceBuilderOptions.
+     */
+    qtyDisplay?: QuantityDisplay;
+    /** Subzeilen (Rabatte, Notizen) die eingerückt unter dem Artikel erscheinen. */
+    subLines?: SubLine[];
+}
+declare class InvoiceBuilder extends ReceiptBuilder {
+    readonly cols: number;
+    private readonly printWidthDots;
+    private readonly defaultQtyDisplay;
+    /** Einrückung für Subzeilen und "separate"-Mengenzeilen (entspricht der Namens-Spalte). */
+    private readonly subIndent;
+    constructor(options?: InvoiceBuilderOptions);
+    /**
+     * Lädt eine Bilddatei, kodiert sie als ESC/POS-Rasterbild und druckt sie
+     * zentriert. Muss mit await aufgerufen werden.
+     */
+    logo(filePath: string, dither?: DitherStrategy): Promise<this>;
+    /**
+     * Druckt einen 3–4-zeiligen Adressblock zentriert.
+     * Zeile 1: Firmenname (fett)
+     * Zeile 2: Straße
+     * Zeile 3: PLZ Ort
+     * Zeile 4: extra (optional)
+     */
+    address(addr: InvoiceAddress): this;
+    /** Trennlinie über die volle Bon-Breite. */
+    separator(char?: string): this;
+    /** Spalten-Kopfzeile: Nr  Artikel  Preis */
+    itemsHeader(): this;
+    /**
+     * Eine Artikel-Zeile mit optionaler Menge und Subzeilen.
+     *
+     * Inline-Modus  (Standard / qtyDisplay: "inline"):
+     *   " 1  2x Schnitzel              25.00 EUR"
+     *
+     * Separate-Modus (qtyDisplay: "separate"):
+     *   " 1  Schnitzel                 25.00 EUR"
+     *   "    2x à 12.50 EUR"
+     *
+     * Subzeilen (immer eingerückt):
+     *   "    - Treuerabatt 10%         -2.50 EUR"
+     *   "    Anmerkung: ohne Sauce"
+     */
+    item(pos: number | string, name: string, price: string, opts?: ItemOptions): this;
+    /** Gesamtbetrag — fett gedruckt. */
+    total(label: string, value: string): this;
+    /** Steuerzusatzzeile, Rabattzeile o. Ä. — normal gedruckt. */
+    taxLine(label: string, value: string): this;
+    /**
+     * Druckt eine Fußzeile mit optionaler Trennlinie davor.
+     * Alle Zeilen werden zentriert ausgegeben.
+     */
+    footer(lines: string[], { withSeparator }?: {
+        withSeparator?: boolean;
+    }): this;
+    /** Hauptzeile: "Nr  Name...........Preis" */
+    private _mainRow;
+    /** Subzeile: eingerückt, mit optionalem rechtsbündigen Wert. */
+    private _subRow;
+    /** Zweispaltige Zeile ohne Positions-Nummer (Summen, Steuer). */
+    private _twoCol;
+}
+
+/**
+ * Memento-Pattern: Speichert eine unveränderliche Momentaufnahme
+ * des PrintState für spätere Wiederherstellung.
+ * @category Builder
+ */
+declare class StateMemento {
+    private readonly snapshot;
+    constructor(state: PrintState);
+    /** Gibt die gespeicherte Zustandskopie zurück. */
+    getSnapshot(): PrintState;
+}
+
+/**
+ * Observer-Pattern: PrinterObserver-Interface und Event-Typen.
+ *
+ * Implementierungen registrieren sich am Printer (Subject) und erhalten
+ * typisierte Events über Zustands- und Datentransfer-Ereignisse.
+ * @category Drucker
+ */
+type PrinterEventType = "written" | "opened" | "closed" | "error" | "statusChanged" | "paperOut" | "coverOpen";
+/**
+ * Basis-Event des Druckers.
+ * @category Drucker
+ */
+interface PrinterEvent {
+    type: PrinterEventType;
+    timestamp: Date;
+    data?: unknown;
+}
+/**
+ * Observer-Interface für Printer-Events.
+ * @category Drucker
+ */
+interface PrinterObserver {
+    /** Wird bei jedem Printer-Event aufgerufen. */
+    onEvent(event: PrinterEvent): void;
+}
+
+/**
+ * Wiederverwendbare Observer-Basis (Subject-Rolle).
+ * Wird von Printer und AbstractConnection geerbt.
+ * @category Drucker
+ */
+declare class Subject {
+    private readonly observers;
+    /** Registriert einen Observer. Gibt eine Abmelde-Funktion zurück. */
+    subscribe(observer: PrinterObserver): () => void;
+    /** Entfernt einen Observer. */
+    unsubscribe(observer: PrinterObserver): void;
+    /** Benachrichtigt alle Observer. */
+    protected notify(event: PrinterEvent): void;
+    protected makeEvent(type: PrinterEventType, data?: unknown): PrinterEvent;
+}
+
+/**
+ * Connection-Interface (Adapter-Pattern).
+ *
+ * Alle Transport-Implementierungen (TCP, USB, Serial, In-Memory, ...)
+ * erfüllen dieses Interface. Konsumenten können eigene Verbindungen
+ * implementieren und im Printer verwenden (Erweiterbarkeit).
+ * @category Verbindung
+ */
+interface Connection {
+    /** Verbindung aufbauen. */
+    open(): Promise<void>;
+    /** Bytes an den Drucker senden. */
+    write(data: Uint8Array): Promise<void>;
+    /**
+     * Optionales Lesen (für Status-Antworten des Druckers).
+     * Nicht alle Transporte unterstützen bidirektionale Kommunikation.
+     */
+    read?(timeout?: number): Promise<Uint8Array>;
+    /** Verbindung schließen. */
+    close(): Promise<void>;
+    /** Gibt an, ob die Verbindung aktuell geöffnet ist. */
+    readonly isOpen: boolean;
+}
+
+/**
+ * Facade + Invoker.
+ *
+ * Kapselt ReceiptBuilder + CommandFactory + Connection + ImageEncoder
+ * hinter einer einfachen API. Ist gleichzeitig Subject (Observer-Pattern):
+ * registrierte Observer erhalten Events über geschriebene Bytes, Fehler etc.
+ * @category Drucker
+ */
+
+declare class Printer extends Subject {
+    private readonly connection;
+    constructor(connection: Connection);
+    /** Erstellt einen neuen ReceiptBuilder (Builder-Einstiegspunkt). */
+    createBuilder(): ReceiptBuilder;
+    /**
+     * Sendet eine bereits kodierte Byte-Folge an die Connection.
+     * Feuert 'written'- bzw. 'error'-Events an Observer.
+     */
+    write(bytes: Uint8Array): Promise<void>;
+    /** Kodiert einen Command und sendet ihn. */
+    send(cmd: Command): Promise<void>;
+    /**
+     * Sendet einen kompletten ReceiptBuilder-Inhalt an den Drucker.
+     * Kurzform: printer.print(builder)
+     */
+    print(builder: ReceiptBuilder | CommandSequence): Promise<void>;
+    /** Öffnet die Connection und feuert 'opened'. */
+    open(): Promise<void>;
+    /** Schließt die Connection und feuert 'closed'. */
+    close(): Promise<void>;
+    initialize(): Promise<void>;
+    cut(feedDots?: number): Promise<void>;
+    openDrawer(pin?: number, t1?: number, t2?: number): Promise<void>;
+}
+
+/**
+ * DLE EOT n=1 — Druckerstatus.
+ * Bit-Tabelle gemäß Handbuch.
+ * @category Status
+ */
+declare class PrinterStatus {
+    private readonly byte;
+    constructor(byte: number);
+    get rawByte(): number;
+    /** Bit 2: 0=Kassenschublade offen, 1=geschlossen */
+    get isCashDrawerClosed(): boolean;
+    /** Bit 3: 1=Offline */
+    get isOffline(): boolean;
+    get isOnline(): boolean;
+}
+
+/**
+ * DLE EOT n=2 — Offline-Status.
+ * @category Status
+ */
+declare class OfflineStatus {
+    private readonly byte;
+    constructor(byte: number);
+    get rawByte(): number;
+    /** Bit 2: Deckel offen */
+    get isCoverOpen(): boolean;
+    /** Bit 3: Papier wird über FEED-Taste vorgeschoben */
+    get isPaperBeingFed(): boolean;
+    /** Bit 5: Druck wird wegen Papierende gestoppt */
+    get isPaperEndStop(): boolean;
+    /** Bit 6: Fehler aufgetreten */
+    get hasError(): boolean;
+}
+
+/**
+ * DLE EOT n=3 — Fehlerstatus.
+ * @category Status
+ */
+declare class ErrorStatus {
+    private readonly byte;
+    constructor(byte: number);
+    get rawByte(): number;
+    /** Bit 3: Auto-Schnitt-Fehler */
+    get hasAutoCutterError(): boolean;
+    /** Bit 5: Nicht behebbarer Fehler */
+    get hasUnrecoverableError(): boolean;
+    /** Bit 6: Automatisch behebbarer Fehler */
+    get hasAutoRecoverableError(): boolean;
+    get hasAnyError(): boolean;
+}
+
+/**
+ * DLE EOT n=4 / GS r n=1,49 — Papiersensor-Status.
+ * @category Status
+ */
+declare class PaperSensorStatus {
+    private readonly byte;
+    constructor(byte: number);
+    get rawByte(): number;
+    /** Bits 2,3: Papier fast aufgebraucht (Near-End) */
+    get isPaperNearEnd(): boolean;
+    /** Bits 5,6 (DLE EOT n=4): Papier leer */
+    get isPaperEnd(): boolean;
+    /** Bits 0,1 (GS r): Papier Near-End */
+    get isNearEndGsr(): boolean;
+    /** Bits 2,3 (GS r): Papier leer */
+    get isPaperEndGsr(): boolean;
+    get isPaperPresent(): boolean;
+}
+
+/**
+ * GS r n=2,50 — Schubladen-Status.
+ * @category Status
+ */
+declare class DrawerStatus {
+    private readonly byte;
+    constructor(byte: number);
+    get rawByte(): number;
+    /** Bit 0: 0=Schublade offen, 1=Schublade geschlossen */
+    get isDrawerClosed(): boolean;
+    get isDrawerOpen(): boolean;
+}
+
+/**
+ * Factory Method Pattern: Dekodiert ein Roh-Byte in das passende Status-Objekt.
+ * @category Status
+ */
+
+/**
+ * Status-Typen entsprechend DLE EOT n=1..4
+ * @category Status
+ */
+type StatusType = "printer" | "offline" | "error" | "paper" | "drawer";
+/**
+ * Union-Typ aller Status-Objekte.
+ * @category Status
+ */
+type AnyStatus = PrinterStatus | OfflineStatus | ErrorStatus | PaperSensorStatus | DrawerStatus;
+declare class StatusDecoder {
+    /** Dekodiert DLE EOT n=1 → PrinterStatus */
+    static decodePrinterStatus(byte: number): PrinterStatus;
+    /** Dekodiert DLE EOT n=2 → OfflineStatus */
+    static decodeOfflineStatus(byte: number): OfflineStatus;
+    /** Dekodiert DLE EOT n=3 → ErrorStatus */
+    static decodeErrorStatus(byte: number): ErrorStatus;
+    /** Dekodiert DLE EOT n=4 → PaperSensorStatus */
+    static decodePaperSensorStatus(byte: number): PaperSensorStatus;
+    /** Dekodiert GS r n=2,50 → DrawerStatus */
+    static decodeDrawerStatus(byte: number): DrawerStatus;
+    /**
+     * Factory Method: Erstellt den passenden Status-Typ anhand des Typ-Bezeichners.
+     * Entspricht DLE EOT n-Parametern.
+     */
+    static decode(type: StatusType, byte: number): AnyStatus;
+    /**
+     * Konvertiert DLE EOT n (1–4) zum StatusType.
+     */
+    static typeFromN(n: 1 | 2 | 3 | 4): StatusType;
+}
+
+/**
+ * Template Method + Subject (Observer) für Transport-Adapter.
+ *
+ * Definiert den Ablauf von open/write/close; Unterklassen implementieren
+ * die konkreten Operationen (_open, _write, _close).
+ * Feuert write-Events an registrierte Observer.
+ * @category Verbindung
+ */
+declare abstract class AbstractConnection extends Subject implements Connection {
+    protected _isOpen: boolean;
+    get isOpen(): boolean;
+    /** Template Method: Validierung → _open → Event */
+    open(): Promise<void>;
+    /** Template Method: Validierung → _write → Event */
+    write(data: Uint8Array): Promise<void>;
+    /** Template Method: _close → Event */
+    close(): Promise<void>;
+    protected abstract _open(): Promise<void>;
+    protected abstract _write(data: Uint8Array): Promise<void>;
+    protected abstract _close(): Promise<void>;
+}
+
+/**
+ * In-Memory-Adapter — sammelt alle geschriebenen Bytes.
+ * Perfekt für Tests und Dry-Run ohne Hardware.
+ * Implementiert das Adapter-Pattern gegenüber dem Connection-Interface.
+ * @category Verbindung
+ */
+declare class BufferConnection extends AbstractConnection {
+    private readonly buffers;
+    protected _open(): Promise<void>;
+    protected _write(data: Uint8Array): Promise<void>;
+    protected _close(): Promise<void>;
+    /**
+     * Gibt alle bisher geschriebenen Bytes als einzelnes Uint8Array zurück.
+     */
+    getBuffer(): Uint8Array;
+    /**
+     * Gibt die Liste aller einzelnen Schreiboperationen zurück.
+     */
+    getWrites(): readonly Uint8Array[];
+    /** Löscht den Buffer. */
+    clear(): void;
+    /** Liest vom Buffer (letzter Write, optionaler Timeout). */
+    read(_timeout?: number): Promise<Uint8Array>;
+}
+
+/**
+ * TCP/Netzwerk-Adapter (Adapter-Pattern).
+ * Verbindet via TCP — typisch für Ethernet-POS-Drucker.
+ * Standard-Port: 9100
+ * @category Verbindung
+ */
+declare class NetworkConnection extends AbstractConnection {
+    private readonly host;
+    private readonly port;
+    private readonly connectTimeout;
+    private socket;
+    constructor(host: string, port?: number, connectTimeout?: number);
+    protected _open(): Promise<void>;
+    protected _write(data: Uint8Array): Promise<void>;
+    protected _close(): Promise<void>;
+    read(timeout?: number): Promise<Uint8Array>;
+}
+
+/**
+ * Optionaler USB-Adapter (Adapter-Pattern).
+ * Verwendet lazy require('usb') — nur verfügbar wenn `usb` installiert ist.
+ * Schlägt mit einer hilfreichen Fehlermeldung fehl wenn das Package fehlt.
+ * @category Verbindung
+ */
+declare class UsbConnection extends AbstractConnection {
+    private readonly vendorId;
+    private readonly productId;
+    private device;
+    constructor(vendorId: number, productId: number);
+    protected _open(): Promise<void>;
+    protected _write(_data: Uint8Array): Promise<void>;
+    protected _close(): Promise<void>;
+}
+
+/**
+ * Optionaler Serial/RS-232-Adapter (Adapter-Pattern).
+ * Verwendet lazy require('serialport').
+ * @category Verbindung
+ */
+declare class SerialConnection extends AbstractConnection {
+    private readonly path;
+    private readonly baudRate;
+    private port;
+    constructor(path: string, baudRate?: number);
+    protected _open(): Promise<void>;
+    protected _write(data: Uint8Array): Promise<void>;
+    protected _close(): Promise<void>;
+}
+
+/**
+ * Factory-Pattern: Erzeugt Connection-Adapter nach Typ oder URL.
+ * Konsumenten können eigene Adapter-Typen registrieren (Erweiterbarkeit).
+ * @category Verbindung
+ */
+
+/**
+ * Optionen für eine Connection-Fabrik.
+ * @category Verbindung
+ */
+type ConnectionOptions = Record<string, unknown>;
+/**
+ * Funktion die eine Connection erzeugt.
+ * @category Verbindung
+ */
+type ConnectionCreator = (options: ConnectionOptions) => Connection;
+declare class ConnectionFactory {
+    private static readonly creators;
+    /**
+     * Registriert einen eigenen Connection-Typ (Erweiterbarkeit).
+     * @example ConnectionFactory.register("bluetooth", opts => new BluetoothConnection(opts.address))
+     */
+    static register(type: string, creator: ConnectionCreator): void;
+    /**
+     * Erstellt eine Connection des gewünschten Typs.
+     * @throws Error wenn der Typ nicht registriert ist.
+     */
+    static create(type: string, options?: ConnectionOptions): Connection;
+    /** Erstellt eine In-Memory-Connection (für Tests). */
+    static createBuffer(): BufferConnection;
+    /** Erstellt eine TCP-Connection. */
+    static createNetwork(host: string, port?: number): NetworkConnection;
+}
+
+/**
+ * Bild-Encoder: Lädt ein Bild via jimp, skaliert es auf Druckerbreite,
+ * wandelt es in Grauwerte um, dithtert es und erzeugt ESC/POS-Raster-Bytes.
+ *
+ * Konfigurierbar mit eigener DitherStrategy (Strategy-Pattern).
+ * @category Bilder & Dithering
+ */
+
+/**
+ * Optionen für den ImageEncoder.
+ * @category Bilder & Dithering
+ */
+interface ImageEncodeOptions {
+    /** Breite in Dots (Standard: 576 für 80mm / 200dpi) */
+    printWidthDots?: number;
+    /** Dither-Strategie (Standard: Floyd–Steinberg) */
+    dither?: DitherStrategy;
+}
+/**
+ * Ergebnis einer Raster-Bild-Kodierung.
+ * @category Bilder & Dithering
+ */
+interface RasterImageResult {
+    /** Raster-Bytes für GS v 0 */
+    data: Uint8Array;
+    /** Breite in Bytes (xL + xH×256) */
+    widthBytes: number;
+    /** Höhe in Dots */
+    heightDots: number;
+    /** nL, nH, yL, yH für den GS v 0 Befehl */
+    xL: number;
+    xH: number;
+    yL: number;
+    yH: number;
+}
+declare class ImageEncoder {
+    private readonly dither;
+    private readonly printWidthDots;
+    constructor(options?: ImageEncodeOptions);
+    /**
+     * Lädt eine Bilddatei (PNG, JPG, BMP, ...) und konvertiert sie in
+     * ESC/POS Raster-Bytes für GS v 0.
+     */
+    encodeFile(filePath: string): Promise<RasterImageResult>;
+    /**
+     * Verarbeitet einen Uint8Array (Bild-Buffer) direkt.
+     */
+    encodeBuffer(buffer: Uint8Array): Promise<RasterImageResult>;
+    private _processImage;
+}
+
+/**
+ * Einfache Schwellwert-Strategie.
+ * Pixel unter dem Schwellwert werden als Druckpunkt gewertet.
+ * @category Bilder & Dithering
+ */
+declare class ThresholdDither implements DitherStrategy {
+    private readonly threshold;
+    readonly name = "Threshold";
+    constructor(threshold?: number);
+    dither(gray: Uint8Array, _width: number, _height: number): Uint8Array;
+}
+
+/**
+ * Floyd–Steinberg Dithering.
+ * Verteilt Quantisierungsfehler auf benachbarte Pixel für feinere Übergänge.
+ * @category Bilder & Dithering
+ */
+declare class FloydSteinbergDither implements DitherStrategy {
+    readonly name = "FloydSteinberg";
+    dither(gray: Uint8Array, width: number, height: number): Uint8Array;
+}
+
+export { AbstractCommand, AbstractConnection, Alignment, type AnyStatus, type BarcodeEncodingStrategy, BarcodeSystem, BarcodeWidth, BeepAndFlashCommand, BeepCommand, BitImageMode, BufferConnection, ByteBuilder, CAN, CR, CancelKanjiModeCommand, CancelPageDataCommand, CarriageReturnCommand, CharacterCodeTable, CodabarStrategy, Code128Strategy, Code39Strategy, type Command, CommandFactory, type CommandRegistration, CommandRegistry, CommandSequence, type Connection, type ConnectionCreator, ConnectionFactory, type ConnectionOptions, CutCommand, CutMode, DC4, DLE, DefineDownloadedBitImageCommand, DefineKanjiCommand, DefineNvBitImageCommand, type DitherStrategy, DrawerPin, DrawerStatus, ENQ, EOT, ESC, EnableAsbCommand, ErrorStatus, ExecuteMacroCommand, FF, FS, FloydSteinbergDither, Font, FormFeedCommand, GS, GeneratePulseCommand, GeneratePulseRealtimeCommand, HT, HorizontalTabCommand, HriFont, HriPosition, type ImageEncodeOptions, ImageEncoder, InitializeCommand, InternationalCharacterSet, type InvoiceAddress, InvoiceBuilder, type InvoiceBuilderOptions, type ItemOptions, ItfStrategy, LF, LineFeedCommand, MacroStartEndCommand, NUL, NetworkConnection, type NvBitImageData, OfflineStatus, PaperSensorStatus, PrintAndFeedLinesCommand, PrintAndFeedPaperCommand, PrintBarcodeCommand, PrintDirection, PrintDownloadedBitImageCommand, type PrintModesOptions, PrintNvBitImageCommand, PrintQrCodeCommand, PrintRasterBitImageCommand, PrintState, Printer, type PrinterEvent, type PrinterEventType, type PrinterObserver, PrinterStatus, QrCodeErrorCorrection, type QrCodeOptions, type QuantityDisplay, type RasterImageResult, RasterMode, RawCommand, RealtimeRequestCommand, ReceiptBuilder, SP, SelectCharacterCodeTableCommand, SelectCharacterFontCommand, SelectCharacterSizeCommand, SelectInternationalCharSetCommand, SelectKanjiModeCommand, SelectPageModeCommand, SelectPrintDirectionCommand, SelectPrintModesCommand, SelectStandardModeCommand, SerialConnection, SetAbsolutePositionCommand, SetBarcodeHeightCommand, SetBarcodeWidthCommand, SetDefaultLineSpacingCommand, SetEmphasizedCommand, SetHorizontalTabPositionsCommand, SetHriFontCommand, SetHriPositionCommand, SetJustificationCommand, SetKanjiPrintModeCommand, SetKanjiQuadrupleCommand, SetKanjiSpacingCommand, SetKanjiUnderlineCommand, SetLeftMarginCommand, SetLineSpacingCommand, SetPrintingAreaPageModeCommand, SetPrintingAreaWidthCommand, SetRelativePositionCommand, SetReverseCommand, SetRotationCommand, SetUnderlineCommand, SetUpsideDownCommand, SimpleNumericBarcodeStrategy, StateMemento, StatusDecoder, type StatusType, type SubLine, Subject, ThresholdDither, TransmitRealtimeStatusCommand, TransmitStatusCommand, UnderlineMode, UsbConnection, fromUint16LE, toComplement16, toUint16LE };