label-printer 0.2.5 → 0.3.0

package/README.md

@@ -1,4 +1,6 @@
-# Label Print
+# Label Printer
+
+> :warning: `label-printer` is still under heavy development and is subject to frequent API changes
 
 This package provides a js based implementation for variouse languages used for label printers
 
@@ -35,4 +37,15 @@ This layer contains code to interact with printers
 
 ## Documentation of supported languages
 
-- [TSPL](documentations/TSPL.pdf)
+- [TSPL](documentations/TSPL.pdf)
+
+# Usefull units:
+
+- 1 pt = 1/72 inch
+- 1 dot = 1 / dpi
+
+# Notes
+
+- If a font is not working, make sure the extension is TTF
+- If you want to use bold fonts, make sure you have one for weight 700
+- Regular font weight is 400

package/dist/index.d.mts

@@ -1,3 +1,5 @@
+import { Font as Font$1 } from 'fontkit';
+
 /**
  * Convenience wrapper for a web usb device
  * Its main purpose is to hide the details of the usb library from client code so in case
@@ -31,7 +33,7 @@ declare class UsbDevice {
      * Write data to an USB device
      * @param data Data to write
      */
-    writeData(data: Uint8Array): Promise<void>;
+    writeData(data: Uint8Array | ArrayBuffer): Promise<void>;
     /**
      * Writes a text to a device
      * @param text Text to write
@@ -59,6 +61,7 @@ declare abstract class Command {
      * Returns a string representation of the command
      */
     abstract get commandString(): string;
+    print(fn: (command: string) => void): void;
     /**
      * Write the command data to a USB device
      * @param device Device to write to
@@ -79,7 +82,7 @@ declare abstract class Command {
      * @param data Byte array to send
      * @param device Device to write to
      */
-    protected writeBytes(data: Uint8Array, device: UsbDevice): Promise<void>;
+    protected writeBytes(data: Uint8Array | ArrayBuffer, device: UsbDevice): Promise<void>;
     /**
      * Write the command terminator to the device
      * @param device
@@ -95,6 +98,7 @@ declare abstract class Command {
 declare abstract class CommandGroup<T extends Command> extends Command {
     private commands;
     constructor(commands: T[]);
+    print(fn: (command: string) => void): void;
     write(device: UsbDevice): Promise<void>;
     get commandString(): string;
 }
@@ -105,6 +109,38 @@ declare abstract class CommandGroup<T extends Command> extends Command {
 declare abstract class TSPLCommand extends Command {
 }
 
+type BitmapLike = {
+    width: number;
+    height: number;
+    bytes: Uint8Array;
+};
+/**
+ * Helper type to transmit black and white bitmap data
+ */
+type BWBitmap = BitmapLike;
+
+/**
+ * Interface that should be implemented by a command generator object for each language
+ */
+interface CommandGenerator<T extends Command> {
+    commandGroup: (commands: T[]) => CommandGroup<T>;
+    print: (sets: number, copiesPerSet: number) => T;
+    text: (content: string, x: number, y: number, font: string | "default", size: number) => T;
+    upload: (name: string, data: ArrayBuffer | Uint8Array) => T;
+    line: (start: Point, end: Point, thickness: number) => T;
+    image: (image: BitmapLike, x: number, y: number, mode?: GraphicMode) => T;
+    qrCode: (content: string, width: number, x: number, y: number) => T;
+    barCode: (content: string, x: number, y: number, type: BarcodeType, height: number, rotation: Rotation, humanReadable: BarcodeHumanReable, alignment: Alignment) => T;
+    /**
+     * Should instruct the printer to display the image of the label on its screen instead of printing it
+     */
+    display: () => T;
+    /**
+     * This should generate the needed commands to set up a label before printing
+     */
+    setUp: (width: number, height: number, gap: number, offset: number, direction: LabelDirection, mirror: boolean, unitSystem: UnitSystem) => T;
+}
+
 /**
  * A raw TSPL command. Can be used to use a command that is not yet supported
  */
