n8n-nodes-uvpdftool 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 UV ResearchLabs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,33 @@
-# Temporary Holding Version
+# n8n-nodes-uvpdftool
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An [n8n](https://n8n.io) community node for the [UV pdfTool API](https://uvpdftool.com/developers):
+compress, convert, OCR and check PDFs in a workflow, on UV pdfTool's servers. It needs nothing at
+run time but n8n itself.
+
+## Install
+
+In n8n: **Settings → Community nodes → Install**, and enter `n8n-nodes-uvpdftool`. On a
+self-hosted n8n you can also run `npm install n8n-nodes-uvpdftool` in `~/.n8n/nodes`.
+
+Then add a **UV pdfTool API** credential with a key from the
+[API keys page](https://uvpdftool.com/developers/keys); a test key is free and marks its results.
+
+## The node
+
+**UV pdfTool** runs one tool for each incoming item:
+
+| Field                | What it is                                                                                      |
+| -------------------- | ----------------------------------------------------------------------------------------------- |
+| Tool                 | Compress PDF, Office to PDF, PDF to Word or PowerPoint, OCR, PDF to PDF/A, and seven more.      |
+| Input Binary Field   | The binary field of the item that holds the file (`data` by default). Not asked for a web page. |
+| Options              | The tool's options as JSON, such as `{"method": "ghostscript", "preset": "ebook"}`.             |
+| Output Binary Field  | Where each result goes (`data`); a second result gets a number after the name.                  |
+| Wait Up To (Seconds) | How long to wait for the job (600). It goes on after that; the error gives its ID.              |
+
+Each result comes out as a binary field of a new item, with `jobId`, `tool`, `mode` (`live` or
+`test`) and the outputs' names and sizes in its JSON. A failed job stops the workflow with the
+API's reason, such as `PASSWORD_REQUIRED: The file is locked.`, unless the node is set to
+continue on failure, when the item carries `error` instead. A job whose upload failed is
+cancelled at once, so its task comes back.
+
+The tools and their options are listed at <https://uvpdftool.com/developers/tools>.

package/dist/credentials/UvPdfToolApi.credentials.d.ts

@@ -0,0 +1,31 @@
+/** The API key, sent as a bearer token; n8n checks it by asking for the account. */
+export declare class UvPdfToolApi {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: {
+        displayName: string;
+        name: string;
+        type: string;
+        typeOptions: {
+            password: boolean;
+        };
+        default: string;
+        required: boolean;
+        description: string;
+    }[];
+    authenticate: {
+        readonly type: "generic";
+        readonly properties: {
+            readonly headers: {
+                readonly Authorization: "=Bearer {{$credentials.apiKey}}";
+            };
+        };
+    };
+    test: {
+        request: {
+            baseURL: string;
+            url: string;
+        };
+    };
+}

package/dist/credentials/UvPdfToolApi.credentials.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UvPdfToolApi = void 0;
+const run_job_1 = require("../run-job");
+/** The API key, sent as a bearer token; n8n checks it by asking for the account. */
+class UvPdfToolApi {
+    name = 'uvPdfToolApi';
+    displayName = 'UV pdfTool API';
+    documentationUrl = 'https://uvpdftool.com/developers';
+    properties = [
+        {
+            displayName: 'API Key',
+            name: 'apiKey',
+            type: 'string',
+            typeOptions: { password: true },
+            default: '',
+            required: true,
+            description: 'A live key (uvp_live_…) or a test key (uvp_test_…), from https://uvpdftool.com/developers/keys',
+        },
+    ];
+    authenticate = {
+        type: 'generic',
+        properties: { headers: { Authorization: '=Bearer {{$credentials.apiKey}}' } },
+    };
+    test = { request: { baseURL: run_job_1.API_BASE, url: '/account' } };
+}
+exports.UvPdfToolApi = UvPdfToolApi;

package/dist/n8n-types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The shapes of n8n's node interface that this package uses, written out here so that the
+ * package needs nothing of n8n's at run time and only these few types to build: n8n passes
+ * objects of these shapes in, and reads the classes' fields as it does any node's.
+ */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export interface IBinaryData {
+    data: string;
+    mimeType: string;
+    fileName?: string;
+    fileExtension?: string;
+}
+export interface INodeExecutionData {
+    json: Record<string, unknown>;
+    binary?: Record<string, IBinaryData>;
+    pairedItem?: {
+        item: number;
+    };
+}
+export interface IHttpRequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    url: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    json?: boolean;
+    encoding?: 'arraybuffer';
+    returnFullResponse?: boolean;
+    timeout?: number;
+}
+export interface IExecuteFunctions {
+    getInputData: () => INodeExecutionData[];
+    getNodeParameter: (name: string, itemIndex: number, fallback?: unknown) => unknown;
+    continueOnFail: () => boolean;
+    helpers: {
+        httpRequest: (options: IHttpRequestOptions) => Promise<unknown>;
+        httpRequestWithAuthentication: (this: IExecuteFunctions, credentialsType: string, options: IHttpRequestOptions) => Promise<unknown>;
+        assertBinaryData: (itemIndex: number, propertyName: string) => IBinaryData;
+        getBinaryDataBuffer: (itemIndex: number, propertyName: string) => Promise<Buffer>;
+        prepareBinaryData: (data: Buffer, fileName?: string, mimeType?: string) => Promise<IBinaryData>;
+    };
+}

package/dist/n8n-types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * The shapes of n8n's node interface that this package uses, written out here so that the
+ * package needs nothing of n8n's at run time and only these few types to build: n8n passes
+ * objects of these shapes in, and reads the classes' fields as it does any node's.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nodes/UvPdfTool/UvPdfTool.node.d.ts

@@ -0,0 +1,87 @@
+import type { IExecuteFunctions, INodeExecutionData } from '../../n8n-types';
+/**
+ * Runs one UV pdfTool tool for each item: the file in its binary field goes up, the job runs
+ * on UV pdfTool's servers, and each result comes back as a binary field of a new item, with
+ * the job's id, tool and mode beside it.
+ */
+export declare class UvPdfTool {
+    description: {
+        displayName: string;
+        name: string;
+        icon: string;
+        group: string[];
+        version: number;
+        subtitle: string;
+        description: string;
+        defaults: {
+            name: string;
+        };
+        inputs: string[];
+        outputs: string[];
+        usableAsTool: boolean;
+        credentials: {
+            name: string;
+            required: boolean;
+        }[];
+        requestDefaults: {
+            baseURL: string;
+        };
+        properties: ({
+            displayName: string;
+            name: string;
+            type: string;
+            noDataExpression: boolean;
+            options: {
+                name: "Compress PDF" | "Office to PDF" | "PDF to Word or PowerPoint" | "OCR (make a scan searchable)" | "PDF to PDF/A" | "Check PDF/A and PDF/UA" | "Repair PDF" | "HTML to PDF" | "Markdown to PDF" | "EPUB to PDF" | "PDF to SVG" | "Web page to PDF";
+                value: "compress" | "office-to-pdf" | "pdf-to-office" | "ocr" | "pdf-to-pdfa" | "pdfa-check" | "repair" | "html-to-pdf" | "markdown-to-pdf" | "epub-to-pdf" | "pdf-to-svg" | "web-to-pdf";
+                description: string;
+            }[];
+            default: string;
+            required?: undefined;
+            description?: undefined;
+            displayOptions?: undefined;
+            typeOptions?: undefined;
+        } | {
+            displayName: string;
+            name: string;
+            type: string;
+            default: string;
+            required: boolean;
+            description: string;
+            displayOptions: {
+                hide: {
+                    tool: string[];
+                };
+            };
+            noDataExpression?: undefined;
+            options?: undefined;
+            typeOptions?: undefined;
+        } | {
+            displayName: string;
+            name: string;
+            type: string;
+            default: string;
+            description: string;
+            noDataExpression?: undefined;
+            options?: undefined;
+            required?: undefined;
+            displayOptions?: undefined;
+            typeOptions?: undefined;
+        } | {
+            displayName: string;
+            name: string;
+            type: string;
+            typeOptions: {
+                minValue: number;
+                maxValue: number;
+            };
+            default: number;
+            description: string;
+            noDataExpression?: undefined;
+            options?: undefined;
+            required?: undefined;
+            displayOptions?: undefined;
+        })[];
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/UvPdfTool/UvPdfTool.node.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UvPdfTool = void 0;
+const run_job_1 = require("../../run-job");
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+/** The node's options, as JSON text or an object (an expression gives either). */
+function optionsOf(value) {
+    const parsed = typeof value === 'string' ? (value.trim() === '' ? {} : JSON.parse(value)) : value;
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new run_job_1.JobError('Options must be a JSON object, as https://uvpdftool.com/developers/tools lists them.');
+    }
+    return parsed;
+}
+/**
+ * Runs one UV pdfTool tool for each item: the file in its binary field goes up, the job runs
+ * on UV pdfTool's servers, and each result comes back as a binary field of a new item, with
+ * the job's id, tool and mode beside it.
+ */
+class UvPdfTool {
+    description = {
+        displayName: 'UV pdfTool',
+        name: 'uvPdfTool',
+        icon: 'file:uvpdftool.png',
+        group: ['transform'],
+        version: 1,
+        subtitle: '={{$parameter["tool"]}}',
+        description: 'Compress, convert, OCR and check PDFs on UV pdfTool’s servers',
+        defaults: { name: 'UV pdfTool' },
+        inputs: ['main'],
+        outputs: ['main'],
+        usableAsTool: true,
+        credentials: [{ name: 'uvPdfToolApi', required: true }],
+        requestDefaults: { baseURL: run_job_1.API_BASE },
+        properties: [
+            {
+                displayName: 'Tool',
+                name: 'tool',
+                type: 'options',
+                noDataExpression: true,
+                options: run_job_1.TOOLS.map((tool) => ({
+                    name: tool.name,
+                    value: tool.id,
+                    description: `Takes ${tool.takes}`,
+                })),
+                default: 'compress',
+            },
+            {
+                displayName: 'Input Binary Field',
+                name: 'binaryPropertyName',
+                type: 'string',
+                default: 'data',
+                required: true,
+                description: 'The binary field of the incoming item that holds the file',
+                displayOptions: { hide: { tool: ['web-to-pdf'] } },
+            },
+            {
+                displayName: 'Options',
+                name: 'options',
+                type: 'json',
+                default: '{}',
+                description: 'The tool’s options as JSON, for example {"method": "ghostscript", "preset": "ebook"}; each tool’s are listed at https://uvpdftool.com/developers/tools',
+            },
+            {
+                displayName: 'Output Binary Field',
+                name: 'outputPropertyName',
+                type: 'string',
+                default: 'data',
+                description: 'The binary field each result is put in; a second result gets a number after it',
+            },
+            {
+                displayName: 'Wait Up To (Seconds)',
+                name: 'waitSeconds',
+                type: 'number',
+                typeOptions: { minValue: 10, maxValue: 3600 },
+                default: 600,
+                description: 'How long to wait for the job; it goes on after, and the error gives its ID',
+            },
+        ],
+    };
+    async execute() {
+        const items = this.getInputData();
+        const results = [];
+        const http = {
+            api: (method, path, body) => this.helpers.httpRequestWithAuthentication.call(this, 'uvPdfToolApi', {
+                method,
+                url: `${run_job_1.API_BASE}${path}`,
+                json: true,
+                ...(body === undefined ? {} : { body }),
+            }),
+            upload: async (url, headers, data) => {
+                await this.helpers.httpRequest({ method: 'PUT', url, headers, body: data });
+            },
+            download: async (url) => Buffer.from((await this.helpers.httpRequest({ url, encoding: 'arraybuffer' }))),
+            sleep,
+            now: () => Date.now(),
+        };
+        for (let index = 0; index < items.length; index += 1) {
+            try {
+                const tool = this.getNodeParameter('tool', index);
+                const options = optionsOf(this.getNodeParameter('options', index, '{}'));
+                const files = [];
+                if ((0, run_job_1.takesFile)(tool)) {
+                    const field = this.getNodeParameter('binaryPropertyName', index);
+                    const binary = this.helpers.assertBinaryData(index, field);
+                    files.push({
+                        name: binary.fileName ?? 'document',
+                        contentType: binary.mimeType,
+                        data: await this.helpers.getBinaryDataBuffer(index, field),
+                    });
+                }
+                const waitSeconds = this.getNodeParameter('waitSeconds', index, 600);
+                const { job, outputs } = await (0, run_job_1.runJob)(http, { tool, options, files }, waitSeconds);
+                const outputField = this.getNodeParameter('outputPropertyName', index, 'data');
+                const binary = {};
+                for (const [number, output] of outputs.entries()) {
+                    binary[number === 0 ? outputField : `${outputField}${String(number + 1)}`] =
+                        await this.helpers.prepareBinaryData(output.data, output.name, output.contentType);
+                }
+                results.push({
+                    json: {
+                        jobId: job.id,
+                        tool: job.tool,
+                        mode: job.mode,
+                        outputs: job.outputs.map((output) => ({
+                            name: output.name,
+                            size: output.size,
+                            contentType: output.contentType,
+                        })),
+                    },
+                    binary,
+                    pairedItem: { item: index },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    results.push({
+                        json: { error: error instanceof Error ? error.message : String(error) },
+                        pairedItem: { item: index },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [results];
+    }
+}
+exports.UvPdfTool = UvPdfTool;

package/dist/run-job.d.ts

@@ -0,0 +1,101 @@
+/**
+ * One job of the UV pdfTool API, from files to results: create it with the files declared,
+ * upload each to the link it gave, start it, wait for it to end, and fetch what it made. The
+ * HTTP comes from the caller, so n8n's own helpers (with its credentials) carry it.
+ */
+export declare const API_BASE = "https://uvpdftool.com/api/v1";
+/** The tools the API runs, by id, with what each takes. */
+export declare const TOOLS: readonly [{
+    readonly id: "compress";
+    readonly name: "Compress PDF";
+    readonly takes: "PDF";
+}, {
+    readonly id: "office-to-pdf";
+    readonly name: "Office to PDF";
+    readonly takes: "Word, Excel, PowerPoint or OpenDocument";
+}, {
+    readonly id: "pdf-to-office";
+    readonly name: "PDF to Word or PowerPoint";
+    readonly takes: "PDF";
+}, {
+    readonly id: "ocr";
+    readonly name: "OCR (make a scan searchable)";
+    readonly takes: "PDF";
+}, {
+    readonly id: "pdf-to-pdfa";
+    readonly name: "PDF to PDF/A";
+    readonly takes: "PDF";
+}, {
+    readonly id: "pdfa-check";
+    readonly name: "Check PDF/A and PDF/UA";
+    readonly takes: "PDF";
+}, {
+    readonly id: "repair";
+    readonly name: "Repair PDF";
+    readonly takes: "PDF";
+}, {
+    readonly id: "html-to-pdf";
+    readonly name: "HTML to PDF";
+    readonly takes: "HTML";
+}, {
+    readonly id: "markdown-to-pdf";
+    readonly name: "Markdown to PDF";
+    readonly takes: "Markdown";
+}, {
+    readonly id: "epub-to-pdf";
+    readonly name: "EPUB to PDF";
+    readonly takes: "EPUB";
+}, {
+    readonly id: "pdf-to-svg";
+    readonly name: "PDF to SVG";
+    readonly takes: "PDF";
+}, {
+    readonly id: "web-to-pdf";
+    readonly name: "Web page to PDF";
+    readonly takes: "nothing: the url option names the page";
+}];
+/** The one tool that takes no file: it fetches the page its options name. */
+export declare const takesFile: (tool: string) => boolean;
+export interface JobFile {
+    name: string;
+    contentType: string;
+    data: Buffer;
+}
+export interface ApiJob {
+    id: string;
+    tool: string;
+    mode: 'live' | 'test';
+    state: 'created' | 'queued' | 'running' | 'done' | 'failed' | 'cancelled';
+    error: {
+        code: string;
+        message: string;
+    } | null;
+    outputs: {
+        name: string;
+        size: number;
+        contentType: string;
+        url?: string;
+    }[];
+}
+export interface Http {
+    /** A call to the API with the key, JSON in and out. */
+    api: (method: 'GET' | 'POST' | 'DELETE', path: string, body?: unknown) => Promise<unknown>;
+    /** A PUT of the bytes to an upload link, with its headers and no key. */
+    upload: (url: string, headers: Record<string, string>, data: Buffer) => Promise<void>;
+    download: (url: string) => Promise<Buffer>;
+    sleep: (ms: number) => Promise<void>;
+    now: () => number;
+}
+/** A job that ended without a result, or a wait that ran out. */
+export declare class JobError extends Error {
+    readonly job?: ApiJob | undefined;
+    constructor(message: string, job?: ApiJob | undefined);
+}
+export declare function runJob(http: Http, request: {
+    tool: string;
+    options: Record<string, unknown>;
+    files: JobFile[];
+}, waitSeconds: number): Promise<{
+    job: ApiJob;
+    outputs: JobFile[];
+}>;

package/dist/run-job.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * One job of the UV pdfTool API, from files to results: create it with the files declared,
+ * upload each to the link it gave, start it, wait for it to end, and fetch what it made. The
+ * HTTP comes from the caller, so n8n's own helpers (with its credentials) carry it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobError = exports.takesFile = exports.TOOLS = exports.API_BASE = void 0;
+exports.runJob = runJob;
+exports.API_BASE = 'https://uvpdftool.com/api/v1';
+/** The tools the API runs, by id, with what each takes. */
+exports.TOOLS = [
+    { id: 'compress', name: 'Compress PDF', takes: 'PDF' },
+    { id: 'office-to-pdf', name: 'Office to PDF', takes: 'Word, Excel, PowerPoint or OpenDocument' },
+    { id: 'pdf-to-office', name: 'PDF to Word or PowerPoint', takes: 'PDF' },
+    { id: 'ocr', name: 'OCR (make a scan searchable)', takes: 'PDF' },
+    { id: 'pdf-to-pdfa', name: 'PDF to PDF/A', takes: 'PDF' },
+    { id: 'pdfa-check', name: 'Check PDF/A and PDF/UA', takes: 'PDF' },
+    { id: 'repair', name: 'Repair PDF', takes: 'PDF' },
+    { id: 'html-to-pdf', name: 'HTML to PDF', takes: 'HTML' },
+    { id: 'markdown-to-pdf', name: 'Markdown to PDF', takes: 'Markdown' },
+    { id: 'epub-to-pdf', name: 'EPUB to PDF', takes: 'EPUB' },
+    { id: 'pdf-to-svg', name: 'PDF to SVG', takes: 'PDF' },
+    { id: 'web-to-pdf', name: 'Web page to PDF', takes: 'nothing: the url option names the page' },
+];
+/** The one tool that takes no file: it fetches the page its options name. */
+const takesFile = (tool) => tool !== 'web-to-pdf';
+exports.takesFile = takesFile;
+/** A job that ended without a result, or a wait that ran out. */
+class JobError extends Error {
+    job;
+    constructor(message, job) {
+        super(message);
+        this.job = job;
+        this.name = 'JobError';
+    }
+}
+exports.JobError = JobError;
+async function runJob(http, request, waitSeconds) {
+    const created = (await http.api('POST', '/jobs', {
+        tool: request.tool,
+        ...(Object.keys(request.options).length > 0 ? { options: request.options } : {}),
+        files: request.files.map((file) => ({
+            name: file.name,
+            size: file.data.length,
+            contentType: file.contentType,
+        })),
+    }));
+    const id = created.job.id;
+    try {
+        for (const [index, upload] of created.uploads.entries()) {
+            const file = request.files[index];
+            if (!file)
+                throw new JobError(`No file for upload ${String(index + 1)}.`);
+            await http.upload(upload.url, upload.headers, file.data);
+        }
+        await http.api('POST', `/jobs/${id}/start`);
+    }
+    catch (error) {
+        // A job without its files would wait twenty minutes for them: end it, and its task returns.
+        await http.api('DELETE', `/jobs/${id}`).catch(() => undefined);
+        throw error;
+    }
+    const deadline = http.now() + waitSeconds * 1000;
+    for (;;) {
+        const { job } = (await http.api('GET', `/jobs/${id}`));
+        if (job.state === 'done') {
+            const outputs = [];
+            for (const output of job.outputs) {
+                if (!output.url)
+                    throw new JobError(`${output.name} has no download link.`, job);
+                outputs.push({
+                    name: output.name,
+                    contentType: output.contentType,
+                    data: await http.download(output.url),
+                });
+            }
+            return { job, outputs };
+        }
+        if (job.state === 'failed' || job.state === 'cancelled') {
+            throw new JobError(job.error ? `${job.error.code}: ${job.error.message}` : `The job ended ${job.state}.`, job);
+        }
+        if (http.now() > deadline) {
+            throw new JobError(`Job ${id} was still ${job.state} after ${String(waitSeconds)} seconds; it goes on, and GET /jobs/${id} has its result.`, job);
+        }
+        await http.sleep(2_000);
+    }
+}

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "n8n-nodes-uvpdftool",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "An n8n node for the UV pdfTool API: compress, convert, OCR and check PDFs in a workflow, on UV pdfTool's servers.",
+  "license": "MIT",
+  "author": "UV ResearchLabs",
+  "homepage": "https://uvpdftool.com/developers",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/uvresearchlab/UV-pdfTool",
+    "directory": "packages/n8n"
+  },
+  "keywords": [
+    "n8n-community-node-package",
+    "pdf",
+    "compress",
+    "ocr",
+    "convert",
+    "pdfa",
+    "uvpdftool"
+  ],
+  "engines": {
+    "node": ">=18.3"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/UvPdfToolApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/UvPdfTool/UvPdfTool.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^24.13.6",
+    "eslint": "^10.11.0",
+    "typescript": "~6.0.3",
+    "typescript-eslint": "^8.70.0",
+    "vitest": "^4.1.12"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node scripts/copy-icons.mjs",
+    "test": "vitest run",
+    "lint": "eslint .",
+    "typecheck": "tsc -p tsconfig.json"
+  }
 }