@adula/kit 0.2.0-alpha.4 → 1.0.0

package/build/src/integrations/imports.js

@@ -0,0 +1,331 @@
+import Papa from 'papaparse';
+import { subject } from '@casl/ability';
+import { buildAbility } from '../auth/ability.js';
+import { KitError } from '../admin/errors.js';
+import { notifyWithTemplate } from '../core/message_templates.js';
+export const IMPORT_ROW_LIMIT = 5000;
+const COLUMN_LIMIT = 100;
+const ERROR_LIMIT = 200;
+const FILE_LIMIT = 5 * 1024 * 1024;
+const UNSUPPORTED = new Set(['hasMany', 'attachment', 'json']);
+const normalize = (value) => value
+    .trim()
+    .toLowerCase()
+    .replace(/[\s_-]+/g, '');
+/** Converts one CSV cell to the field's stored representation, or throws a readable error. */
+export function importCell(field, raw, lookups) {
+    const value = raw.trim();
+    if (value === '')
+        return null;
+    const latin = value.replace(/[٠-٩]/g, (digit) => String(digit.charCodeAt(0) - 0x0660));
+    switch (field.type) {
+        case 'integer':
+        case 'belongsTo': {
+            if (!/^-?\d+$/.test(latin))
+                throw new Error('رقم صحيح مطلوب');
+            return Number(latin);
+        }
+        case 'money': {
+            const plain = latin.replace(/[,٬\s]/g, '').replace('٫', '.');
+            if (!/^-?\d+(\.\d{1,2})?$/.test(plain))
+                throw new Error('مبلغ غير صالح');
+            const [whole, fraction = ''] = plain.replace('-', '').split('.');
+            const minor = BigInt(whole) * 100n + BigInt(fraction.padEnd(2, '0') || '0');
+            return String(plain.startsWith('-') ? -minor : minor);
+        }
+        case 'boolean': {
+            const truthy = ['1', 'true', 'yes', 'نعم', 'صح'];
+            const falsy = ['0', 'false', 'no', 'لا', 'خطأ'];
+            if (truthy.includes(value.toLowerCase()))
+                return true;
+            if (falsy.includes(value.toLowerCase()))
+                return false;
+            throw new Error('قيمة نعم/لا غير صالحة');
+        }
+        case 'date': {
+            const iso = /^(\d{4})-(\d{2})-(\d{2})$/.exec(latin);
+            const local = /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/.exec(latin);
+            const [y, m, d] = iso
+                ? [iso[1], iso[2], iso[3]]
+                : local
+                    ? [local[3], local[2].padStart(2, '0'), local[1].padStart(2, '0')]
+                    : [];
+            const date = y ? new Date(`${y}-${m}-${d}T00:00:00Z`) : null;
+            if (!date || Number.isNaN(date.getTime()) || date.getUTCDate() !== Number(d))
+                throw new Error('تاريخ غير صالح (YYYY-MM-DD أو DD/MM/YYYY)');
+            return `${y}-${m}-${d}`;
+        }
+        case 'datetime': {
+            const date = new Date(latin);
+            if (Number.isNaN(date.getTime()))
+                throw new Error('تاريخ ووقت غير صالحين');
+            return date.toISOString();
+        }
+        case 'lookup': {
+            const key = lookups.get(normalize(value));
+            if (!key)
+                throw new Error('قيمة غير موجودة في القائمة');
+            return key;
+        }
+        default:
+            return value;
+    }
+}
+/**
+ * CSV imports in batches: the upload is parsed and stored, the user maps columns
+ * to writable fields, and a worker saves each row through ResourceService with
+ * the importing user's current permissions. Row failures never stop the batch.
+ */
+export class ImportBatches {
+    db;
+    registry;
+    resources;
+    actors;
+    constructor(db, registry, resources, actors) {
+        this.db = db;
+        this.registry = registry;
+        this.resources = resources;
+        this.actors = actors;
+    }
+    /** Writable, importable fields for this actor. */
+    targets(name, actor) {
+        const resource = this.registry.get(name);
+        const ability = buildAbility(actor.rules, this.registry.all());
+        if (!resource.actions.includes('create') || !ability.can('create', name))
+            throw new KitError(403, 'E_FORBIDDEN', 'ليس لديك صلاحية الإضافة إلى هذا الكيان');
+        const fields = resource.form
+            .filter((key) => {
+            const field = resource.fields[key];
+            return (!UNSUPPORTED.has(field.type) &&
+                !field.sequence &&
+                actor.permissionLevel >=
+                    Math.max(field.permissionLevel ?? 0, resource.hidden?.includes(key) ? 1 : 0) &&
+                ability.can('create', subject(name, {}), key));
+        })
+            .map((key) => ({
+            key,
+            label: resource.fields[key].label.ar,
+            type: resource.fields[key].type,
+            required: Boolean(resource.fields[key].required),
+        }));
+        if (resource.scoped)
+            fields.push({
+                key: 'orgUnitId',
+                label: 'الوحدة التنظيمية (رقم)',
+                type: 'integer',
+                required: true,
+            });
+        return fields;
+    }
+    async create(name, actor, input) {
+        const targets = this.targets(name, actor);
+        const fileName = typeof input.fileName === 'string' ? input.fileName.slice(0, 200) : 'import.csv';
+        if (typeof input.content !== 'string' || !input.content.trim())
+            throw new KitError(422, 'E_IMPORT_FILE', 'الملف فارغ');
+        if (Buffer.byteLength(input.content) > FILE_LIMIT)
+            throw new KitError(422, 'E_IMPORT_FILE', 'حجم الملف يتجاوز 5 ميغابايت');
+        const parsed = Papa.parse(input.content.replace(/^\uFEFF/, ''), {
+            skipEmptyLines: 'greedy',
+        });
+        if (parsed.errors.some((error) => error.type !== 'Delimiter'))
+            throw new KitError(422, 'E_IMPORT_FILE', `تعذر قراءة CSV: ${parsed.errors[0].message}`);
+        const [headers = [], ...rows] = parsed.data;
+        if (!headers.length || headers.length > COLUMN_LIMIT)
+            throw new KitError(422, 'E_IMPORT_FILE', 'يجب أن يحتوي الملف صف عناوين (100 عمود كحد أقصى)');
+        if (!rows.length || rows.length > IMPORT_ROW_LIMIT)
+            throw new KitError(422, 'E_IMPORT_ROWS', `عدد الصفوف بين 1 و${IMPORT_ROW_LIMIT}`);
+        const mapping = {};
+        headers.forEach((header, index) => {
+            const target = targets.find((field) => [field.key, field.label].some((alias) => normalize(alias) === normalize(header)));
+            if (target && !Object.values(mapping).includes(target.key))
+                mapping[String(index)] = target.key;
+        });
+        const [row] = await this.db('import_batches')
+            .insert({
+            resource: name,
+            user_id: actor.id,
+            file_name: fileName,
+            status: 'mapping',
+            headers: JSON.stringify(headers),
+            mapping: JSON.stringify(mapping),
+            rows: JSON.stringify(rows.map((cells) => cells.slice(0, headers.length))),
+            total: rows.length,
+        })
+            .returning('*');
+        return this.present(row, targets);
+    }
+    async show(id, actor) {
+        const row = await this.owned(id, actor);
+        return this.present(row, this.safeTargets(row.resource, actor));
+    }
+    async list(actor) {
+        const rows = await this.db('import_batches')
+            .where('user_id', actor.id)
+            .orderBy('id', 'desc')
+            .limit(50)
+            .select('id', 'resource', 'file_name', 'status', 'headers', 'mapping', 'total', 'processed', 'created', 'failed', 'errors', 'created_at', 'finished_at');
+        return rows.map((row) => this.present({ ...row, rows: [] }, []));
+    }
+    /** Stores the column mapping and queues the batch for the worker. */
+    async start(id, actor, mapping) {
+        const row = await this.owned(id, actor);
+        if (row.status !== 'mapping')
+            throw new KitError(409, 'E_IMPORT_STATE', 'بدأت معالجة هذه الدفعة بالفعل');
+        const targets = this.targets(row.resource, actor);
+        if (!mapping || typeof mapping !== 'object' || Array.isArray(mapping))
+            throw new KitError(422, 'E_IMPORT_MAPPING', 'مطابقة الأعمدة غير صالحة');
+        const clean = {};
+        const used = new Set();
+        for (const [column, key] of Object.entries(mapping)) {
+            if (key === '' || key === null || key === undefined)
+                continue;
+            const index = Number(column);
+            if (!Number.isInteger(index) || index < 0 || index >= row.headers.length)
+                throw new KitError(422, 'E_IMPORT_MAPPING', 'عمود غير موجود');
+            if (typeof key !== 'string' || !targets.some((target) => target.key === key) || used.has(key))
+                throw new KitError(422, 'E_IMPORT_MAPPING', `حقل غير قابل للاستيراد أو مكرر: ${String(key)}`);
+            used.add(key);
+            clean[String(index)] = key;
+        }
+        const missing = targets.filter((target) => target.required && !used.has(target.key));
+        if (missing.length)
+            throw new KitError(422, 'E_IMPORT_MAPPING', `حقول مطلوبة بلا عمود: ${missing.map((target) => target.label).join('، ')}`);
+        await this.db('import_batches')
+            .where('id', row.id)
+            .update({ mapping: JSON.stringify(clean), status: 'queued' });
+        return this.show(row.id, actor);
+    }
+    /**
+     * Worker step: claims one queued or running batch and imports up to `chunk`
+     * rows. Progress is committed per row, so a crash resumes after the last one.
+     */
+    async process(chunk = 200) {
+        const batch = await this.db.transaction(async (trx) => {
+            const row = await trx('import_batches')
+                .whereIn('status', ['queued', 'running'])
+                .orderBy('id')
+                .forUpdate()
+                .skipLocked()
+                .first();
+            if (!row)
+                return null;
+            await trx('import_batches')
+                .where('id', row.id)
+                .update({ status: 'running', started_at: row.started_at ?? trx.fn.now() });
+            return row;
+        });
+        if (!batch)
+            return null;
+        const actor = await this.actors.load(Number(batch.user_id));
+        const resource = this.registry.get(batch.resource);
+        const lookupGroups = new Map();
+        for (const [key, field] of Object.entries(resource.fields)) {
+            if (field.type !== 'lookup')
+                continue;
+            const rows = await this.db('lookups')
+                .where({ group: field.group, active: true })
+                .select('key', 'label_ar', 'label_en');
+            const map = new Map();
+            for (const entry of rows)
+                for (const name of [entry.key, entry.label_ar, entry.label_en])
+                    map.set(normalize(String(name)), entry.key);
+            lookupGroups.set(key, map);
+        }
+        const mapping = batch.mapping;
+        const rows = batch.rows;
+        let { processed, created, failed } = batch;
+        const errors = [...batch.errors];
+        const end = Math.min(rows.length, processed + chunk);
+        for (let index = processed; index < end; index++) {
+            const cells = rows[index];
+            const input = {};
+            try {
+                for (const [column, key] of Object.entries(mapping)) {
+                    const raw = cells[Number(column)] ?? '';
+                    if (key === 'orgUnitId') {
+                        input.orgUnitId = raw.trim() === '' ? null : Number(raw.trim());
+                        continue;
+                    }
+                    try {
+                        input[key] = importCell(resource.fields[key], raw, lookupGroups.get(key) ?? new Map());
+                    }
+                    catch (error) {
+                        throw new Error(`${resource.fields[key].label.ar}: ${error.message}`);
+                    }
+                }
+                await this.resources.save(batch.resource, actor, input);
+                created++;
+            }
+            catch (error) {
+                failed++;
+                if (errors.length < ERROR_LIMIT)
+                    errors.push({
+                        row: index + 2,
+                        message: error instanceof KitError || error instanceof Error
+                            ? error.message.slice(0, 300)
+                            : 'خطأ غير معروف',
+                    });
+            }
+            processed = index + 1;
+            await this.db('import_batches')
+                .where('id', batch.id)
+                .update({ processed, created, failed, errors: JSON.stringify(errors) });
+        }
+        if (processed >= rows.length) {
+            await this.db.transaction(async (trx) => {
+                await trx('import_batches')
+                    .where('id', batch.id)
+                    // Row data is only needed while importing; the log keeps counts and errors.
+                    .update({ status: 'done', finished_at: trx.fn.now(), rows: JSON.stringify([]) });
+                await notifyWithTemplate(trx, Number(batch.user_id), 'import.finished', {
+                    resource: resource.label.ar,
+                    created,
+                    failed,
+                });
+            });
+        }
+        return { id: Number(batch.id), processed, created, failed };
+    }
+    safeTargets(name, actor) {
+        try {
+            return this.targets(name, actor);
+        }
+        catch {
+            return [];
+        }
+    }
+    async owned(id, actor) {
+        const batchId = Number(id);
+        if (!Number.isSafeInteger(batchId) || batchId <= 0)
+            throw new KitError(404, 'E_IMPORT_NOT_FOUND', 'الدفعة غير موجودة');
+        const row = await this.db('import_batches').where({ id: batchId, user_id: actor.id }).first();
+        if (!row)
+            throw new KitError(404, 'E_IMPORT_NOT_FOUND', 'الدفعة غير موجودة');
+        return row;
+    }
+    present(row, targets) {
+        let label = String(row.resource);
+        try {
+            label = this.registry.get(row.resource).label.ar;
+        }
+        catch { }
+        return {
+            id: Number(row.id),
+            resource: String(row.resource),
+            resourceLabel: label,
+            fileName: String(row.file_name),
+            status: row.status,
+            headers: row.headers ?? [],
+            mapping: row.mapping ?? {},
+            sample: (row.rows ?? []).slice(0, 5),
+            total: Number(row.total),
+            processed: Number(row.processed ?? 0),
+            created: Number(row.created ?? 0),
+            failed: Number(row.failed ?? 0),
+            errors: row.errors ?? [],
+            createdAt: new Date(row.created_at).toISOString(),
+            finishedAt: row.finished_at ? new Date(row.finished_at).toISOString() : null,
+            targets,
+        };
+    }
+}

