pdfdancer-client-typescript 1.0.4 → 1.0.6

package/src/{client-v1.ts → pdfdancer_v1.ts}

@@ -31,7 +31,153 @@ import {
     ShapeType
 } from './models';
 import {ParagraphBuilder} from './paragraph-builder';
+import {FormFieldObject, FormXObject, ImageObject, ParagraphObject, PathObject, TextLineObject} from "./types";
+import {ImageBuilder} from "./image-builder";
+import fs from "fs";
 
+// 👇 Internal view of PDFDancer methods, not exported
+interface PDFDancerInternals {
+
+    toImageObjects(objectRefs: ObjectRef[]): ImageObject[];
+
+    toPathObjects(objectRefs: ObjectRef[]): PathObject[];
+
+    toFormXObjects(objectRefs: ObjectRef[]): FormXObject[];
+
+    deletePage(objectRef: ObjectRef): Promise<boolean>;
+
+    toTextLineObjects(objectRefs: ObjectRef[]): TextLineObject[];
+
+    toFormFields(formFieldRefs: FormFieldRef[]): FormFieldObject[];
+
+    toParagraphObjects(objectRefs: ObjectRef[]): ParagraphObject[];
+
+    findFormFields(position?: Position): Promise<FormFieldRef[]>;
+
+    findPaths(position?: Position): Promise<ObjectRef[]>;
+
+    findFormXObjects(position?: Position): Promise<ObjectRef[]>;
+
+    findParagraphs(position?: Position): Promise<ObjectRef[]>;
+
+    findTextLines(pos?: Position): Promise<ObjectRef[]>;
+
+    _findImages(position?: Position): Promise<ObjectRef[]>;
+}
+
+class PageClient {
+
+    private _pageIndex: number;
+    private _client: PDFDancer;
+    type: ObjectType = ObjectType.PAGE;
+    position: Position;
+    internalId: string;
+    private _internals: PDFDancerInternals;
+
+    constructor(client: PDFDancer, pageIndex: number) {
+        this._client = client;
+        this._pageIndex = pageIndex;
+        this.internalId = `PAGE-${this._pageIndex}`;
+        this.position = Position.atPage(this._pageIndex);
+        // Cast to the internal interface to get access
+        this._internals = this._client as unknown as PDFDancerInternals;
+    }
+
+    async selectPathsAt(x: number, y: number) {
+        return this._internals.toPathObjects(await this._internals.findPaths(Position.atPageCoordinates(this._pageIndex, x, y)));
+    }
+
+    async selectImages() {
+        return this._internals.toImageObjects(await this._internals._findImages(Position.atPage(this._pageIndex)));
+    }
+
+    async selectImagesAt(x: number, y: number) {
+        return this._internals.toImageObjects(await this._internals._findImages(Position.atPageCoordinates(this._pageIndex, x, y)));
+    }
+
+    async delete() {
+        return this._internals.deletePage(this.ref());
+    }
+
+    private ref() {
+        return new ObjectRef(this.internalId, this.position, this.type);
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    async selectForms() {
+        return this._internals.toFormXObjects(await this._internals.findFormXObjects(Position.atPage(this._pageIndex)));
+    }
+
+    async selectFormsAt(x: number, y: number) {
+        return this._internals.toFormXObjects(await this._internals.findFormXObjects(Position.atPageCoordinates(this._pageIndex, x, y)));
+    }
+
+    async selectFormFields() {
+        return this._internals.toFormFields(await this._internals.findFormFields(Position.atPage(this._pageIndex)));
+    }
+
+    async selectFormFieldsAt(x: number, y: number) {
+        return this._internals.toFormFields(await this._internals.findFormFields(Position.atPageCoordinates(this._pageIndex, x, y)));
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    async selectFormFieldsByName(fieldName: string) {
+        let pos = Position.atPage(this._pageIndex);
+        pos.name = fieldName;
+        return this._internals.toFormFields(await this._internals.findFormFields(pos));
+    }
+
+    async selectParagraphs() {
+        return this._internals.toParagraphObjects(await this._internals.findParagraphs(Position.atPage(this._pageIndex)));
+    }
+
+    async selectParagraphsStartingWith(text: string) {
+        let pos = Position.atPage(this._pageIndex);
+        pos.textStartsWith = text;
+        return this._internals.toParagraphObjects(await this._internals.findParagraphs(pos));
+    }
+
+    async selectParagraphsMatching(pattern: string) {
+        let pos = Position.atPage(this._pageIndex);
+        pos.textPattern = pattern;
+        return this._internals.toParagraphObjects(await this._internals.findParagraphs(pos));
+    }
+
+    async selectParagraphsAt(x: number, y: number) {
+        return this._internals.toParagraphObjects(await this._internals.findParagraphs(Position.atPageCoordinates(this._pageIndex, x, y)));
+    }
+
+    async selectTextLinesStartingWith(text: string) {
+        let pos = Position.atPage(this._pageIndex);
+        pos.textStartsWith = text;
+        return this._internals.toTextLineObjects(await this._internals.findTextLines(pos));
+    }
+
+    /**
+     * Creates a new ParagraphBuilder for fluent paragraph construction.
+     */
+    newParagraph(): ParagraphBuilder {
+        return new ParagraphBuilder(this._client, this.position.pageIndex);
+    }
+
+    async selectTextLines() {
+        return this._internals.toTextLineObjects(await this._internals.findTextLines(Position.atPage(this._pageIndex)));
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    async selectTextLinesMatching(pattern: string) {
+        let pos = Position.atPage(this._pageIndex);
+        pos.textPattern = pattern;
+        return this._internals.toTextLineObjects(await this._internals.findTextLines(pos));
+    }
+
+    // noinspection JSUnusedGlobalSymbols
+    async selectTextLinesAt(x: number, y: number) {
+        return this._internals.toTextLineObjects(await this._internals.findTextLines(Position.atPageCoordinates(this._pageIndex, x, y)));
+    }
+}
+
+// noinspection ExceptionCaughtLocallyJS,JSUnusedLocalSymbols
 /**
  * REST API client for interacting with the PDFDancer PDF manipulation service.
  * This client provides a convenient TypeScript interface for performing PDF operations
@@ -39,7 +185,7 @@ import {ParagraphBuilder} from './paragraph-builder';
  * Handles authentication, session lifecycle, and HTTP communication transparently.
  *
  */
-export class ClientV1 {
+export class PDFDancer {
     private _token: string;
     private _baseUrl: string;
     private _readTimeout: number;
@@ -48,10 +194,10 @@ export class ClientV1 {
 
     /**
      * Creates a new client with PDF data.
-     * This constructor initializes the client, uploads the PDF data to create
+     * This constructor initializes the client, uploads the PDF data to open
      * a new session, and prepares the client for PDF manipulation operations.
      */
-    constructor(
+    private constructor(
         token: string,
         pdfData: Uint8Array | File | ArrayBuffer,
         baseUrl: string = "http://localhost:8080",
@@ -78,8 +224,19 @@ export class ClientV1 {
         return this;
     }
 
-    static async create(token: string, pdfData: Uint8Array, baseUrl: string, timeout: number = 0): Promise<ClientV1> {
-        const client = new ClientV1(token, pdfData, baseUrl, timeout);
+    static async open(pdfData: Uint8Array, token?: string, baseUrl?: string, timeout?: number): Promise<PDFDancer> {
+        const resolvedToken = token ?? process.env.PDFDANCER_TOKEN;
+        const resolvedBaseUrl =
+            baseUrl ??
+            process.env.PDFDANCER_BASE_URL ??
+            "https://api.pdfdancer.com";
+        const resolvedTimeout = timeout ?? 30000;
+
+        if (!resolvedToken) {
+            throw new Error("Missing PDFDancer token (pass it explicitly or set PDFDANCER_TOKEN in environment).");
+        }
+
+        const client = new PDFDancer(resolvedToken, pdfData, resolvedBaseUrl, resolvedTimeout);
         return await client.init();
     }
 
@@ -272,7 +429,7 @@ export class ClientV1 {
      * This method provides flexible search capabilities across all PDF content,
      * allowing filtering by object type and position constraints.
      */
-    async find(objectType?: ObjectType, position?: Position): Promise<ObjectRef[]> {
+    private async find(objectType?: ObjectType, position?: Position): Promise<ObjectRef[]> {
         const requestData = new FindRequest(objectType, position).toDict();
         const response = await this._makeRequest('POST', '/pdf/find', requestData);
 
@@ -283,35 +440,55 @@ export class ClientV1 {
     /**
      * Searches for paragraph objects at the specified position.
      */
-    async findParagraphs(position?: Position): Promise<ObjectRef[]> {
+    private async findParagraphs(position?: Position): Promise<ObjectRef[]> {
         return this.find(ObjectType.PARAGRAPH, position);
     }
 
     /**
      * Searches for image objects at the specified position.
      */
-    async findImages(position?: Position): Promise<ObjectRef[]> {
+    private async _findImages(position?: Position): Promise<ObjectRef[]> {
         return this.find(ObjectType.IMAGE, position);
     }
 
+    async selectImages(): Promise<ImageObject[]> {
+        return this.toImageObjects(await this.find(ObjectType.IMAGE));
+    }
+
     /**
      * Searches for form X objects at the specified position.
      */
-    async findFormXObjects(position?: Position): Promise<ObjectRef[]> {
+    private async findFormXObjects(position?: Position): Promise<ObjectRef[]> {
         return this.find(ObjectType.FORM_X_OBJECT, position);
     }
 
     /**
      * Searches for vector path objects at the specified position.
      */
-    async findPaths(position?: Position): Promise<ObjectRef[]> {
+    private async findPaths(position?: Position): Promise<ObjectRef[]> {
         return this.find(ObjectType.PATH, position);
     }
 
+    async selectPaths() {
+        return this.toPathObjects(await this.find(ObjectType.PATH));
+    }
+
+    async selectForms() {
+        return this.toFormXObjects(await this.find(ObjectType.FORM_X_OBJECT));
+    }
+
+    async selectFormFields() {
+        return this.toFormFields(await this.findFormFields());
+    }
+
+    async selectFieldsByName(fieldName: string) {
+        return this.toFormFields(await this.findFormFields(Position.byName(fieldName)));
+    }
+
     /**
      * Searches for text line objects at the specified position.
      */
-    async findTextLines(position?: Position): Promise<ObjectRef[]> {
+    private async findTextLines(position?: Position): Promise<ObjectRef[]> {
         return this.find(ObjectType.TEXT_LINE, position);
     }
 
@@ -319,7 +496,7 @@ export class ClientV1 {
      * Searches for form fields at the specified position.
      * Returns FormFieldRef objects with name and value properties.
      */
-    async findFormFields(position?: Position): Promise<FormFieldRef[]> {
+    private async findFormFields(position?: Position): Promise<FormFieldRef[]> {
         const requestData = new FindRequest(ObjectType.FORM_FIELD, position).toDict();
         const response = await this._makeRequest('POST', '/pdf/find', requestData);
 
@@ -332,7 +509,7 @@ export class ClientV1 {
     /**
      * Retrieves references to all pages in the PDF document.
      */
-    async getPages(): Promise<ObjectRef[]> {
+    private async getPages(): Promise<ObjectRef[]> {
         const response = await this._makeRequest('POST', '/pdf/page/find');
         const pagesData = await response.json() as any[];
         return pagesData.map((pageData: any) => this._parseObjectRef(pageData));
@@ -341,7 +518,7 @@ export class ClientV1 {
     /**
      * Retrieves a reference to a specific page by its page index.
      */
-    async getPage(pageIndex: number): Promise<ObjectRef | null> {
+    private async _getPage(pageIndex: number): Promise<ObjectRef | null> {
         if (pageIndex < 0) {
             throw new ValidationException(`Page index must be >= 0, got ${pageIndex}`);
         }
@@ -360,7 +537,7 @@ export class ClientV1 {
     /**
      * Deletes a page from the PDF document.
      */
-    async deletePage(pageRef: ObjectRef): Promise<boolean> {
+    private async deletePage(pageRef: ObjectRef): Promise<boolean> {
         if (!pageRef) {
             throw new ValidationException("Page reference cannot be null");
         }
@@ -375,7 +552,7 @@ export class ClientV1 {
     /**
      * Deletes the specified PDF object from the document.
      */
-    async delete(objectRef: ObjectRef): Promise<boolean> {
+    private async delete(objectRef: ObjectRef): Promise<boolean> {
         if (!objectRef) {
             throw new ValidationException("Object reference cannot be null");
         }
@@ -388,7 +565,7 @@ export class ClientV1 {
     /**
      * Moves a PDF object to a new position within the document.
      */
-    async move(objectRef: ObjectRef, position: Position): Promise<boolean> {
+    private async move(objectRef: ObjectRef, position: Position): Promise<boolean> {
         if (!objectRef) {
             throw new ValidationException("Object reference cannot be null");
         }
@@ -404,7 +581,7 @@ export class ClientV1 {
     /**
      * Changes the value of a form field.
      */
-    async changeFormField(formFieldRef: FormFieldRef, newValue: string): Promise<boolean> {
+    private async changeFormField(formFieldRef: FormFieldRef, newValue: string): Promise<boolean> {
         if (!formFieldRef) {
             throw new ValidationException("Form field reference cannot be null");
         }
@@ -419,7 +596,7 @@ export class ClientV1 {
     /**
      * Adds an image to the PDF document.
      */
-    async addImage(image: Image, position?: Position): Promise<boolean> {
+    private async addImage(image: Image, position?: Position): Promise<boolean> {
         if (!image) {
             throw new ValidationException("Image cannot be null");
         }
@@ -438,7 +615,7 @@ export class ClientV1 {
     /**
      * Adds a paragraph to the PDF document.
      */
-    async addParagraph(paragraph: Paragraph): Promise<boolean> {
+    private async addParagraph(paragraph: Paragraph): Promise<boolean> {
         if (!paragraph) {
             throw new ValidationException("Paragraph cannot be null");
         }
@@ -469,7 +646,7 @@ export class ClientV1 {
     /**
      * Modifies a paragraph object or its text content.
      */
-    async modifyParagraph(objectRef: ObjectRef, newParagraph: Paragraph | string): Promise<boolean> {
+    private async modifyParagraph(objectRef: ObjectRef, newParagraph: Paragraph | string): Promise<boolean> {
         if (!objectRef) {
             throw new ValidationException("Object reference cannot be null");
         }
@@ -493,7 +670,7 @@ export class ClientV1 {
     /**
      * Modifies a text line object.
      */
-    async modifyTextLine(objectRef: ObjectRef, newText: string): Promise<boolean> {
+    private async modifyTextLine(objectRef: ObjectRef, newText: string): Promise<boolean> {
         if (!objectRef) {
             throw new ValidationException("Object reference cannot be null");
         }
@@ -594,42 +771,18 @@ export class ClientV1 {
         return new Uint8Array(await response.arrayBuffer());
     }
 
-    async getXmlFile(): Promise<String> {
-        const response = await fetch(`${this._baseUrl}/xml`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${this._token}`,
-                'X-Session-Id': this._sessionId
-            },
-            signal: AbortSignal.timeout(30000)
-        });
-        return response.text()
-    }
-
     /**
      * Saves the current PDF to a file (browser environment).
      * Downloads the PDF in the browser.
      */
-    async savePdf(filename: string = 'document.pdf'): Promise<void> {
+    async save(filename: string): Promise<void> {
         if (!filename) {
             throw new ValidationException("Filename cannot be null or empty");
         }
 
         try {
             const pdfData = await this.getPdfFile();
-
-            // Create blob and download link
-            const blob = new Blob([pdfData.buffer as ArrayBuffer], {type: 'application/pdf'});
-            const url = URL.createObjectURL(blob);
-
-            const link = document.createElement('a');
-            link.href = url;
-            link.download = filename;
-            document.body.appendChild(link);
-            link.click();
-            document.body.removeChild(link);
-
-            URL.revokeObjectURL(url);
+            fs.writeFileSync(filename, pdfData);
         } catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             throw new PdfDancerException(`Failed to save PDF file: ${errorMessage}`, error as Error);
@@ -699,10 +852,52 @@ export class ClientV1 {
 
     // Builder Pattern Support
 
-    /**
-     * Creates a new ParagraphBuilder for fluent paragraph construction.
-     */
-    paragraphBuilder(): ParagraphBuilder {
-        return new ParagraphBuilder(this);
+
+    private toPathObjects(objectRefs: ObjectRef[]) {
+        return objectRefs.map(ref => PathObject.fromRef(this, ref));
+    }
+
+    private toFormXObjects(objectRefs: ObjectRef[]) {
+        return objectRefs.map(ref => FormXObject.fromRef(this, ref));
+    }
+
+    private toImageObjects(objectRefs: ObjectRef[]) {
+        return objectRefs.map(ref => ImageObject.fromRef(this, ref));
+    }
+
+    newImage() {
+        return new ImageBuilder(this);
+    }
+
+    page(pageIndex: number) {
+        if (pageIndex < 0) {
+            throw new ValidationException(`Page index must be >= 0, got ${pageIndex}`);
+        }
+        return new PageClient(this, pageIndex);
+    }
+
+    async pages() {
+        let pageRefs = await this.getPages();
+        return pageRefs.map((_, pageIndex) => new PageClient(this, pageIndex));
+    }
+
+    private toFormFields(objectRefs: FormFieldRef[]) {
+        return objectRefs.map(ref => FormFieldObject.fromRef(this, ref));
+    }
+
+    async selectParagraphs() {
+        return this.toParagraphObjects(await this.findParagraphs());
+    }
+
+    private toParagraphObjects(objectRefs: ObjectRef[]) {
+        return objectRefs.map(ref => ParagraphObject.fromRef(this, ref));
+    }
+
+    private toTextLineObjects(objectRefs: ObjectRef[]) {
+        return objectRefs.map(ref => TextLineObject.fromRef(this, ref));
+    }
+
+    async selectLines() {
+        return this.toTextLineObjects(await this.findTextLines());
     }
 }

package/src/types.ts

@@ -0,0 +1,133 @@
+import {FormFieldRef, ObjectRef, ObjectType, Position} from "./models";
+import {PDFDancer} from "./pdfdancer_v1";
+import {ParagraphBuilder} from "./paragraph-builder";
+
+// 👇 Internal view of PDFDancer methods, not exported
+interface PDFDancerInternals {
+    delete(objectRef: ObjectRef): Promise<boolean>;
+
+    move(objectRef: ObjectRef, position: Position): Promise<boolean>;
+
+    changeFormField(formFieldRef: FormFieldRef, value: string): Promise<boolean>;
+
+    modifyTextLine(objectRef: ObjectRef, newText: string): Promise<boolean>;
+}
+
+export class BaseObject<TRef extends ObjectRef = ObjectRef> {
+
+    _client: PDFDancer;
+
+    internalId: string;
+    type: ObjectType;
+    position: Position;
+    protected _internals: PDFDancerInternals;
+
+    constructor(client: PDFDancer, internalId: string, type: ObjectType, position: Position) {
+        this.internalId = internalId;
+        this.type = type;
+        this.position = position;
+        this._client = client;
+        this._internals = this._client as unknown as PDFDancerInternals;
+    }
+
+    async delete() {
+        return this._internals.delete(this.ref());
+    }
+
+    protected ref(): TRef {
+        return new ObjectRef(this.internalId, this.position, this.type) as TRef;
+    }
+
+    async moveTo(x: number, y: number) {
+        return this._internals.move(this.ref(), Position.atPageCoordinates(this.position.pageIndex!, x, y));
+    }
+}
+
+export class PathObject extends BaseObject {
+
+    static fromRef(_client: PDFDancer, objectRef: ObjectRef) {
+        return new PathObject(_client, objectRef.internalId, objectRef.type, objectRef.position);
+    }
+}
+
+export class ImageObject extends BaseObject {
+
+    static fromRef(_client: PDFDancer, objectRef: ObjectRef) {
+        return new ImageObject(_client, objectRef.internalId, objectRef.type, objectRef.position);
+    }
+}
+
+export class FormXObject extends BaseObject {
+
+    static fromRef(_client: PDFDancer, objectRef: ObjectRef) {
+        return new FormXObject(_client, objectRef.internalId, objectRef.type, objectRef.position);
+    }
+}
+
+export class FormFieldObject extends BaseObject<FormFieldRef> {
+    name: string;
+    value: string | null;
+
+    constructor(client: PDFDancer, internalId: string, type: ObjectType, position: Position, name: string, value: string | null) {
+        super(client, internalId, type, position);
+        this.name = name;
+        this.value = value;
+    }
+
+    async fill(value: string) {
+        return await this._internals.changeFormField(this.ref(), value);
+    }
+
+    protected ref() {
+        return new FormFieldRef(this.internalId, this.position, this.type, this.name, this.value);
+    }
+
+    static fromRef(_client: PDFDancer, objectRef: FormFieldRef) {
+        return new FormFieldObject(_client, objectRef.internalId, objectRef.type, objectRef.position, objectRef.name, objectRef.value);
+    }
+}
+
+export class ParagraphObject extends BaseObject {
+
+    static fromRef(_client: PDFDancer, objectRef: ObjectRef) {
+        return new ParagraphObject(_client, objectRef.internalId, objectRef.type, objectRef.position);
+    }
+
+    edit() {
+        return new ParagraphBuilder(this._client, this.ref());
+    }
+}
+
+export class TextLineObject extends BaseObject {
+    static fromRef(_client: PDFDancer, objectRef: ObjectRef) {
+        return new TextLineObject(_client, objectRef.internalId, objectRef.type, objectRef.position);
+    }
+
+    edit() {
+        return new TextLineBuilder(this._client, this.ref());
+    }
+}
+
+
+class TextLineBuilder {
+
+    private _text: string | undefined;
+    private _objectRef: ObjectRef;
+    private _client: PDFDancer
+    private _internals: PDFDancerInternals;
+
+    constructor(client: PDFDancer, objectRef: ObjectRef) {
+        this._objectRef = objectRef;
+        this._client = client;
+        this._internals = this._client as unknown as PDFDancerInternals;
+    }
+
+    text(newText: string) {
+        this._text = newText;
+        return this;
+    }
+
+    async apply() {
+        return await this._internals.modifyTextLine(this._objectRef, this._text!);
+    }
+}

package/example.ts

@@ -1,99 +0,0 @@
-/**
- * Example usage of the PDFDancer TypeScript client
- */
-
-import {
-  ClientV1,
-  Position,
-  Color,
-  Font,
-  ValidationException,
-  HttpClientException
-} from './src/index';
-
-async function exampleUsage() {
-  try {
-    // Create a sample PDF data (in a real application, this would be loaded from a file)
-    const pdfData = new Uint8Array([
-      0x25, 0x50, 0x44, 0x46, // %PDF header
-      // ... rest of PDF data would go here
-    ]);
-
-    // Initialize the client with authentication token and PDF data
-    const client = await ClientV1.create('your-auth-token', pdfData, 'http://localhost:8080', 30000);
-
-    // Example 1: Find all paragraphs on page 1
-    const page1Position = Position.atPage(1);
-    const paragraphs = await client.findParagraphs(page1Position);
-    console.log(`Found ${paragraphs.length} paragraphs on page 1`);
-
-    // Example 2: Add a new paragraph using the builder pattern
-    const newParagraph = client.paragraphBuilder()
-      .fromString('Hello, PDFDancer!', new Color(255, 0, 0)) // Red text
-      .withFont(new Font('Arial', 12))
-      .withPosition(Position.atPageCoordinates(1, 100, 200))
-      .withLineSpacing(1.5)
-      .build();
-
-    await client.addParagraph(newParagraph);
-    console.log('Added new paragraph successfully');
-
-    // Example 3: Find and modify existing text
-    const textLines = await client.findTextLines(page1Position);
-    if (textLines.length > 0) {
-      await client.modifyTextLine(textLines[0], 'Modified text content');
-      console.log('Modified first text line');
-    }
-
-    // Example 4: Get the modified PDF
-    const modifiedPdf = await client.getPdfFile();
-    console.log(`Generated PDF size: ${modifiedPdf.length} bytes`);
-
-    // Example 5: Save PDF (in browser environment)
-    // await client.savePdf('modified-document.pdf');
-
-  } catch (error) {
-    if (error instanceof ValidationException) {
-      console.error('Validation error:', error.message);
-    } else if (error instanceof HttpClientException) {
-      console.error('HTTP error:', error.message, 'Status:', error.statusCode);
-    } else {
-      console.error('Unexpected error:', error);
-    }
-  }
-}
-
-// Example of using with custom font
-async function exampleWithCustomFont() {
-  try {
-    const pdfData = new Uint8Array([0x25, 0x50, 0x44, 0x46]);
-    const client = await ClientV1.create('your-auth-token', pdfData, undefined, 30000);
-
-    // Register a custom font (example with dummy TTF data)
-    const customFontData = new Uint8Array([/* TTF font data here */]);
-    const fontName = await client.registerFont(customFontData);
-    console.log(`Registered font: ${fontName}`);
-
-    // Use the custom font in a paragraph
-    const paragraph = client.paragraphBuilder()
-      .fromString('Text with custom font')
-      .withFont(new Font(fontName, 14))
-      .withPosition(Position.atPageCoordinates(1, 50, 300))
-      .build();
-
-    await client.addParagraph(paragraph);
-    console.log('Added paragraph with custom font');
-
-  } catch (error) {
-    console.error('Error with custom font:', error);
-  }
-}
-
-// Note: These examples show the API usage patterns.
-// In a real application, you would need:
-// 1. A valid authentication token
-// 2. Actual PDF data
-// 3. A running PDFDancer server at the specified URL
-// 4. Proper error handling for your use case
-
-export { exampleUsage, exampleWithCustomFont };