/**
 * Bondrucker am USB-Kabel ueber WebUSB (Chrome/Edge auf Windows, macOS,
 * Android, ChromeOS -- kein Safari, kein iPad). Der Browser bekommt das Geraet
 * nur, wenn kein Treiber es haelt (Windows: ggf. WinUSB statt Epson-Treiber).
 * Die Bytes sind dieselben wie am Bluetooth-Drucker: ESC/POS aus
 * `escPosLayoutBytes`, exakt die Rasterzeilen.
 *
 * Alles hier ist strukturell getippt (kein `USBDevice`-DOM-Typ noetig), damit
 * es ohne Browser testbar bleibt und in jeder App gleich laeuft.
 */
export interface UsbEndpointLike {
    direction: string;
    type: string;
    endpointNumber: number;
}
export interface UsbAlternateLike {
    alternateSetting: number;
    interfaceClass: number;
    endpoints: UsbEndpointLike[];
}
export interface UsbInterfaceLike {
    interfaceNumber: number;
    alternates: UsbAlternateLike[];
}
export interface UsbConfigurationLike {
    configurationValue: number;
    interfaces: UsbInterfaceLike[];
}
export interface UsbTransferOutResultLike {
    status: string;
    bytesWritten: number;
}
export interface UsbWriterLike {
    transferOut: (endpointNumber: number, data: Uint8Array) => Promise<UsbTransferOutResultLike>;
}
export interface UsbIdentityLike {
    vendorId: number;
    productId: number;
    serialNumber?: string | null;
}
/** Das, was ein WebUSB-`USBDevice` bietet -- soweit hier gebraucht. */
export interface UsbDeviceLike extends UsbWriterLike, UsbIdentityLike {
    productName?: string | null;
    manufacturerName?: string | null;
    opened: boolean;
    configuration: UsbConfigurationLike | null;
    open: () => Promise<void>;
    close: () => Promise<void>;
    selectConfiguration: (value: number) => Promise<void>;
    claimInterface: (interfaceNumber: number) => Promise<void>;
    releaseInterface: (interfaceNumber: number) => Promise<void>;
    selectAlternateInterface: (interfaceNumber: number, alternateSetting: number) => Promise<void>;
}
export interface UsbPrinterEndpoint {
    interfaceNumber: number;
    alternateSetting: number;
    endpointNumber: number;
}
export interface UsbPrinterConnection {
    device: UsbDeviceLike;
    /** "Hersteller Produkt", z. B. "EPSON TM-T20III". */
    name: string;
    interfaceNumber: number;
    endpointNumber: number;
    /** Kennung fuers Wiederfinden ueber `navigator.usb.getDevices()`. */
    key: string;
}
/** Epson Seiko USB-Vendor-ID -- als Vorfilter im Geraetedialog. */
export declare const USB_VENDOR_EPSON = 1208;
/** USB-Geraeteklasse "Drucker". */
export declare const USB_CLASS_PRINTER = 7;
/** Kennung `vvvv:pppp:serial` -- stabil ueber Neustarts, wenn der Drucker eine Seriennummer meldet. */
export declare function usbDeviceKey(d: UsbIdentityLike): string;
/** Druckerschnittstelle (Klasse 7) bevorzugt, sonst herstellerspezifisch (0xFF), sonst irgendein Bulk-OUT. */
export declare function usbFindPrinterEndpoint(d: {
    configuration: UsbConfigurationLike | null;
}): UsbPrinterEndpoint | null;
/**
 * Ein USB-Schritt kam nicht innerhalb der Frist zurueck. Anders als bei einem
 * HTTP-Aufruf (siehe `receipt/epos.ts`, `EposConnectionError`) kennt WebUSB
 * fuer diese Methoden kein Abbruchsignal -- der zugrunde liegende Transfer
 * kann am Geraet WEITERLAUFEN, auch nachdem dieser Fehler geworfen wurde. Was
 * hier begrenzt wird, ist NUR das Warten dieses Aufrufers, nicht der Transfer
 * selbst. Dieselbe ehrliche Einschraenkung wie beim Dart-Zwilling
 * `HpsPayments` (`_abortBudget`-Kommentar): ein weicher Zeitablauf ist besser
 * als gar keiner, aber kein echtes Abbrechen.
 */
export declare class UsbTimeoutError extends Error {
    readonly name = "UsbTimeoutError";
    readonly step: string;
    readonly timeoutMs: number;
    constructor(step: string, timeoutMs: number);
}
/**
 * Bytes blockweise an den OUT-Endpunkt; liefert die geschriebene Gesamtzahl,
 * wirft bei Fehlstatus. [timeoutMs] gilt JE Block, nicht fuer den gesamten
 * Druckauftrag -- ein grosser Beleg darf laenger brauchen, ein EINZELNER
 * haengender Block soll trotzdem auffallen, statt den ganzen Aufruf
 * unbegrenzt festzuhalten (genau das Muster, das im Flutter-Paket einen
 * Verkauf angehalten hat).
 */
export declare function usbWriteAll(dev: UsbWriterLike, endpointNumber: number, bytes: Uint8Array, blockSize?: number, timeoutMs?: number): Promise<number>;
/**
 * Geraet oeffnen, Konfiguration waehlen, Druckerschnittstelle belegen. Wirft
 * verstaendlich, wenn ein Treiber das Geraet haelt oder kein Drucker-Endpunkt
 * da ist -- und schliesst das Geraet dann wieder. Jeder Schritt steht unter
 * [timeoutMs] (siehe [UsbTimeoutError]).
 */
export declare function usbConnectPrinter(device: UsbDeviceLike, timeoutMs?: number): Promise<UsbPrinterConnection>;
/** Bytes an eine bestehende Verbindung. */
export declare function usbPrint(c: UsbPrinterConnection, bytes: Uint8Array, timeoutMs?: number): Promise<number>;
/**
 * Schnittstelle freigeben und schliessen; Fehler dabei sind egal (Geraet ist
 * ohnehin weg) -- ABER ein haengender Aufruf ist etwas anderes als ein Fehler:
 * ein `catch` faengt nur eine ABLEHNUNG ab, nicht ein Versprechen, das nie
 * aufloest. Ohne die Frist haette ein steckengebliebenes `releaseInterface`
 * `usbDisconnect` selbst unbegrenzt haengen lassen, trotz des `try/catch`.
 */
export declare function usbDisconnect(c: UsbPrinterConnection, timeoutMs?: number): Promise<void>;