retail-print-kit 0.0.0-stage → 0.2.0

package/dist/core/builder.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpBuilder = void 0;
+exports.parseStyle = parseStyle;
+const bitmap_1 = require("./bitmap");
+const ALIGN = { lt: 'left', ct: 'center', rt: 'right', left: 'left', center: 'center', right: 'right' };
+/**
+ * Records print operations. Method names match the `escpos` package so a host can swap the
+ * device without rewriting its receipt code. Nothing is sent from here; see `Printer`.
+ */
+class OpBuilder {
+    constructor(profile) {
+        this.profile = profile;
+        this.ops = [];
+        this.font = 'a';
+    }
+    /** A copy of the recorded ops. */
+    get operations() {
+        return this.ops.slice();
+    }
+    append(ops) {
+        for (const op of ops)
+            this.ops.push(op);
+        return this;
+    }
+    get columns() {
+        return this.profile.columns[this.font];
+    }
+    push(op) {
+        this.ops.push(op);
+        return this;
+    }
+    raw(bytes) {
+        return this.push({ kind: 'raw', bytes: Uint8Array.from(bytes) });
+    }
+    text(content) {
+        return this.push({ kind: 'text', text: `${content}\n` });
+    }
+    /** Text without a trailing line break. */
+    print(content) {
+        return this.push({ kind: 'text', text: content });
+    }
+    newLine(count = 1) {
+        return this.push({ kind: 'newline', count });
+    }
+    feed(lines = 1) {
+        return this.push({ kind: 'feed', lines });
+    }
+    align(align) {
+        const a = ALIGN[align];
+        if (!a)
+            throw new Error(`retail-print-kit: unknown align "${align}"`);
+        return this.push({ kind: 'align', align: a });
+    }
+    setFont(font) {
+        this.font = font;
+        return this.push({ kind: 'font', font });
+    }
+    size(width, height) {
+        return this.push({ kind: 'size', width, height });
+    }
+    style(style) {
+        const flags = typeof style === 'string' ? parseStyle(style) : style;
+        return this.push({ kind: 'style', style: flags });
+    }
+    lineSpace(dots = null) {
+        return this.push({ kind: 'lineSpacing', dots });
+    }
+    cut(partial = false, feed = 3) {
+        return this.push({ kind: 'cut', partial, feed });
+    }
+    cashdraw(pin = 2) {
+        return this.push({ kind: 'drawer', pin });
+    }
+    beep(times = 1, duration = 1) {
+        return this.push({ kind: 'beep', times, duration });
+    }
+    barcode(data, type = 'CODE128', options = {}) {
+        return this.push({ kind: 'barcode', data, type, options });
+    }
+    /** Native QR where the printer has one, otherwise a bitmap QR. */
+    qr(data, options = {}) {
+        if (this.profile.features.nativeQr || this.profile.set === 'star-graphic')
+            return this.push({ kind: 'qr', data, options });
+        return this.image((0, bitmap_1.qrBitmap)(data, options));
+    }
+    image(bitmap) {
+        return this.push({ kind: 'raster', width: bitmap.width, height: bitmap.height, bits: bitmap.bits });
+    }
+    /** `escpos` name for a QR code; prints a native QR when the profile has one. */
+    qrimage(data, options = {}) {
+        return this.qr(data, options);
+    }
+    drawLine(char = '-') {
+        return this.text(char.repeat(this.columns));
+    }
+    tableCustom(cells, options = {}) {
+        const total = options.width ?? this.columns;
+        const widths = cellWidths(cells, total);
+        const wrap = options.wrap !== false;
+        const lines = cells.map((c, i) => (wrap ? wrapText(c.text ?? '', widths[i]) : [String(c.text ?? '').slice(0, widths[i])]));
+        const rows = Math.max(1, ...lines.map((l) => l.length));
+        for (let r = 0; r < rows; r++) {
+            let line = '';
+            cells.forEach((c, i) => {
+                line += pad(lines[i][r] ?? '', widths[i], c.align ?? 'LEFT');
+            });
+            this.text(line.replace(/\s+$/, ''));
+        }
+        return this;
+    }
+}
+exports.OpBuilder = OpBuilder;
+/** `escpos` style letters: b bold, i italic, u underline, u2 double underline. */
+function parseStyle(style) {
+    if (style === 'normal')
+        return { bold: false, underline: 0, italic: false, invert: false };
+    const s = style.toLowerCase();
+    return {
+        bold: s.includes('b'),
+        italic: s.includes('i'),
+        underline: s.includes('u2') ? 2 : s.includes('u') ? 1 : 0,
+        invert: false,
+    };
+}
+function cellWidths(cells, total) {
+    const fixed = cells.map((c) => (c.width === undefined ? null : c.width > 1 ? Math.floor(c.width) : Math.floor(c.width * total)));
+    const used = fixed.reduce((n, w) => n + (w ?? 0), 0);
+    const free = fixed.filter((w) => w === null).length;
+    const each = free ? Math.floor(Math.max(0, total - used) / free) : 0;
+    const widths = fixed.map((w) => (w === null ? each : w));
+    const sum = widths.reduce((a, b) => a + b, 0);
+    if (sum < total)
+        widths[widths.length - 1] += total - sum;
+    return widths;
+}
+function wrapText(text, width) {
+    if (width <= 0)
+        return [''];
+    const out = [];
+    for (const para of String(text).split('\n')) {
+        let line = '';
+        for (const word of para.split(/\s+/)) {
+            if (!word)
+                continue;
+            if (word.length > width) {
+                if (line)
+                    out.push(line);
+                line = '';
+                for (let i = 0; i < word.length; i += width)
+                    out.push(word.slice(i, i + width));
+                continue;
+            }
+            const next = line ? `${line} ${word}` : word;
+            if (next.length > width) {
+                out.push(line);
+                line = word;
+            }
+            else {
+                line = next;
+            }
+        }
+        out.push(line);
+    }
+    return out.length ? out : [''];
+}
+function pad(text, width, align) {
+    const t = text.slice(0, width);
+    const gap = width - t.length;
+    if (align === 'RIGHT')
+        return ' '.repeat(gap) + t;
+    if (align === 'CENTER') {
+        const left = Math.floor(gap / 2);
+        return ' '.repeat(left) + t + ' '.repeat(gap - left);
+    }
+    return t + ' '.repeat(gap);
+}

