@muhammara/native-core 7.0.0-alpha.1 → 7.0.0-beta.2

package/muhammara.d.ts

@@ -327,12 +327,23 @@ declare namespace muhammara {
   export type PDFObjectType = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
   export function getTypeLabel(type: PDFObjectType): string;
 
+  export const ePDFPageContentItemText = 0;
+  export const ePDFPageContentItemPath = 1;
+  export const ePDFPageContentItemXObject = 2;
+  export const ePDFPageContentItemShading = 3;
+  export type PDFPageContentItemType =
+    | typeof ePDFPageContentItemText
+    | typeof ePDFPageContentItemPath
+    | typeof ePDFPageContentItemXObject
+    | typeof ePDFPageContentItemShading;
+
   export const ePDFPageBoxMediaBox = 0;
   export const ePDFPageBoxCropBox = 1;
   export const ePDFPageBoxBleedBox = 2;
   export const ePDFPageBoxTrimBox = 3;
   export const ePDFPageBoxArtBox = 4;
   export type PDFPageBoxType = 0 | 1 | 2 | 3 | 4;
+  export type PageBox = "media" | "crop" | "bleed" | "trim" | "art";
 
   export const eRangeTypeAll = 0;
   export const eRangeTypeSpecific = 1;
@@ -396,10 +407,32 @@ declare namespace muhammara {
     /** The page resource name selected by the most recent Tf operation. */
     fontResource: string;
     fontSize: number;
-    /** The active PDF text matrix: [a, b, c, d, e, f]. */
+    /** The text-to-page matrix after applying the active graphics CTM: [a, b, c, d, e, f]. */
     textMatrix: [number, number, number, number, number, number];
   }
 
+  /** A content-stream operation that produces a page mark. */
+  export interface PDFPageContentItem {
+    type: PDFPageContentItemType;
+    operation: string;
+  }
+
+  /**
+   * Per-call extraction budget. Every field is clamped to a built-in ceiling,
+   * so a caller may tighten a limit but never raise it above the default.
+   * Omitted fields keep the ceiling.
+   */
+  export interface PDFExtractionLimits {
+    /** Extracted elements or items. Default and ceiling: 100000. */
+    maxElements?: number;
+    /** Pending operands per operator. Default and ceiling: 1024. */
+    maxOperands?: number;
+    /** Total extracted text. Default and ceiling: 16777216 (16 MiB). */
+    maxTextBytes?: number;
+    /** Content-stream objects parsed. Default and ceiling: 1000000. */
+    maxParsedObjects?: number;
+  }
+
   export interface RectangleDimension {
     width: Width;
     height: Height;
@@ -444,15 +477,33 @@ declare namespace muhammara {
     ): undefined | PDFObject;
     parseNewObject(objectId: number): PDFObject;
     getPageObjectID(objectId: number): number;
-    parsePageDictionary(objectId: number): PDFDictionary;
-    parsePage(page: number): PDFPageInput;
+    parsePageDictionary(pageIndex: number): PDFDictionary;
+    parsePage(pageIndex: number): PDFPageInput;
     /**
      * Returns text-showing operations in PDF content-stream drawing order.
-     * Does not decode font character maps or calculate glyph bounds. For safety,
-     * extraction rejects pages with more than 1,000,000 content objects, 100,000 text
-     * operations, or 16 MiB of text.
+     * Does not decode font character maps or calculate glyph bounds.
+     *
+     * Throws when the page exceeds the extraction budget. `limits` may only
+     * tighten the defaults: higher values are clamped to the built-in ceilings
+     * of 1,000,000 content objects, 100,000 text operations, 1024 operands, and
+     * 16 MiB of text.
      */
-    extractPageText(pageIndex: number): PDFTextElement[];
+    extractPageText(
+      pageIndex: number,
+      limits?: PDFExtractionLimits,
+    ): PDFTextElement[];
+    /**
+     * Returns every direct content-stream operation that produces a page mark.
+     * White-on-white content is included; non-painting operations are excluded.
+     *
+     * Shares `extractPageText`'s budget and clamping. `limits.maxTextBytes` is
+     * accepted for signature parity but has no effect here, because items carry
+     * an operator name rather than extracted text.
+     */
+    extractPageContentItems(
+      pageIndex: number,
+      limits?: PDFExtractionLimits,
+    ): PDFPageContentItem[];
     getObjectsCount(): number;
     isEncrypted(): boolean;
     getXrefSize(): number;
@@ -746,7 +797,19 @@ declare namespace muhammara {
 
   export type inInterPagesCallback = () => {};
 
+  /** Stateful methods require an active writer and throw Error("PDF writer has ended") after cleanup. */
   export interface PDFWriter {
+    /**
+     * Replace direct references to an object in a page dictionary.
+     * Available only when modifying an existing PDF.
+     */
+    replaceObject(
+      pageIndex: number,
+      sourceObjectId: number,
+      replacementObjectId: number,
+      options?: ObjectReplacementOptions,
+    ): this;
+    /** Finalize once; repeated calls return this writer. A failed finalization also ends the writer. */
     end(): PDFWriter;
     createPage(x: PosX, y: PosY, width: Width, height: Height): PDFPage;
     createPage(): PDFPage;
@@ -774,11 +837,12 @@ declare namespace muhammara {
     ): UsedFont;
     attachURLLinktoCurrentPage(
       url: string,
-      x: PosX,
-      y: PosY,
-      width: Width,
-      height: Height,
+      left: PosX,
+      bottom: PosY,
+      right: PosX,
+      top: PosY,
     ): this;
+    /** Save continuation state and retire this writer, including when saving fails. */
     shutdown(outputFilePath: FilePath): this;
     createFormXObjectFromTIFF(
       filePath: FilePath | PDFRStreamForFile,
@@ -822,7 +886,7 @@ declare namespace muhammara {
     ): FormXObjectId[];
     createPDFCopyingContextForModifiedFile(): DocumentCopyingContext;
     createPDFTextString(): PDFTextString;
-    createPDFDate(): PDFDate;
+    createPDFDate(value?: string | Date): PDFDate;
     getImageDimensions(
       inFontFilePath: FilePath | ReadStream,
     ): RectangleDimension;
@@ -845,7 +909,75 @@ declare namespace muhammara {
     ): void;
   }
 
+  export interface ObjectReplacementOptions {
+    scope?: "global";
+  }
+
+  export interface RecipePageInfo {
+    width: number;
+    height: number;
+    rotate: number;
+    pageNumber: number;
+  }
+
   namespace Recipe {
+    type Color = string | readonly number[];
+    type BorderRadius =
+      | number
+      | readonly [number]
+      | readonly [number, number]
+      | readonly [number, number, number]
+      | readonly [number, number, number, number];
+    type DeviceColorspace = "rgb" | "gray" | "cmyk";
+    type Colorspace = DeviceColorspace | "separation";
+    /**
+     * Matches known runtime values case-insensitively without enumerating
+     * every per-character capitalization combination — that recursive
+     * approach costs 2^N literal types for an N-character word (4096 for
+     * "circumcenter" alone). The runtime lowercases the whole value before
+     * comparing, so any casing works at runtime; the type instead accepts
+     * the three forms callers actually write (lower case, UPPER CASE, and
+     * Capitalized).
+     */
+    type CaseInsensitive<Value extends string> =
+      Lowercase<Value> | Uppercase<Value> | Capitalize<Lowercase<Value>>;
+    type TriangleTrait = CaseInsensitive<"sss" | "sas" | "asa" | "vtx">;
+    type TriangleMeasurementTrait = CaseInsensitive<"sss" | "sas" | "asa">;
+    type TriangleVertexTrait = CaseInsensitive<"vtx">;
+    type TrianglePosition = CaseInsensitive<
+      "a" | "b" | "c" | "centroid" | "circumcenter" | "incenter"
+    >;
+    type PermissionName =
+      | "print"
+      | "modify"
+      | "copy"
+      | "edit"
+      | "fillform"
+      | "extract"
+      | "assemble"
+      | "printbest";
+    /** Known permission names with string compatibility for composed lists. */
+    type PermissionList = PermissionName | (string & {});
+    /**
+     * Passes a colorspace argument through when it is valid, and otherwise
+     * resolves to the accepted set so the compiler names the valid values
+     * instead of reporting the bare `never` the optional parameter would
+     * collapse to. A plain `string` stays accepted for runtime-computed values.
+     */
+    type ValidColorspace<Value extends string | undefined> = [Value] extends [
+      undefined,
+    ]
+      ? Value
+      : string extends Exclude<Value, undefined>
+        ? Value
+        : Exclude<Value, undefined> extends Colorspace | ""
+          ? Value
+          : Colorspace | "";
+    type ExtensionCallback<
+      Arguments extends unknown[] = never[],
+      Result = unknown,
+    > = (this: Recipe, ...args: Arguments) => Result;
+
     type CommentOptionsFlag =
       | "invisible"
       | "hidden"
@@ -908,12 +1040,18 @@ declare namespace muhammara {
       | "Paragraph"
       | "Insert";
 
+    type RecipeCoordinate = number | "center";
+
+    type RecipeFontStyle =
+      "regular" | "bold" | "italic" | "bold-italic" | "r" | "b" | "i" | "bi";
+
     interface RecipeOptions {
       version?: number;
       author?: string;
       title?: string;
       subject?: string;
       keywords?: string[];
+      colorspace?: Colorspace;
     }
 
     interface RecipeMargins {
@@ -929,6 +1067,8 @@ declare namespace muhammara {
       open?: boolean;
       richText?: boolean;
       flag?: CommentOptionsFlag;
+      /** Replies linked to this comment annotation. */
+      replies?: readonly AnnotReply[];
     }
 
     interface AnnotOptions {
@@ -939,9 +1079,11 @@ declare namespace muhammara {
       icon?: AnnotOptionsIcon;
       width?: number;
       height?: number;
+      /** Annotation opacity from 0 (transparent) to 1 (opaque). Defaults to 1. */
+      opacity?: number;
       date?: string;
       subject?: string;
-      replies?: Array<AnnotReply>;
+      replies?: readonly AnnotReply[];
     }
 
     interface AnnotReply {
@@ -950,10 +1092,19 @@ declare namespace muhammara {
       title?: string;
       richText?: boolean;
       flag?: AnnotOptionsFlag;
+      opacity?: number;
       date?: string;
       subject?: string;
     }
 
+    interface TextMarkupOptions extends Pick<
+      AnnotOptions,
+      "opacity" | "replies"
+    > {
+      text?: string;
+      color?: Color;
+    }
+
     interface EncryptOptions {
       password?: string;
       ownerPassword?: string;
@@ -962,15 +1113,23 @@ declare namespace muhammara {
     }
 
     interface ImageOptions {
+      /** Make the rendered image open this URL. */
+      link?: string;
       width?: number;
       height?: number;
       scale?: number;
       keepAspectRatio?: boolean;
       opacity?: number;
       align?: string;
+      rotation?: number;
+      rotationOrigin?: [number, number];
+      skewX?: number;
+      skewY?: number;
     }
 
     interface InfoOptions {
+      /** Additional Info dictionary entries; arrays are joined with a comma and space. */
+      [key: string]: string | string[] | undefined;
       version?: string;
       author?: string;
       title?: string;
@@ -986,12 +1145,46 @@ declare namespace muhammara {
       fitHeight?: boolean;
     }
 
+    interface MetadataPage {
+      pageNumber: number;
+      mediaBox: number[];
+      layout: "portrait" | "landscape";
+      rotate: number;
+      width: number;
+      height: number;
+      size?: number[];
+      offsetX?: number;
+      offsetY?: number;
+    }
+
+    interface ReadMetadataPage extends MetadataPage {
+      size: number[];
+      offsetX: number;
+      offsetY: number;
+    }
+
+    interface Metadata {
+      /** Number of pages in a parsed source PDF. */
+      pages?: number;
+      /** Number of pages created in a new PDF. */
+      pageCount?: number;
+      [page: number]: MetadataPage | undefined;
+    }
+
+    interface ReadMetadata extends Metadata {
+      pages: number;
+      pageCount?: never;
+      [page: number]: ReadMetadataPage | undefined;
+    }
+
     interface TextBoxStyle {
       lineWidth?: number;
-      stroke?: string | number[];
-      dash?: number[];
-      fill?: string | number[];
+      stroke?: Color;
+      dash?: readonly number[];
+      fill?: Color;
+      colorspace?: Colorspace;
       opacity?: number;
+      borderRadius?: boolean | BorderRadius;
     }
 
     interface TextBoxClipResult {
@@ -1010,34 +1203,54 @@ declare namespace muhammara {
       width?: number;
       height?: number;
       minHeight?: number;
-      padding?: number | number[];
+      padding?: number | readonly number[];
       lineHeight?: number;
+      wrap?: boolean | "auto" | "clip" | "trim" | "ellipsis";
       textAlign?: string;
       clipIfExceedsBox?: boolean;
       onClip?: (recipe: Recipe, result: TextBoxClipResult) => void;
       style?: TextBoxStyle;
     }
 
+    interface TextOverflowInstructions {
+      layout?: number | string;
+      column?: number | readonly [number, number];
+    }
+
+    type TextOverflowCallback = (
+      this: Recipe,
+      recipe: Recipe,
+    ) => boolean | TextOverflowInstructions;
+
     interface TextOptions {
+      /** Make the rendered text open this URL. */
+      link?: string;
       charSpace?: number;
-      color?: string | number[];
+      color?: Color;
+      colorspace?: Colorspace;
       flow?: boolean;
-      overflow?: () => void;
+      overflow?: TextOverflowCallback;
       layout?: number | string;
       opacity?: number;
       rotation?: number;
-      rotationOrigin?: [number, number];
+      rotationOrigin?: readonly [number, number];
       font?: string;
+      /** Font size in points for text() and textDimensions(); defaults to 14 when both fontSize and size are omitted. */
+      fontSize?: number;
+      /** Font size in points for text() and textDimensions(); defaults to 14. */
       size?: number;
+      bold?: boolean;
+      italic?: boolean;
       align?: string;
-      highlight?: boolean;
-      underline?: boolean;
-      strikeOut?: boolean;
+      highlight?: boolean | TextMarkupOptions;
+      underline?: boolean | TextMarkupOptions;
+      strikeOut?: boolean | TextMarkupOptions;
+      squiggly?: boolean | TextMarkupOptions;
       html?: boolean;
       hilite?:
         | boolean
         | {
-            color?: string | number[];
+            color?: Color;
             opacity?: number;
           };
       textBox?: TextBox;
@@ -1050,49 +1263,230 @@ declare namespace muhammara {
       subject?: string;
     }
 
-    interface LineToOptions {
-      color?: string | number[];
-      stroke?: string | number[];
-      fill?: string | number[];
-      lineWidth?: number;
-      opacity?: number;
-      dash?: number[];
+    interface LayoutOptions {
+      columns?: number;
+      gap?: number;
+      reset?: boolean;
     }
 
-    interface LineOptions {
-      color?: string | number[];
-      stroke?: string | number[];
-      lineWidth?: number;
-      dash?: number[];
+    type TableField<RecordType extends object> = RecordType extends unknown
+      ? RecordType extends readonly unknown[]
+        ? number extends RecordType["length"]
+          ? `${number}`
+          : Extract<keyof RecordType, `${number}`>
+        : | Extract<keyof RecordType, string>
+          | `${Extract<keyof RecordType, number>}`
+      : never;
+    type TableColumnField<RecordType extends object> = Exclude<
+      TableField<RecordType>,
+      ""
+    >;
+    type TableFieldValue<
+      RecordType extends object,
+      Field extends TableField<RecordType>,
+    > = RecordType extends unknown
+      ? Field extends keyof RecordType
+        ? RecordType[Field]
+        : Field extends `${infer NumericField extends number}`
+          ? NumericField extends keyof RecordType
+            ? RecordType[NumericField]
+            : undefined
+          : undefined
+      : never;
+
+    interface TableColumnDefinition<
+      RecordType extends object = Record<string, unknown>,
+      Field extends TableColumnField<RecordType> = TableColumnField<RecordType>,
+    > extends Omit<TextOptions, "textBox"> {
+      name: Field;
+      text?: string;
+      width?: number;
+      cell?: TextBox;
+      header?: boolean | TextOptions;
+      hcell?: TextBox;
+      renderer?: (
+        this: void,
+        text: undefined extends TableFieldValue<RecordType, Field>
+          ? Exclude<TableFieldValue<RecordType, Field>, undefined> | ""
+          : TableFieldValue<RecordType, Field>,
+        record: RecordType,
+        field: Field,
+        row: number,
+      ) => TextOptions | false | null | "" | 0 | void;
     }
 
-    interface PolygonOptions {
-      color?: string | number[];
-      stroke?: string | number[];
-      fill?: string | number[];
-      lineWidth?: number;
-      opacity?: number;
-      dash?: number[];
+    /**
+     * A distributive map over every field of `RecordType`, so a column's
+     * `renderer` receives the exact value type for its own `name` rather than
+     * the union of all columns' value types. This costs one
+     * `TableColumnDefinition` instantiation per field of `RecordType`; a
+     * plain `TableColumnDefinition<RecordType>` would be cheaper but would
+     * widen every renderer's `text` parameter to the union of all fields.
+     */
+    type TableColumnOptions<
+      RecordType extends object = Record<string, unknown>,
+    > = {
+      [Field in TableColumnField<RecordType>]: TableColumnDefinition<
+        RecordType,
+        Field
+      >;
+    }[TableColumnField<RecordType>];
+
+    interface TableOptions<
+      RecordType extends object = Record<string, unknown>,
+    > extends Omit<TextOptions, "overflow"> {
+      height?: number;
+      order?:
+        | string
+        | TableField<RecordType>[]
+        | readonly [TableField<RecordType>, ...TableField<RecordType>[]];
+      columns?: readonly TableColumnOptions<RecordType>[];
+      header?:
+        boolean | (TextOptions & { alignToData?: boolean; cell?: TextBox });
+      border?: boolean | PolygonOptions;
+      row?: TextOptions & { nth?: "even" | "odd"; cell?: TextBox };
+      overflow?: (
+        this: Recipe,
+        recipe: Recipe,
+        row: number,
+      ) => boolean | { position?: readonly [number, number] };
+    }
+
+    interface HtmlTextObject {
+      value: string | null;
+      tag: string | undefined;
+      font: string | undefined;
+      isBold: boolean;
+      isItalic: boolean;
+      underline: boolean;
+      strikeOut: boolean;
+      attributes: Array<{ name: string; value: string | null }>;
+      styles: Record<string, string | number | number[]>;
+      needsLineBreaker: boolean;
+      size: number | undefined;
+      sizeRatio: number;
+      sizeRatios: number[];
+      link: string | null;
+      childs: HtmlTextObject[];
     }
 
-    interface CircleOptions {
-      color?: string | number[];
-      stroke?: string | number[];
-      fill?: string | number[];
+    interface DrawingOptions {
+      color?: Color;
+      stroke?: Color;
+      colorspace?: Colorspace;
       lineWidth?: number;
+      width?: number;
       opacity?: number;
-      dash?: number[];
+      dash?: readonly number[];
+      dashPhase?: number;
+    }
+
+    interface PathOptions extends DrawingOptions {
+      lineCap?: "butt" | "round" | "square";
+      lineJoin?: "miter" | "round" | "bevel";
+      miterLimit?: number;
     }
 
-    interface RectangleOptions {
-      color?: string | number[];
-      stroke?: string | number[];
-      fill?: string | number[];
+    interface SkewOptions {
+      skewX?: number;
+      skewY?: number;
+    }
+
+    interface TransformOptions extends SkewOptions {
+      rotation?: number;
+      rotationOrigin?: readonly [number, number];
+    }
+
+    interface TransformedPathOptions extends PathOptions, TransformOptions {}
+
+    type LineToOptions = PathOptions;
+
+    type LineOptions = PathOptions;
+
+    interface LinkFillOptions {
+      link?: string;
+      fill?: Color;
+    }
+
+    interface PolygonOptions extends TransformedPathOptions, LinkFillOptions {}
+
+    interface ShapeOptions extends PolygonOptions {
+      debug?: boolean | number;
+    }
+
+    interface NGonOptions extends ShapeOptions {
+      rotationVertice?: number;
+    }
+
+    interface ArrowOptions extends ShapeOptions {
+      head?:
+        | number
+        | readonly [number]
+        | readonly [number, number]
+        | readonly [number, number, number];
+      shaft?: number | readonly [number] | readonly [number, number];
+      double?: boolean;
+      type?: 0 | 1 | 2 | "triangle" | "dart" | "kite";
+      at?: "head" | "tail";
+    }
+
+    interface TriangleBaseOptions extends ShapeOptions {
+      position?: TrianglePosition;
+      flipX?: boolean;
+      flipY?: boolean;
+    }
+
+    type TriangleMeasurementOptions = TriangleBaseOptions &
+      (
+        | { traitID: TriangleMeasurementTrait; traitsID?: TriangleTrait }
+        | {
+            traitID?: undefined;
+            traitsID?: TriangleMeasurementTrait;
+          }
+      );
+    type TriangleVertexIdentifier =
+      | { traitID: TriangleVertexTrait; traitsID?: TriangleTrait }
+      | { traitID?: undefined; traitsID: TriangleVertexTrait };
+    type TriangleVertexOptions = TriangleBaseOptions & TriangleVertexIdentifier;
+    type TriangleUnpositionedVertexOptions = Omit<
+      TriangleBaseOptions,
+      "position" | "flipX" | "flipY"
+    > & {
+      position?: undefined;
+      flipX?: false;
+      flipY?: false;
+    } & TriangleVertexIdentifier;
+    type TriangleOptions = TriangleMeasurementOptions | TriangleVertexOptions;
+    type TriangleMeasurements = readonly [number, number, number];
+    type TriangleVertices = readonly [
+      readonly [number, number],
+      readonly [number, number],
+      readonly [number, number],
+    ];
+    type MutableTriangleVertices = [
+      [number, number],
+      [number, number],
+      [number, number],
+    ];
+
+    interface CircleOptions
+      extends DrawingOptions, SkewOptions, LinkFillOptions {}
+
+    interface EllipseOptions extends CircleOptions, TransformOptions {}
+
+    interface RectangleOptions
+      extends DrawingOptions, TransformOptions, LinkFillOptions {
+      borderRadius?: BorderRadius;
+    }
+
+    interface LineStyleOptions {
+      width?: number;
       lineWidth?: number;
-      opacity?: number;
+      cap?: number;
+      join?: number;
+      miterLimit?: number;
       dash?: number[];
-      rotation?: number;
-      rotationOrigin?: number[];
+      dashPhase?: number;
     }
 
     type EndPDFCallback1 = () => any;
@@ -1108,9 +1502,16 @@ declare namespace muhammara {
     );
 
     readonly position: { x: number; y: number };
-    read(inSrc?: string | Buffer): { pages: number; [page: number]: object };
-    register(key: string, callback: Function): void;
-    register(callback: Function & { name: string }): void;
+    /** Current document metadata, keyed by one-based page number. */
+    readonly metadata: Recipe.Metadata;
+    read(inSrc?: string | Buffer): Recipe.ReadMetadata;
+    register<Arguments extends unknown[], Result>(
+      key: string,
+      callback: Recipe.ExtensionCallback<Arguments, Result>,
+    ): Recipe;
+    register<Arguments extends unknown[], Result>(
+      callback: Recipe.ExtensionCallback<Arguments, Result>,
+    ): Recipe;
 
     constructor(
       buffer: Buffer,
@@ -1125,6 +1526,14 @@ declare namespace muhammara {
       options?: Recipe.CommentOptions,
     ): Recipe;
 
+    link(
+      url: string,
+      x: number,
+      y: number,
+      width: number,
+      height: number,
+    ): Recipe;
+
     annot(
       x: number,
       y: number,
@@ -1139,12 +1548,16 @@ declare namespace muhammara {
 
     encrypt(options?: Recipe.EncryptOptions): Recipe;
 
-    registerFont(fontName: string, fontSrcPath: string): Recipe;
+    registerFont(
+      fontName: string,
+      fontSrcPath: string,
+      type?: Recipe.RecipeFontStyle,
+    ): Recipe;
 
     image(
       imgSrc: string,
-      x: number,
-      y: number,
+      x: Recipe.RecipeCoordinate,
+      y: Recipe.RecipeCoordinate,
       options?: Recipe.ImageOptions,
     ): Recipe;
 
@@ -1158,6 +1571,7 @@ declare namespace muhammara {
       srcPageNumber: number,
     ): Recipe;
 
+    overlay(pdfSrc: string, options?: Recipe.OverlayOptions): Recipe;
     overlay(
       pdfSrc: string,
       x: number,
@@ -1175,16 +1589,23 @@ declare namespace muhammara {
       rotation?: number,
       margins?: Recipe.RecipeMargins,
     ): Recipe;
+    rotate(rotation: number): Recipe;
     endPage(): Recipe;
+    setPageBox(
+      box: PDFPageBoxType,
+      left: number,
+      bottom: number,
+      right: number,
+      top: number,
+    ): Recipe;
 
     editPage(pageNumber: number): Recipe;
+    deletePage(pageNumbers: number | number[]): Recipe;
 
-    pageInfo(pageNumber: number): {
-      width: number;
-      height: number;
-      rotate: number;
-      pageNumber: number;
-    };
+    replaceText(text: string, replacement: string, pageNumber: number): Recipe;
+
+    pageInfo(pageNumber: number): RecipePageInfo;
+    getCurrentPageInfo(): RecipePageInfo | null;
 
     margins(): Required<Recipe.RecipeMargins>;
     margins(margins: Recipe.RecipeMargins): Recipe;
@@ -1195,14 +1616,16 @@ declare namespace muhammara {
       bottom?: number,
     ): Recipe;
     getPageInfo(): InfoDictionary;
-    pauseContext(): void;
-    resumeContext(): void;
+    pauseContext(): Recipe;
+    resumeContext(): Recipe;
+    rotateContent(degrees: number, x?: number, y?: number): Recipe;
     split(outputDir?: string, prefix?: string): Recipe;
 
+    text(text: string, options?: Recipe.TextOptions): Recipe;
     text(
       text: string,
-      x: number,
-      y: number,
+      x: Recipe.RecipeCoordinate,
+      y: Recipe.RecipeCoordinate,
       options?: Recipe.TextOptions,
     ): Recipe;
     textDimensions(text: string, options?: Recipe.TextOptions): TextDimension;
@@ -1215,9 +1638,14 @@ declare namespace muhammara {
       y?: number,
       width?: number,
       height?: number,
-      options?: object,
+      options?: Recipe.LayoutOptions,
+    ): Recipe;
+    table<RecordType extends object>(
+      x: number,
+      y: number,
+      contents: readonly RecordType[],
+      options?: Recipe.TableOptions<RecordType>,
     ): Recipe;
-    table(x: number, y: number, contents: object[], options?: object): Recipe;
 
     moveTo(x: number, y: number): Recipe;
 
@@ -1247,7 +1675,7 @@ declare namespace muhammara {
       cy: number,
       rx: number,
       ry: number,
-      options?: Recipe.CircleOptions,
+      options?: Recipe.EllipseOptions,
     ): Recipe;
     arc(
       x: number,
@@ -1255,41 +1683,67 @@ declare namespace muhammara {
       radius: number,
       startAngle?: number,
       endAngle?: number,
-      options?: Recipe.CircleOptions,
+      options?: Recipe.EllipseOptions,
     ): Recipe;
+    pie(
+      x: number,
+      y: number,
+      radius: number,
+      startAngle?: number,
+      endAngle?: number,
+      options?: Recipe.EllipseOptions,
+    ): Recipe;
+    lineStyle(options?: Recipe.LineStyleOptions): Recipe;
     lineWidth(width: number): Recipe;
-    fillOpacity(opacity: number): Recipe;
-    fill(color?: string | number[]): Recipe;
-    stroke(color?: string | number[]): Recipe;
-    fillAndStroke(fill?: string | number[], stroke?: string | number[]): Recipe;
+    /** Set fill and stroke opacity from 0 (transparent) to 1 (opaque). */
+    opacity(opacity: number): Recipe;
+    fill(color?: Recipe.Color): Recipe;
+    stroke(color?: Recipe.Color): Recipe;
+    fillAndStroke(fill?: Recipe.Color, stroke?: Recipe.Color): Recipe;
     n_gon(
       cx: number,
       cy: number,
       radius: number,
-      sides?: number | Recipe.PolygonOptions,
-      options?: Recipe.PolygonOptions,
+      sides?: number | Recipe.NGonOptions,
+      options?: Recipe.NGonOptions,
     ): Recipe;
     star(
       cx: number,
       cy: number,
       radius: number,
-      points?: number | Recipe.PolygonOptions,
-      options?: Recipe.PolygonOptions,
+      points?: number | Recipe.ShapeOptions,
+      options?: Recipe.ShapeOptions,
     ): Recipe;
     triangle(
       x: number,
       y: number,
-      traits: number[] | number[][],
-      options?: Recipe.PolygonOptions,
+      traits: Recipe.TriangleMeasurements,
+      options?: Recipe.TriangleMeasurementOptions,
+    ): Recipe;
+    triangle(
+      x: number,
+      y: number,
+      traits: Recipe.TriangleVertices,
+      options: Recipe.TriangleUnpositionedVertexOptions,
+    ): Recipe;
+    triangle(
+      x: number,
+      y: number,
+      traits: Recipe.MutableTriangleVertices,
+      options: Recipe.TriangleVertexOptions,
+    ): Recipe;
+    arrow(x: number, y: number, options?: Recipe.ArrowOptions): Recipe;
+    chroma<ColorspaceValue extends string | undefined = undefined>(
+      name: string,
+      value: Recipe.Color,
+      colorspace?: Recipe.ValidColorspace<ColorspaceValue>,
     ): Recipe;
-    arrow(x: number, y: number, options?: Recipe.PolygonOptions): Recipe;
-    chroma(name: string, value: string | number[], colorspace?: string): Recipe;
-    permission(flags?: string): number;
+    permission(flags?: Recipe.PermissionList): number;
     structure(output: string): Recipe;
     htmlToTextObjects(
       htmlCodes: string,
       options?: Recipe.TextOptions,
-    ): object[];
+    ): Recipe.HtmlTextObject[];
 
     endPDF(): void;
     endPDF<T>(callback: (output?: Buffer | string) => T): T;