label-printer 0.2.6 → 0.3.1

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,406 @@ 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 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$3_Alignment = Alignment;
+type index$3_AutoManual = AutoManual;
+type index$3_BarcodeHumanReable = BarcodeHumanReable;
+type index$3_BarcodeType = BarcodeType;
+type index$3_ECCLevel = ECCLevel;
+type index$3_GraphicMode = GraphicMode;
+type index$3_LabelDirection = LabelDirection;
+type index$3_QRModel = QRModel;
+type index$3_Rotation = Rotation;
+type index$3_TSPLBarCommand = TSPLBarCommand;
+declare const index$3_TSPLBarCommand: typeof TSPLBarCommand;
+type index$3_TSPLBitmapCommand = TSPLBitmapCommand;
+declare const index$3_TSPLBitmapCommand: typeof TSPLBitmapCommand;
+type index$3_TSPLBlockCommand = TSPLBlockCommand;
+declare const index$3_TSPLBlockCommand: typeof TSPLBlockCommand;
+type index$3_TSPLCLSCommand = TSPLCLSCommand;
+declare const index$3_TSPLCLSCommand: typeof TSPLCLSCommand;
+type index$3_TSPLCommand = TSPLCommand;
+declare const index$3_TSPLCommand: typeof TSPLCommand;
+type index$3_TSPLCommandGroup = TSPLCommandGroup;
+declare const index$3_TSPLCommandGroup: typeof TSPLCommandGroup;
+type index$3_TSPLDiagonal = TSPLDiagonal;
+declare const index$3_TSPLDiagonal: typeof TSPLDiagonal;
+type index$3_TSPLDirectionCommand = TSPLDirectionCommand;
+declare const index$3_TSPLDirectionCommand: typeof TSPLDirectionCommand;
+type index$3_TSPLDisplay = TSPLDisplay;
+declare const index$3_TSPLDisplay: typeof TSPLDisplay;
+type index$3_TSPLDownload = TSPLDownload;
+declare const index$3_TSPLDownload: typeof TSPLDownload;
+type index$3_TSPLGapCommand = TSPLGapCommand;
+declare const index$3_TSPLGapCommand: typeof TSPLGapCommand;
+type index$3_TSPLPrintCommand = TSPLPrintCommand;
+declare const index$3_TSPLPrintCommand: typeof TSPLPrintCommand;
+type index$3_TSPLQRCommand = TSPLQRCommand;
+declare const index$3_TSPLQRCommand: typeof TSPLQRCommand;
+type index$3_TSPLRawCommand = TSPLRawCommand;
+declare const index$3_TSPLRawCommand: typeof TSPLRawCommand;
+type index$3_TSPLSizeCommand = TSPLSizeCommand;
+declare const index$3_TSPLSizeCommand: typeof TSPLSizeCommand;
+type index$3_TSPLTextCommand = TSPLTextCommand;
+declare const index$3_TSPLTextCommand: typeof TSPLTextCommand;
+type index$3_TSPLVisualCommand = TSPLVisualCommand;
+declare const index$3_TSPLVisualCommand: typeof TSPLVisualCommand;
+declare const index$3_alignmentToNumber: typeof alignmentToNumber;
+declare namespace index$3 {
+  export { type index$3_Alignment as Alignment, type index$3_AutoManual as AutoManual, type index$3_BarcodeHumanReable as BarcodeHumanReable, type index$3_BarcodeType as BarcodeType, type index$3_ECCLevel as ECCLevel, type index$3_GraphicMode as GraphicMode, type index$3_LabelDirection as LabelDirection, type index$3_QRModel as QRModel, type index$3_Rotation as Rotation, index$3_TSPLBarCommand as TSPLBarCommand, index$3_TSPLBitmapCommand as TSPLBitmapCommand, index$3_TSPLBlockCommand as TSPLBlockCommand, index$3_TSPLCLSCommand as TSPLCLSCommand, index$3_TSPLCommand as TSPLCommand, index$3_TSPLCommandGroup as TSPLCommandGroup, index$3_TSPLDiagonal as TSPLDiagonal, index$3_TSPLDirectionCommand as TSPLDirectionCommand, index$3_TSPLDisplay as TSPLDisplay, index$3_TSPLDownload as TSPLDownload, index$3_TSPLGapCommand as TSPLGapCommand, index$3_TSPLPrintCommand as TSPLPrintCommand, index$3_TSPLQRCommand as TSPLQRCommand, index$3_TSPLRawCommand as TSPLRawCommand, index$3_TSPLSizeCommand as TSPLSizeCommand, index$3_TSPLTextCommand as TSPLTextCommand, index$3_TSPLVisualCommand as TSPLVisualCommand, index$3_alignmentToNumber as alignmentToNumber, _default as commandGenerator };
+}
+
+type Point = {
+    x: number;
+    y: number;
+};
+
+type PrinterLanguage = "tspl";
+type UnitSystem = "imperial" | "metric" | "dot";
+
+type index$2_Command = Command;
+declare const index$2_Command: typeof Command;
+type index$2_CommandGroup<T extends Command> = CommandGroup<T>;
+declare const index$2_CommandGroup: typeof CommandGroup;
+type index$2_Point = Point;
+type index$2_PrinterLanguage = PrinterLanguage;
 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 };
+  export { index$2_Command as Command, index$2_CommandGroup as CommandGroup, type index$2_Point as Point, type index$2_PrinterLanguage as PrinterLanguage, type index$2_UnitSystem as UnitSystem, index$3 as tspl };
 }
 
-type PrinterLanguage = "tspl";
+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;
+}
+
+/**
+ * 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>;
+}
 
-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;
+type index$1_BarCode = BarCode;
+declare const index$1_BarCode: typeof BarCode;
+type index$1_Image = Image;
+declare const index$1_Image: typeof Image;
+type index$1_Label = Label;
+declare const index$1_Label: typeof Label;
+type index$1_Line = Line;
+declare const index$1_Line: typeof Line;
+type index$1_Text = Text;
+declare const index$1_Text: typeof Text;
 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 };
+  export { index$1_BarCode as BarCode, index$1_Image as Image, index$1_Label as Label, index$1_Line as Line, index$1_Text as Text, QRCode as qrCode };
 }
 
 /**
@@ -431,6 +805,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
@@ -472,4 +856,4 @@ declare namespace index {
   export { index_Printer as Printer, index_PrinterService as PrinterService };
 }
 
-export { index$1 as commands, index as printers };
+export { index$2 as commands, index$1 as labels, index as printers };