package/dist/core/encode.d.ts

@@ -0,0 +1,8 @@
+import { Op } from './ops';
+import { Profile } from '../profiles/types';
+import { Rasterizer } from './rasterizer';
+export interface EncodeContext {
+    /** Used by bitmap-only command sets. Defaults to a canvas-backed rasterizer. */
+    rasterizer?: Rasterizer;
+}
+export declare function encode(ops: Op[], profile: Profile, ctx?: EncodeContext): Buffer;

package/dist/core/encode.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = encode;
+const escpos_encoder_1 = require("./escpos-encoder");
+const star_line_encoder_1 = require("./star-line-encoder");
+const star_graphic_encoder_1 = require("./star-graphic-encoder");
+const rasterizer_1 = require("./rasterizer");
+function encode(ops, profile, ctx = {}) {
+    switch (profile.set) {
+        case 'escpos':
+            return (0, escpos_encoder_1.encodeEscPos)(ops, profile);
+        case 'star-line':
+            return (0, star_line_encoder_1.encodeStarLine)(ops, profile);
+        case 'star-graphic':
+            return (0, star_graphic_encoder_1.encodeStarGraphic)(ops, profile, ctx.rasterizer ?? new rasterizer_1.CanvasRasterizer());
+    }
+}

package/dist/core/escpos-encoder.d.ts

@@ -0,0 +1,4 @@
+import { Op } from './ops';
+import { Profile } from '../profiles/types';
+/** Turns ops into ESC/POS bytes for the given profile. Pure: no I/O, no state across calls. */
+export declare function encodeEscPos(ops: Op[], profile: Profile): Buffer;