package/build/src/integrations/openapi.d.ts

@@ -0,0 +1,39 @@
+import { type Actor } from '../auth/ability.js';
+import type { ResourceRegistry } from '../resource/registry.js';
+type Schema = Record<string, unknown>;
+/**
+ * OpenAPI 3.1 description of the resource API, generated from the registry. When
+ * an actor is given, only resources and actions it may use are described.
+ */
+export declare function openApiDocument(registry: ResourceRegistry, options: {
+    title: string;
+    version: string;
+    serverUrl: string;
+    basePath?: string;
+    /** Describe only what this actor may use (row conditions still apply at runtime). */
+    actor?: Actor;
+}): {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+    };
+    servers: {
+        url: string;
+    }[];
+    security: {
+        bearer: never[];
+    }[];
+    paths: Record<string, Schema>;
+    components: {
+        schemas: Record<string, Schema>;
+        securitySchemes: {
+            bearer: {
+                type: string;
+                scheme: string;
+                description: string;
+            };
+        };
+    };
+};
+export {};

package/build/src/integrations/openapi.js

@@ -0,0 +1,256 @@
+import { buildAbility } from '../auth/ability.js';
+function fieldSchema(field, mode, registry) {
+    const description = field.label.ar;
+    switch (field.type) {
+        case 'integer':
+            return { type: 'integer', description };
+        case 'money':
+            return {
+                type: 'string',
+                pattern: '^-?\\d+$',
+                description: `${description} (minor units as a decimal string)`,
+            };
+        case 'boolean':
+            return { type: 'boolean', description };
+        case 'date':
+            return { type: 'string', format: 'date', description };
+        case 'datetime':
+            return { type: 'string', format: 'date-time', description };
+        case 'json':
+            return { description };
+        case 'belongsTo':
+            return { type: 'integer', description: `${description} → ${field.resource}` };
+        case 'lookup':
+            return { type: 'string', description: `${description} (lookup group ${field.group})` };
+        case 'attachment':
+            return mode === 'write'
+                ? { type: 'integer', description: `${description} (id returned by POST /attachments)` }
+                : {
+                    type: 'object',
+                    description,
+                    properties: {
+                        id: { type: 'integer' },
+                        name: { type: 'string' },
+                        size: { type: 'integer' },
+                        mimeType: { type: 'string' },
+                    },
+                };
+        case 'hasMany': {
+            const child = registry.get(field.resource);
+            return {
+                type: 'array',
+                maxItems: 100,
+                description,
+                items: { $ref: `#/components/schemas/${child.name}_input` },
+            };
+        }
+        default:
+            return { type: 'string', description };
+    }
+}
+function nullable(schema, required) {
+    if (required)
+        return schema;
+    if (typeof schema.type === 'string')
+        return { ...schema, type: [schema.type, 'null'] };
+    return schema;
+}
+function schemas(resource, registry) {
+    const readKeys = (resource.serialize ?? [...new Set([...resource.list, ...resource.show])]).filter((key) => resource.fields[key]?.type !== 'hasMany');
+    const read = {
+        type: 'object',
+        description: `${resource.label.ar}. Fields the caller may not read are omitted.`,
+        properties: {
+            id: { type: 'integer' },
+            ...Object.fromEntries(readKeys.map((key) => [
+                key,
+                nullable(fieldSchema(resource.fields[key], 'read', registry), false),
+            ])),
+            ...(resource.version ? { version: { type: 'integer' } } : {}),
+            ...(resource.submittable
+                ? {
+                    docStatus: {
+                        type: 'integer',
+                        enum: [0, 1, 2],
+                        description: '0 draft, 1 submitted, 2 cancelled',
+                    },
+                }
+                : {}),
+            ...(resource.scoped ? { orgUnitId: { type: 'integer' } } : {}),
+        },
+        required: ['id'],
+    };
+    const writable = resource.form.filter((key) => !resource.fields[key].sequence);
+    const input = {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            ...Object.fromEntries(writable.map((key) => [
+                key,
+                nullable(fieldSchema(resource.fields[key], 'write', registry), Boolean(resource.fields[key].required)),
+            ])),
+            ...(resource.scoped ? { orgUnitId: { type: 'integer' } } : {}),
+            ...(resource.version
+                ? { version: { type: 'integer', description: 'Required on update (optimistic locking)' } }
+                : {}),
+        },
+        required: [
+            ...writable.filter((key) => resource.fields[key].required),
+            ...(resource.scoped ? ['orgUnitId'] : []),
+        ],
+    };
+    return { read, input };
+}
+const error = {
+    description: 'Error',
+    content: {
+        'application/json': {
+            schema: {
+                type: 'object',
+                properties: {
+                    error: {
+                        type: 'object',
+                        properties: { code: { type: 'string' }, message: { type: 'string' } },
+                    },
+                },
+            },
+        },
+    },
+};
+/**
+ * OpenAPI 3.1 description of the resource API, generated from the registry. When
+ * an actor is given, only resources and actions it may use are described.
+ */
+export function openApiDocument(registry, options) {
+    const base = options.basePath ?? '/api/v1';
+    const paths = {};
+    const components = {};
+    const children = new Set(registry
+        .all()
+        .flatMap((resource) => Object.values(resource.fields).flatMap((field) => field.type === 'hasMany' ? [field.resource] : [])));
+    for (const resource of registry.all()) {
+        const ability = options.actor ? buildAbility(options.actor.rules, registry.all()) : undefined;
+        const allowed = new Set(resource.actions.filter((action) => !ability || ability.can(action, resource.name)));
+        if (ability && !allowed.has('view'))
+            continue;
+        const { read, input } = schemas(resource, registry);
+        components[resource.name] = read;
+        components[`${resource.name}_input`] = input;
+        if (children.has(resource.name))
+            continue;
+        const ref = { $ref: `#/components/schemas/${resource.name}` };
+        const inputRef = { $ref: `#/components/schemas/${resource.name}_input` };
+        const tag = resource.label.en;
+        const one = (description) => ({
+            description,
+            content: { 'application/json': { schema: { type: 'object', properties: { data: ref } } } },
+        });
+        const idParam = { name: 'id', in: 'path', required: true, schema: { type: 'integer' } };
+        const collection = {};
+        const item = {};
+        if (allowed.has('view')) {
+            collection.get = {
+                tags: [tag],
+                summary: `List ${resource.label.en}`,
+                parameters: [
+                    { name: 'limit', in: 'query', schema: { type: 'integer', maximum: 100 } },
+                    { name: 'cursor', in: 'query', schema: { type: 'string' } },
+                    { name: 'search', in: 'query', schema: { type: 'string' } },
+                    { name: 'sort', in: 'query', schema: { type: 'string' } },
+                    { name: 'direction', in: 'query', schema: { enum: ['asc', 'desc'] } },
+                    { name: 'tag', in: 'query', schema: { type: 'string' } },
+                ],
+                responses: {
+                    200: {
+                        description: 'Keyset page',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: {
+                                        data: { type: 'array', items: ref },
+                                        meta: {
+                                            type: 'object',
+                                            properties: {
+                                                limit: { type: 'integer' },
+                                                nextCursor: { type: ['string', 'null'] },
+                                                estimatedTotal: { type: 'integer' },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    403: error,
+                },
+            };
+            item.get = {
+                tags: [tag],
+                summary: `Show one ${resource.label.en} record`,
+                parameters: [idParam],
+                responses: { 200: one('Record'), 403: error, 404: error },
+            };
+        }
+        if (allowed.has('create'))
+            collection.post = {
+                tags: [tag],
+                summary: `Create ${resource.label.en}`,
+                requestBody: { required: true, content: { 'application/json': { schema: inputRef } } },
+                responses: { 201: one('Created'), 403: error, 409: error, 422: error },
+            };
+        if (allowed.has('update'))
+            item.patch = {
+                tags: [tag],
+                summary: `Update ${resource.label.en}`,
+                parameters: [idParam],
+                requestBody: { required: true, content: { 'application/json': { schema: inputRef } } },
+                responses: { 200: one('Updated'), 403: error, 404: error, 409: error, 422: error },
+            };
+        if (allowed.has('delete'))
+            item.delete = {
+                tags: [tag],
+                summary: `Soft-delete ${resource.label.en}`,
+                parameters: [idParam],
+                responses: { 200: one('Deleted'), 403: error, 404: error, 409: error },
+            };
+        if (Object.keys(collection).length)
+            paths[`${base}/resources/${resource.name}`] = collection;
+        if (Object.keys(item).length)
+            paths[`${base}/resources/${resource.name}/{id}`] = item;
+        for (const action of ['submit', 'cancel'])
+            if (resource.submittable && allowed.has(action))
+                paths[`${base}/resources/${resource.name}/{id}/${action}`] = {
+                    post: {
+                        tags: [tag],
+                        summary: `${action === 'submit' ? 'Submit' : 'Cancel'} ${resource.label.en}`,
+                        parameters: [idParam],
+                        requestBody: {
+                            content: {
+                                'application/json': {
+                                    schema: { type: 'object', properties: { version: { type: 'integer' } } },
+                                },
+                            },
+                        },
+                        responses: { 200: one('Transitioned'), 403: error, 404: error, 409: error },
+                    },
+                };
+    }
+    return {
+        openapi: '3.1.0',
+        info: { title: options.title, version: options.version },
+        servers: [{ url: options.serverUrl }],
+        security: [{ bearer: [] }],
+        paths,
+        components: {
+            schemas: components,
+            securitySchemes: {
+                bearer: {
+                    type: 'http',
+                    scheme: 'bearer',
+                    description: 'Personal API token. Read tokens are limited to GET requests.',
+                },
+            },
+        },
+    };
+}

package/build/src/integrations/print.d.ts

@@ -0,0 +1,37 @@
+import type { ResourceDescription } from '../admin/presentation.js';
+import type { SerializedRecord } from '../resource/types.js';
+export type PrintIdentity = {
+    name: string;
+    logoUrl?: string | null;
+};
+export type PrintInput = {
+    identity: PrintIdentity;
+    resource: ResourceDescription;
+    record: SerializedRecord;
+    related?: Record<string, SerializedRecord[]>;
+    lookups?: Record<string, {
+        value: string;
+        label: string;
+    }[]>;
+    children?: Record<string, {
+        rows: SerializedRecord[];
+        fields: ResourceDescription['fields'];
+    }>;
+    printedBy: string;
+    printedAt?: Date;
+};
+/**
+ * The generic printable view of one record: RTL A4 HTML, every value escaped.
+ * Only fields already serialized for the caller are printed, so printing can
+ * never reveal more than the detail page.
+ */
+export declare function renderPrintHtml(input: PrintInput): string;
+/**
+ * Converts printable HTML to PDF with an optional Gotenberg service
+ * (POST /forms/chromium/convert/html). Without it, pages use the browser's print.
+ */
+export declare function htmlToPdf(html: string, options: {
+    gotenbergUrl: string;
+    timeoutMs?: number;
+    fetch?: typeof fetch;
+}): Promise<Buffer<ArrayBuffer>>;