@@ -136,15 +172,6 @@ declare abstract class TSPLVisualCommand extends TSPLCommand {
     constructor(x: number, y: number);
 }
 
-/**
- * Helper type to transmit black and white bitmap data
- */
-type BWBitmap = {
-    width: number;
-    height: number;
-    bytes: Uint8Array;
-};
-
 type Rotation = 0 | 90 | 180 | 270;
 type Alignment = undefined | "left" | "center" | "right";
 /**
@@ -159,7 +186,7 @@ declare const alignmentToNumber: (alignment: Alignment) => 0 | 1 | 2 | 3;
  * on the values
  */
 type GraphicMode = "overwrite" | "or" | "xor";
-type UnitSystem = "imperial" | "metric" | "dot";
+type LabelDirection = "normal" | "inverse";
 type ECCLevel = "L" | "M" | "Q" | "H";
 type AutoManual = "A" | "M";
 type QRModel = "M1" | "M2";
@@ -252,7 +279,6 @@ declare class TSPLGapCommand extends TSPLCommand {
     private readonly unitSystem;
     constructor(gap: number, offset: number, unitSystem: UnitSystem);
     get commandString(): string;
-    private valueWithUnit;
 }
 
 /**
@@ -271,7 +297,6 @@ declare class TSPLSizeCommand extends TSPLCommand {
     private readonly unitSystem;
     constructor(width: number, height: number, unitSystem: UnitSystem);
     get commandString(): string;
-    private valueWithUnit;
 }
 
 /**
@@ -293,7 +318,7 @@ declare class TSPLDirectionCommand extends TSPLCommand {
      * @param direction Controls the orientation of the resulting label compared to the printer
      * @param mirror Controls mirroring relative to the center line of the label perpendicular to the printhead. See the documentsion for examples
      */
-    constructor(direction: "normal" | "inverse", mirror?: boolean);
+    constructor(direction: LabelDirection, mirror?: boolean);
     get commandString(): string;
 }
 
@@ -360,57 +385,381 @@ declare class TSPLBlockCommand extends TSPLTextCommand {
     get commandString(): string;
 }
 