package/dist/core/escpos-encoder.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeEscPos = encodeEscPos;
+const iconv_lite_1 = __importDefault(require("iconv-lite"));
+const ESC = 0x1b;
+const GS = 0x1d;
+const LF = 0x0a;
+const BARCODE_CODE = {
+    UPC_A: 65, UPC_E: 66, EAN13: 67, EAN8: 68, CODE39: 69, ITF: 70, CODABAR: 71, CODE128: 73,
+};
+const QR_CORRECTION = { L: 48, M: 49, Q: 50, H: 51 };
+class Bytes {
+    constructor() {
+        this.chunks = [];
+    }
+    push(...parts) {
+        for (const p of parts) {
+            if (typeof p === 'number')
+                this.chunks.push(Buffer.from([p]));
+            else if (Array.isArray(p))
+                this.chunks.push(Buffer.from(p));
+            else
+                this.chunks.push(Buffer.from(p));
+        }
+    }
+    toBuffer() {
+        return Buffer.concat(this.chunks);
+    }
+}
+function clamp(n, lo, hi) {
+    return Math.max(lo, Math.min(hi, Math.floor(n)));
+}
+/** Turns ops into ESC/POS bytes for the given profile. Pure: no I/O, no state across calls. */
+function encodeEscPos(ops, profile) {
+    const out = new Bytes();
+    for (const op of ops) {
+        switch (op.kind) {
+            case 'init':
+                out.push([ESC, 0x40]);
+                if (profile.codepage !== null)
+                    out.push([ESC, 0x74, profile.codepage]);
+                break;
+            case 'text':
+                out.push(iconv_lite_1.default.encode(op.text, profile.encoding));
+                break;
+            case 'newline':
+                for (let i = 0; i < op.count; i++)
+                    out.push(LF);
+                break;
+            case 'feed':
+                out.push([ESC, 0x64, clamp(op.lines, 0, 255)]);
+                break;
+            case 'align':
+                out.push([ESC, 0x61, op.align === 'left' ? 0 : op.align === 'center' ? 1 : 2]);
+                break;
+            case 'font':
+                out.push([ESC, 0x4d, op.font === 'a' ? 0 : 1]);
+                break;
+            case 'size': {
+                const w = clamp(op.width, 1, 8) - 1;
+                const h = clamp(op.height, 1, 8) - 1;
+                out.push([GS, 0x21, (w << 4) | h]);
+                break;
+            }
+            case 'style':
+                out.push([ESC, 0x45, op.style.bold ? 1 : 0]);
+                out.push([ESC, 0x2d, op.style.underline ?? 0]);
+                if (profile.features.italic)
+                    out.push([ESC, 0x34, op.style.italic ? 1 : 0]);
+                if (profile.features.invert)
+                    out.push([GS, 0x42, op.style.invert ? 1 : 0]);
+                break;
+            case 'lineSpacing':
+                if (op.dots === null)
+                    out.push([ESC, 0x32]);
+                else
+                    out.push([ESC, 0x33, clamp(op.dots, 0, 255)]);
+                break;
+            case 'cut': {
+                const feed = clamp(op.feed, 0, 255);
+                if (profile.cut === 'feed-and-cut') {
+                    out.push([GS, 0x56, op.partial ? 66 : 65, feed]);
+                }
+                else {
+                    if (feed > 0)
+                        out.push([ESC, 0x64, feed]);
+                    out.push([GS, 0x56, op.partial ? 1 : 0]);
+                }
+                break;
+            }
+            case 'drawer':
+                out.push([ESC, 0x70, op.pin === 2 ? 0 : 1, clamp(profile.drawer.on, 0, 255), clamp(profile.drawer.off, 0, 255)]);
+                break;
+            case 'beep':
+                if (profile.features.beep)
+                    out.push([ESC, 0x42, clamp(op.times, 1, 9), clamp(op.duration, 1, 9)]);
+                break;
+            case 'barcode': {
+                const o = op.options;
+                out.push([GS, 0x68, clamp(o.height ?? 80, 1, 255)]);
+                out.push([GS, 0x77, clamp(o.width ?? 3, 2, 6)]);
+                const pos = o.position ?? 'below';
+                out.push([GS, 0x48, pos === 'none' ? 0 : pos === 'above' ? 1 : pos === 'below' ? 2 : 3]);
+                out.push([GS, 0x66, (o.font ?? 'a') === 'a' ? 0 : 1]);
+                const data = Buffer.from(op.data, 'ascii');
+                const m = BARCODE_CODE[op.type];
+                if (op.type === 'CODE128') {
+                    const body = Buffer.concat([Buffer.from('{B', 'ascii'), data]);
+                    out.push([GS, 0x6b, m, body.length], body);
+                }
+                else {
+                    out.push([GS, 0x6b, m, data.length], data);
+                }
+                break;
+            }
+            case 'qr':
+                if (!profile.features.nativeQr) {
+                    throw new Error(`retail-print-kit: profile ${profile.id} has no native QR; raster QR is not implemented yet`);
+                }
+                pushQr(out, op.data, op.options);
+                break;
+            case 'raster': {
+                if (!profile.features.raster)
+                    throw new Error(`retail-print-kit: profile ${profile.id} cannot print raster images`);
+                const bytesPerRow = Math.ceil(op.width / 8);
+                out.push([GS, 0x76, 0x30, 0, bytesPerRow & 0xff, bytesPerRow >> 8, op.height & 0xff, op.height >> 8], op.bits);
+                break;
+            }
+            case 'raw':
+                out.push(op.bytes);
+                break;
+        }
+    }
+    return out.toBuffer();
+}
+function pushQr(out, data, options) {
+    const payload = Buffer.from(data, 'utf8');
+    const model = options.model === 1 ? 49 : 50;
+    const size = clamp(options.size ?? 6, 1, 16);
+    const ec = QR_CORRECTION[options.correction ?? 'M'];
+    out.push([GS, 0x28, 0x6b, 4, 0, 49, 65, model, 0]);
+    out.push([GS, 0x28, 0x6b, 3, 0, 49, 67, size]);
+    out.push([GS, 0x28, 0x6b, 3, 0, 49, 69, ec]);
+    const len = payload.length + 3;
+    out.push([GS, 0x28, 0x6b, len & 0xff, len >> 8, 49, 80, 48], payload);
+    out.push([GS, 0x28, 0x6b, 3, 0, 49, 81, 48]);
+}

package/dist/core/identify.d.ts

@@ -0,0 +1,22 @@
+import { Transport } from '../transports/types';
+import { Profile } from '../profiles/types';
+export interface Identity {
+    maker: string | null;
+    model: string | null;
+    firmware: string | null;
+    set: 'escpos' | 'star-line' | 'unknown';
+    profile: Profile | null;
+}
+/** USB vendor ids of receipt printer makers; used before any byte is sent. */
+export declare const USB_VENDORS: Record<number, {
+    maker: string;
+    profile: Profile;
+}>;
+export declare function profileForUsb(vendorId: number, productId?: number): Profile;
+/** Picks a profile from the model string an ESC/POS printer reports with GS I. */
+export declare function profileForModel(maker: string | null, model: string | null): Profile;
+/**
+ * Asks an open transport what is on the other end: ESC/POS `GS I 66/67/65` (maker, model,
+ * firmware), then a Star Line status request when ESC/POS stays silent.
+ */
+export declare function identify(transport: Transport, timeoutMs?: number): Promise<Identity>;

package/dist/core/identify.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USB_VENDORS = void 0;
+exports.profileForUsb = profileForUsb;
+exports.profileForModel = profileForModel;
+exports.identify = identify;
+const profiles_1 = require("../profiles");
+/** USB vendor ids of receipt printer makers; used before any byte is sent. */
+exports.USB_VENDORS = {
+    0x04b8: { maker: 'Epson', profile: profiles_1.epsonTmT88 },
+    0x0519: { maker: 'Star Micronics', profile: profiles_1.starTsp650 },
+    0x1504: { maker: 'Bixolon', profile: profiles_1.genericEscPos },
+    0x1d90: { maker: 'Citizen', profile: profiles_1.genericEscPos },
+};
+function profileForUsb(vendorId, productId) {
+    const v = exports.USB_VENDORS[vendorId];
+    if (!v)
+        return profiles_1.genericEscPos;
+    if (vendorId === 0x0519 && productId !== undefined && productId <= 0x0002)
+        return profiles_1.starTsp100;
+    return v.profile;
+}
+/** Picks a profile from the model string an ESC/POS printer reports with GS I. */
+function profileForModel(maker, model) {
+    const m = (model ?? '').toUpperCase();
+    if (/T88/.test(m))
+        return profiles_1.epsonTmT88;
+    if (/T20/.test(m))
+        return profiles_1.epsonTmT20;
+    if (/M30/.test(m))
+        return profiles_1.epsonTmM30;
+    if (/^EPSON/i.test(maker ?? ''))
+        return profiles_1.epsonTmT88;
+    for (const p of Object.values(profiles_1.profiles))
+        if (m && p.model.toUpperCase().includes(m))
+            return p;
+    return profiles_1.genericEscPos;
+}
+async function ask(transport, bytes, timeoutMs) {
+    if (!transport.read)
+        throw new Error(`retail-print-kit: ${transport.name} transport cannot read from the printer`);
+    await transport.write(Buffer.from(bytes));
+    try {
+        return await transport.read(timeoutMs);
+    }
+    catch {
+        return null;
+    }
+}
+function infoString(reply) {
+    if (!reply || reply[0] !== 0x5f)
+        return null;
+    const end = reply.indexOf(0, 1);
+    return reply.subarray(1, end === -1 ? reply.length : end).toString('ascii').trim() || null;
+}
+/**
+ * Asks an open transport what is on the other end: ESC/POS `GS I 66/67/65` (maker, model,
+ * firmware), then a Star Line status request when ESC/POS stays silent.
+ */
+async function identify(transport, timeoutMs = 1500) {
+    const maker = infoString(await ask(transport, [0x1d, 0x49, 66], timeoutMs));
+    const model = infoString(await ask(transport, [0x1d, 0x49, 67], timeoutMs));
+    if (maker || model) {
+        const firmware = infoString(await ask(transport, [0x1d, 0x49, 65], timeoutMs));
+        return { maker, model, firmware, set: 'escpos', profile: profileForModel(maker, model) };
+    }
+    const star = await ask(transport, [0x1b, 0x06, 0x01], timeoutMs);
+    if (star && star.length >= 2)
+        return { maker: 'Star Micronics', model: null, firmware: null, set: 'star-line', profile: profiles_1.starTsp650 };
+    return { maker: null, model: null, firmware: null, set: 'unknown', profile: null };
+}