-type index$2_Alignment = Alignment;
-type index$2_AutoManual = AutoManual;
-type index$2_BarcodeHumanReable = BarcodeHumanReable;
-type index$2_BarcodeType = BarcodeType;
-type index$2_ECCLevel = ECCLevel;
-type index$2_GraphicMode = GraphicMode;
-type index$2_QRModel = QRModel;
-type index$2_Rotation = Rotation;
-type index$2_TSPLBarCommand = TSPLBarCommand;
-declare const index$2_TSPLBarCommand: typeof TSPLBarCommand;
-type index$2_TSPLBitmapCommand = TSPLBitmapCommand;
-declare const index$2_TSPLBitmapCommand: typeof TSPLBitmapCommand;
-type index$2_TSPLBlockCommand = TSPLBlockCommand;
-declare const index$2_TSPLBlockCommand: typeof TSPLBlockCommand;
-type index$2_TSPLCLSCommand = TSPLCLSCommand;
-declare const index$2_TSPLCLSCommand: typeof TSPLCLSCommand;
-type index$2_TSPLCommand = TSPLCommand;
-declare const index$2_TSPLCommand: typeof TSPLCommand;
-type index$2_TSPLCommandGroup = TSPLCommandGroup;
-declare const index$2_TSPLCommandGroup: typeof TSPLCommandGroup;
-type index$2_TSPLDirectionCommand = TSPLDirectionCommand;
-declare const index$2_TSPLDirectionCommand: typeof TSPLDirectionCommand;
-type index$2_TSPLGapCommand = TSPLGapCommand;
-declare const index$2_TSPLGapCommand: typeof TSPLGapCommand;
-type index$2_TSPLPrintCommand = TSPLPrintCommand;
-declare const index$2_TSPLPrintCommand: typeof TSPLPrintCommand;
-type index$2_TSPLQRCommand = TSPLQRCommand;
-declare const index$2_TSPLQRCommand: typeof TSPLQRCommand;
-type index$2_TSPLRawCommand = TSPLRawCommand;
-declare const index$2_TSPLRawCommand: typeof TSPLRawCommand;
-type index$2_TSPLSizeCommand = TSPLSizeCommand;
-declare const index$2_TSPLSizeCommand: typeof TSPLSizeCommand;
-type index$2_TSPLTextCommand = TSPLTextCommand;
-declare const index$2_TSPLTextCommand: typeof TSPLTextCommand;
-type index$2_TSPLVisualCommand = TSPLVisualCommand;
-declare const index$2_TSPLVisualCommand: typeof TSPLVisualCommand;
-type index$2_UnitSystem = UnitSystem;
-declare const index$2_alignmentToNumber: typeof alignmentToNumber;
-declare namespace index$2 {
-  export { type index$2_Alignment as Alignment, type index$2_AutoManual as AutoManual, type index$2_BarcodeHumanReable as BarcodeHumanReable, type index$2_BarcodeType as BarcodeType, type index$2_ECCLevel as ECCLevel, type index$2_GraphicMode as GraphicMode, type index$2_QRModel as QRModel, type index$2_Rotation as Rotation, index$2_TSPLBarCommand as TSPLBarCommand, index$2_TSPLBitmapCommand as TSPLBitmapCommand, index$2_TSPLBlockCommand as TSPLBlockCommand, index$2_TSPLCLSCommand as TSPLCLSCommand, index$2_TSPLCommand as TSPLCommand, index$2_TSPLCommandGroup as TSPLCommandGroup, index$2_TSPLDirectionCommand as TSPLDirectionCommand, index$2_TSPLGapCommand as TSPLGapCommand, index$2_TSPLPrintCommand as TSPLPrintCommand, index$2_TSPLQRCommand as TSPLQRCommand, index$2_TSPLRawCommand as TSPLRawCommand, index$2_TSPLSizeCommand as TSPLSizeCommand, index$2_TSPLTextCommand as TSPLTextCommand, index$2_TSPLVisualCommand as TSPLVisualCommand, type index$2_UnitSystem as UnitSystem, index$2_alignmentToNumber as alignmentToNumber };
+type Data = ArrayBuffer | Uint8Array;
+/**
+ * A raw TSPL command. Can be used to use a command that is not yet supported
+ */
+declare class TSPLDownload extends TSPLCommand {
+    /**
+     * Name of the file on the printer
+     */
+    private readonly fileName;
+    private readonly data;
+    /**
+     * Initialize a command with a raw body
+     * @param body
+     */
+    constructor(fileName: string, data: Data);
+    get commandString(): string;
+    write(device: UsbDevice): Promise<void>;
 }
 
+type DisplayType = "CLS" | "IMAGE" | "OFF";
+/**
+ * Displays the image buffer on the screen
+ * {@link /documentsions/TSPL.pdf}
+ */
+declare class TSPLDisplay extends TSPLCommand {
+    private readonly type;
+    constructor(type: DisplayType);
+    get commandString(): string;
+}
+
+declare class TSPLDiagonal extends TSPLCommand {
+    private readonly start;
+    private readonly end;
+    private readonly thickness;
+    constructor(start: Point, end: Point, thickness?: number);
+    get commandString(): string;
+}
+
+/**
+ * Command generator for tspl commands
+ */
+declare class TSPLCommandGenerator implements CommandGenerator<TSPLCommand> {
+    commandGroup(commands: TSPLCommand[]): TSPLCommandGroup;
+    print(sets: number, copiesPerSet: number): TSPLCommand;
+    text(content: string, x: number, y: number, font: string | "default", size: number): TSPLCommand;
+    upload(name: string, data: ArrayBuffer | Uint8Array): TSPLCommand;
+    setUp(width: number, height: number, gap: number, offset: number, direction: LabelDirection, mirror: boolean | undefined, unitSystem: UnitSystem): TSPLCommand;
+    display(): TSPLCommandGroup;
+    line(start: Point, end: Point, thickness: number): TSPLCommand;
+    image(image: BitmapLike, x: number, y: number, mode?: GraphicMode | undefined): TSPLCommand;
+    qrCode(content: string, width: number, x: number, y: number): TSPLCommand;
+    barCode(content: string, x: number, y: number, type: BarcodeType, height: number, rotation: Rotation, humanReadable: BarcodeHumanReable, alignment: Alignment): TSPLCommand;
+    private cellCount;
+}
+declare const _default: TSPLCommandGenerator;
+
+type index_Alignment = Alignment;
+type index_AutoManual = AutoManual;
+type index_BarcodeHumanReable = BarcodeHumanReable;
+type index_BarcodeType = BarcodeType;
+type index_ECCLevel = ECCLevel;
+type index_GraphicMode = GraphicMode;
+type index_LabelDirection = LabelDirection;
+type index_QRModel = QRModel;
+type index_Rotation = Rotation;
+type index_TSPLBarCommand = TSPLBarCommand;
+declare const index_TSPLBarCommand: typeof TSPLBarCommand;
+type index_TSPLBitmapCommand = TSPLBitmapCommand;
+declare const index_TSPLBitmapCommand: typeof TSPLBitmapCommand;
+type index_TSPLBlockCommand = TSPLBlockCommand;
+declare const index_TSPLBlockCommand: typeof TSPLBlockCommand;
+type index_TSPLCLSCommand = TSPLCLSCommand;
+declare const index_TSPLCLSCommand: typeof TSPLCLSCommand;
+type index_TSPLCommand = TSPLCommand;
+declare const index_TSPLCommand: typeof TSPLCommand;
+type index_TSPLCommandGroup = TSPLCommandGroup;
+declare const index_TSPLCommandGroup: typeof TSPLCommandGroup;
+type index_TSPLDiagonal = TSPLDiagonal;
+declare const index_TSPLDiagonal: typeof TSPLDiagonal;
+type index_TSPLDirectionCommand = TSPLDirectionCommand;
+declare const index_TSPLDirectionCommand: typeof TSPLDirectionCommand;
+type index_TSPLDisplay = TSPLDisplay;
+declare const index_TSPLDisplay: typeof TSPLDisplay;
+type index_TSPLDownload = TSPLDownload;
+declare const index_TSPLDownload: typeof TSPLDownload;
+type index_TSPLGapCommand = TSPLGapCommand;
+declare const index_TSPLGapCommand: typeof TSPLGapCommand;
+type index_TSPLPrintCommand = TSPLPrintCommand;
+declare const index_TSPLPrintCommand: typeof TSPLPrintCommand;
+type index_TSPLQRCommand = TSPLQRCommand;
+declare const index_TSPLQRCommand: typeof TSPLQRCommand;
+type index_TSPLRawCommand = TSPLRawCommand;
+declare const index_TSPLRawCommand: typeof TSPLRawCommand;
+type index_TSPLSizeCommand = TSPLSizeCommand;
+declare const index_TSPLSizeCommand: typeof TSPLSizeCommand;
+type index_TSPLTextCommand = TSPLTextCommand;
+declare const index_TSPLTextCommand: typeof TSPLTextCommand;
+type index_TSPLVisualCommand = TSPLVisualCommand;
+declare const index_TSPLVisualCommand: typeof TSPLVisualCommand;
+declare const index_alignmentToNumber: typeof alignmentToNumber;
+declare namespace index {
+  export { type index_Alignment as Alignment, type index_AutoManual as AutoManual, type index_BarcodeHumanReable as BarcodeHumanReable, type index_BarcodeType as BarcodeType, type index_ECCLevel as ECCLevel, type index_GraphicMode as GraphicMode, type index_LabelDirection as LabelDirection, type index_QRModel as QRModel, type index_Rotation as Rotation, index_TSPLBarCommand as TSPLBarCommand, index_TSPLBitmapCommand as TSPLBitmapCommand, index_TSPLBlockCommand as TSPLBlockCommand, index_TSPLCLSCommand as TSPLCLSCommand, index_TSPLCommand as TSPLCommand, index_TSPLCommandGroup as TSPLCommandGroup, index_TSPLDiagonal as TSPLDiagonal, index_TSPLDirectionCommand as TSPLDirectionCommand, index_TSPLDisplay as TSPLDisplay, index_TSPLDownload as TSPLDownload, index_TSPLGapCommand as TSPLGapCommand, index_TSPLPrintCommand as TSPLPrintCommand, index_TSPLQRCommand as TSPLQRCommand, index_TSPLRawCommand as TSPLRawCommand, index_TSPLSizeCommand as TSPLSizeCommand, index_TSPLTextCommand as TSPLTextCommand, index_TSPLVisualCommand as TSPLVisualCommand, index_alignmentToNumber as alignmentToNumber, _default as commandGenerator };
+}
+
+type Point = {
+    x: number;
+    y: number;
+};
+
 type PrinterLanguage = "tspl";
+type UnitSystem = "imperial" | "metric" | "dot";
+
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+type FontStyle = "italic" | "normal";
+type Font = {
+    name: string;
+    data: ArrayBufferLike;
+    font: Font$1;
+    weight: number;
+    style: FontStyle;
+};
+type FontOption = Expand<Partial<Pick<Font, "style" | "weight">> & Pick<Font, "name"> & {
+    size: number;
+}>;
+
+type PrintConfig = {
+    dpi: number;
+    textWidth: (text: string, font: FontOption) => number;
+    getFontName: (font: FontOption) => string;
+};
+/**
+ * A component that can be directly printed to label printer
+ */
+declare abstract class Printable {
+    /**
+     * Generates a printable command
+     * @param language The printing language that should be used
+     * @returns A promise of a command that can be printed
+     */
+    abstract commandForLanguage(language: PrinterLanguage, config?: PrintConfig): Promise<Command>;
+    /**
+     * Generates printable command for the given printer. Can be used to obtain a command for fields supported by the package then customizing it before printing
+     * @param printer Printer to generate the command. Important because the command is printer language specific
+     * @returns A promise for a command. Most commands are syncronouse but some may require to access async resources
+     */
+    commandForPrinter(printer: Printer, config?: PrintConfig): Promise<Command>;
+    /**
+     * Obtain a command generator for the given language
+     * @param language Language to get generator for
+     */
+    protected commandGeneratorFor(language: PrinterLanguage): CommandGenerator<any>;
+}
+
+declare abstract class LabelField extends Printable {
+}
+
+/**
+ * Holds the content of a label and handles printing
+ */
+declare class Label extends Printable {
+    /**
+     * Width of label in dots, mm or inch
+     */
+    private readonly width;
+    /**
+     * Height of label in dots, mm or inch
+     */
+    private readonly height;
+    /**
+     * Units for width, height, gap and offset
+     */
+    private readonly unitSystem;
+    private fonts;
+    private dpi;
+    /**
+    * List of fields on the label
+    */
+    private fields;
+    private fontCounter;
+    /**
+     * Configuration used when generating commands
+     */
+    get printConfig(): PrintConfig;
+    constructor(width: number, height: number, dimensionUnit?: UnitSystem, dpi?: number);
+    commandForLanguage(language: PrinterLanguage, config?: PrintConfig): Promise<Command>;
+    /**
+     * Place fields to a label
+     * @param fields
+     */
+    add(...fields: LabelField[]): void;
+    /**
+     * Register a font to be used. Use the name provided in components to use the font.
+     * For example: textField.setFont('myFont.ttf', 12)
+     * @param file Font file. Can be a blob or a url
+     * @param name Name to be used to reference the font
+     */
+    registerFont(font: Omit<Font, "font">): Promise<void>;
+    /**
+     * Generate a command that is complete for printing
+     * @param language Printing language to use
+     * @param gap Distance between two labels. It is measured between the two points where the sensor
+     * leaves the label and enters the next one
+     * @param direction Direction relative to printing direction. See documentation for more details
+     * @param sets Number of sets to print. If you have counters for example, it will not change in a set
+     * @param copiesPerSet Number of labels per set
+     * @param mirror Mirror the label along the vertical axis
+     * @param gapOffset Used with non uniform shaped labels. Is the distance between the point where the sensor leaves the label and the
+     * furthest point of the label in the direction of printing. Check documentation for more info
+     * TODO: Is this too TSPL Specific?
+     */
+    fullPrintCommand(language: PrinterLanguage, gap: number, direction: LabelDirection, sets: number, copiesPerSet?: number, mirror?: boolean, gapOffset?: number): Promise<Command>;
+    /**
+     * Generate commands needed to display the label on the printer screen
+     * @param language Printing language to use
+     * @param direction Direction relative to printing direction. See documentation for more details
+     * @param mirror Mirror the label along the vertical axis
+     */
+    fullDisplayCommand(language: PrinterLanguage, direction: LabelDirection, mirror?: boolean): Promise<CommandGroup<any>>;
+    /**
+     * Helper function that generates common commands for print and display
+     */
+    private fullCommand;
+    private fontUploadCommands;
+    private getIndexedFont;
+    private getFontName;
+    private get fontExtension();
+    private fontKey;
+}
 
-type index$1_Command = Command;
-declare const index$1_Command: typeof Command;
-type index$1_CommandGroup<T extends Command> = CommandGroup<T>;
-declare const index$1_CommandGroup: typeof CommandGroup;
-type index$1_PrinterLanguage = PrinterLanguage;
-declare namespace index$1 {
-  export { index$1_Command as Command, index$1_CommandGroup as CommandGroup, type index$1_PrinterLanguage as PrinterLanguage, index$2 as tspl };
+/**
+ * Draws a line to the screen
+ */
+declare class Line extends LabelField {
+    private readonly start;
+    private readonly end;
+    private readonly thickness;
+    /**
+     *
+     * @param start Start point of the line. Values are in dots
+     * @param end End point of the line. Values are in dots
+     * @param thickness Thickness of the line in dots
+     */
+    constructor(start: Point, end: Point, thickness?: number);
+    commandForLanguage(language: PrinterLanguage): Promise<Command>;
+}
+
+/**
+ * Presents a piece of text on the label
+ */
+declare class Text extends LabelField {
+    private readonly content;
+    /**
+     * X coordinate in dots
+     */
+    private readonly x;
+    /**
+     * Y coordinate in dots
+     */
+    private readonly y;
+    /**
+     * If true, basic html elements will be interpretted, otherwise the raw string is printed out
+     */
+    private readonly formatted;
+    private font;
+    private type;
+    private context;
+    private readonly lineSpacing;
+    /**
+     * Width of the text.
+     * If set, the text will be clipped to this size
+     * If the type is set to multiline, this is where the text is split to a newline
+     */
+    private width;
+    /**
+     * Height of the text box, if empty and the type is multiline, the box can grow infinitely
+     */
+    private height;
+    constructor(content: string, x: number, y: number, formatted?: boolean);
+    /**
+     * Sets the field to single line
+     * @param width Max width of the text. Leave it undefined to allow the field to grow
+     */
+    setSingleLine(width?: number): void;
+    /**
+     * Sets the field to multi line
+     * @param width Max width of text before it gets wrapped to a new line
+     * @param height Max height of the text box, leave undefined to allow the text box to grow infinitly
+     */
+    setMultiLine(width: number, height?: number): void;
+    /**
+     * Set a font to use as a base. If no formatting is set on the text with a html tag, this will be used
+     * Note: The font name either has to be a built in font on your printer or a font
+     * that is registered on the label using 'registerFont'.
+     */
+    setFont(font: FontOption): void;
+    commandForLanguage(language: PrinterLanguage, config?: PrintConfig): Promise<Command>;
+    /**
+     * Generate commands for formatted text
+     * @returns
+     */
+    private generateFormattedText;
+    /**
+     * Generate commands for plain text
+     * @returns
+     */
+    private generatePlainText;
+    /**
+     * Iterats the nodes in a html text and generates text commands for it
+     */
+    private generateFormattedRecursive;
+    /**
+     * Generate commands for plain text
+     * @param config
+     * @returns
+     */
+    private generatePlainTextCore;
+    private textCommand;
+    private textLineCommand;
+    private getFontName;
+    private get textWithFunction();
+    /**
+     * This function is used to calculate the font size if no
+     * print config is provided. This will asume that the font has square characters
+     */
+    private defaultTextWidth;
+}
+
+declare class BarCode extends LabelField {
+    private readonly content;
+    private readonly x;
+    private readonly y;
+    private readonly type;
+    private readonly height;
+    private rotation;
+    private humanReadable;
+    private readonly alignment;
+    constructor(content: string, x: number, y: number, type: BarcodeType, height: number);
+    setRotation(rotation: Rotation): void;
+    setHumanReadable(humanReadable: BarcodeHumanReable): void;
+    commandForLanguage(language: PrinterLanguage, _config?: PrintConfig | undefined): Promise<Command>;
+}
+
+declare class Image extends LabelField {
+    /**
+     * X coordinate in dots
+     */
+    private readonly x;
+    /**
+     * Y coordinate in dots
+     */
+    private readonly y;
+    private readonly image;
+    constructor(x: number, y: number, image: BitmapLike);
+    commandForLanguage(language: PrinterLanguage, _config?: PrintConfig | undefined): Promise<Command>;
+    /**
+     * Create an image field for an image
+     * @param image
+     * @param x
+     * @param y
+     * @param width
+     * @param height
+     * @returns
+     */
+    static create(image: string, x: number, y: number, width?: number, height?: number): Promise<Image>;
+}
+
+declare class QRCode extends LabelField {
+    private readonly content;
+    private readonly x;
+    private readonly y;
+    private readonly width;
+    constructor(content: string, x: number, y: number, width: number);
+    commandForLanguage(language: PrinterLanguage, config?: PrintConfig | undefined): Promise<Command>;
 }
 
 /**
@@ -431,6 +780,16 @@ declare abstract class Printer {
      * Close the printer USB
      */
     close(): Promise<void>;
+    /**
+     * Prints a label
+     * @param label
+     */
+    print(label: Label, sets: number, gap: number, copiesPerSet?: number, direction?: LabelDirection, mirror?: boolean, gapOffset?: number): Promise<void>;
+    /**
+     * Display label on the printer's screen
+     * @param label
+     */
+    display(label: Label, direction?: LabelDirection, mirror?: boolean): Promise<void>;
     /**
      * Writes a command to the printers usb
      * @param command Command to send to the usb
@@ -464,12 +823,4 @@ declare class PrinterService {
     static requestPrinter(): Promise<Printer | undefined>;
 }
 
-type index_Printer = Printer;
-declare const index_Printer: typeof Printer;
-type index_PrinterService = PrinterService;
-declare const index_PrinterService: typeof PrinterService;
-declare namespace index {
-  export { index_Printer as Printer, index_PrinterService as PrinterService };
-}
-
-export { index$1 as commands, index as printers };
+export { BarCode, Command, CommandGroup, Image, Label, Line, type Point, Printer, type PrinterLanguage, PrinterService, Text, type UnitSystem, QRCode as qrCode, index as tspl };