package/dist/core/image.d.ts

@@ -0,0 +1,13 @@
+import { Bitmap } from './bitmap';
+export interface LoadImageOptions {
+    /** Target width in dots; the height keeps the aspect ratio. Defaults to the image's own width. */
+    width?: number;
+    /** Floyd-Steinberg dithering (photos, gradients). Default false: plain threshold. */
+    dither?: boolean;
+    threshold?: number;
+}
+/**
+ * Loads a PNG / JPEG / WebP / GIF file or buffer and converts it to a 1-bit bitmap, scaled to
+ * `width` dots. Node only; needs the optional `@napi-rs/canvas` (or `canvas`) package.
+ */
+export declare function loadImage(source: string | Uint8Array, options?: LoadImageOptions): Promise<Bitmap>;

package/dist/core/image.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadImage = loadImage;
+const bitmap_1 = require("./bitmap");
+/**
+ * Loads a PNG / JPEG / WebP / GIF file or buffer and converts it to a 1-bit bitmap, scaled to
+ * `width` dots. Node only; needs the optional `@napi-rs/canvas` (or `canvas`) package.
+ */
+async function loadImage(source, options = {}) {
+    let mod = null;
+    for (const name of ['@napi-rs/canvas', 'canvas']) {
+        try {
+            mod = require(name);
+            break;
+        }
+        catch {
+            /* try the next */
+        }
+    }
+    if (!mod)
+        throw new Error('retail-print-kit: loadImage needs @napi-rs/canvas; run `npm install @napi-rs/canvas`');
+    const img = await mod.loadImage(source);
+    const width = Math.max(1, Math.round(options.width ?? img.width));
+    const height = Math.max(1, Math.round((img.height * width) / img.width));
+    const canvas = mod.createCanvas(width, height);
+    const ctx = canvas.getContext('2d');
+    ctx.fillStyle = '#fff';
+    ctx.fillRect(0, 0, width, height);
+    ctx.drawImage(img, 0, 0, width, height);
+    const data = ctx.getImageData(0, 0, width, height).data;
+    return options.dither ? (0, bitmap_1.ditherRgba)(data, width, height) : (0, bitmap_1.fromRgba)(data, width, height, options.threshold ?? 128);
+}

package/dist/core/ops.d.ts

@@ -0,0 +1,78 @@
+export type Align = 'left' | 'center' | 'right';
+export type Font = 'a' | 'b';
+export type BarcodeType = 'CODE128' | 'EAN13' | 'EAN8' | 'UPC_A' | 'UPC_E' | 'CODE39' | 'ITF' | 'CODABAR';
+export type BarcodePosition = 'none' | 'above' | 'below' | 'both';
+export interface StyleFlags {
+    bold?: boolean;
+    underline?: 0 | 1 | 2;
+    italic?: boolean;
+    invert?: boolean;
+}
+export interface BarcodeOptions {
+    width?: number;
+    height?: number;
+    position?: BarcodePosition;
+    font?: Font;
+    includeParity?: boolean;
+}
+export interface QrOptions {
+    size?: number;
+    correction?: 'L' | 'M' | 'Q' | 'H';
+    model?: 1 | 2;
+}
+export type Op = {
+    kind: 'init';
+} | {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'newline';
+    count: number;
+} | {
+    kind: 'feed';
+    lines: number;
+} | {
+    kind: 'align';
+    align: Align;
+} | {
+    kind: 'font';
+    font: Font;
+} | {
+    kind: 'size';
+    width: number;
+    height: number;
+} | {
+    kind: 'style';
+    style: StyleFlags;
+} | {
+    kind: 'lineSpacing';
+    dots: number | null;
+} | {
+    kind: 'cut';
+    partial: boolean;
+    feed: number;
+} | {
+    kind: 'drawer';
+    pin: 2 | 5;
+} | {
+    kind: 'beep';
+    times: number;
+    duration: number;
+} | {
+    kind: 'barcode';
+    data: string;
+    type: BarcodeType;
+    options: BarcodeOptions;
+} | {
+    kind: 'qr';
+    data: string;
+    options: QrOptions;
+} | {
+    kind: 'raster';
+    width: number;
+    height: number;
+    bits: Uint8Array;
+} | {
+    kind: 'raw';
+    bytes: Uint8Array;
+};

package/dist/core/ops.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/printer.d.ts

@@ -0,0 +1,35 @@
+import { Transport } from '../transports/types';
+import { Profile } from '../profiles/types';
+import { EncodeContext } from './encode';
+import { OpBuilder } from './builder';
+import { PrinterStatus } from './status';
+export * from './builder';
+export interface PrinterOptions extends EncodeContext {
+    /** Send ESC @ and the profile code page on open. Default true. */
+    initOnOpen?: boolean;
+    /** Milliseconds to wait for a status reply. Default 1500. */
+    statusTimeout?: number;
+}
+/** An `OpBuilder` bound to a transport: `open()`, record ops, `close()` sends them. */
+export declare class Printer extends OpBuilder {
+    readonly transport: Transport;
+    private readonly options;
+    private opened;
+    constructor(transport: Transport, profile: Profile, options?: PrinterOptions);
+    open(): Promise<this>;
+    /** Encodes and sends everything recorded so far, keeping the connection open. */
+    flush(): Promise<this>;
+    /** Flushes, then closes the transport. */
+    close(): Promise<void>;
+    /** Renders a template with data and appends the result. */
+    render(template: import('../template/types').Template, data: unknown): this;
+    /** HTML preview of the recorded ops. */
+    toHtml(options?: import('../preview/html').HtmlPreviewOptions): string;
+    /** The bytes that would be sent for the recorded ops; useful for tests and previews. */
+    toBuffer(): Buffer;
+    /**
+     * Asks the printer for its state (ESC/POS DLE EOT 1..4). Flushes pending ops first so the
+     * reply is not mixed with receipt data. Needs a transport with `read`.
+     */
+    status(): Promise<PrinterStatus>;
+}