@managemint-solutions/sdk 0.56.0 → 0.65.0

package/dist/documents/documents.d.ts

@@ -0,0 +1,154 @@
+import type { MmsList } from '@managemint-solutions/entities/common';
+import type { DocumentBlock, DocumentEmail, DocumentEntity, DocumentImageUploadTarget, DocumentSend, DocumentSummary, DocumentVariable, DocumentVariableValues } from '@managemint-solutions/entities/documents';
+import { DocumentStatus, type DocumentRepeat, type DocumentVisibility } from '@managemint-solutions/entities/documents/enum';
+import { EntityAuditTrail, type AuditResource, type ResourceActor } from '../audit';
+import type { TypedSupabaseClient } from '../client';
+import type { GetDocumentsDto } from './dto';
+/**
+ * The columns the api writes on a document. Issuing, numbering, the totals and the frozen
+ * system values are the api's to work out; the sdk stores what it is given.
+ */
+type DocumentRow = {
+    template_id: string | null;
+    client_id: string | null;
+    category: string;
+    title: string;
+    status: DocumentStatus;
+    number_prefix: string;
+    number_sequence: number | null;
+    number: string | null;
+    currency: string | null;
+    variables: DocumentVariable[];
+    variable_values: DocumentVariableValues;
+    blocks: DocumentBlock[];
+    visibility: DocumentVisibility;
+    subtotal_minor: number;
+    discount_minor: number;
+    tax_minor: number;
+    total_minor: number;
+    /** ISO timestamps, and the users.mms_id of who acted. */
+    issued_at: string | null;
+    issued_by: string | null;
+    voided_at: string | null;
+    voided_by: string | null;
+    void_reason: string | null;
+    /** A recurring parent's schedule (dates YYYY-MM-DD), a scheduled draft's issue date and email. */
+    repeat: DocumentRepeat | null;
+    repeat_next_at: string | null;
+    repeat_until: string | null;
+    repeat_paused: boolean;
+    /** The parent a draft was made from - written by the cron only (members hold no grant on it). */
+    repeat_from: string | null;
+    issue_at: string | null;
+    email: DocumentEmail | null;
+};
+/**
+ * A document as the sdk reads it. `my_role` (what the caller may do with it), `payments` (read
+ * beside it through `payments.list` - they have no foreign key to embed through) and
+ * `pay_now_available` are the api's to add.
+ */
+export type DocumentRecord = Omit<DocumentEntity, 'my_role' | 'payments' | 'pay_now_available' | 'payment_status' | 'issued_count'>;
+/** A list row as the sdk reads it; `payment_status` is the api's to add, from the page's payments. */
+export type DocumentListRecord = Omit<DocumentSummary, 'payment_status'>;
+/** What a send's audit event records. */
+export type DocumentSendEvent = Pick<DocumentSend, 'recipients' | 'cc' | 'subject' | 'pay_now'>;
+/**
+ * A new draft: everything but the status, the number and the issue and void columns, which a
+ * draft has none of. The schedule columns are optional (a plain draft has none); `repeat_from` is
+ * the cron's, for the drafts it makes.
+ */
+export type CreateDocumentRow = Omit<DocumentRow, 'status' | 'number_sequence' | 'number' | 'issued_at' | 'issued_by' | 'voided_at' | 'voided_by' | 'void_reason' | keyof DocumentScheduleRow> & Partial<DocumentScheduleRow>;
+type DocumentScheduleRow = Pick<DocumentRow, 'repeat' | 'repeat_next_at' | 'repeat_until' | 'repeat_paused' | 'repeat_from' | 'issue_at' | 'email'>;
+/**
+ * A draft save, an issue or a void: whichever columns it changes - never the visibility, which
+ * members hold no grant on after create (the visibility route changes it on the service role).
+ */
+export type UpdateDocumentRow = Partial<Omit<DocumentRow, 'visibility' | 'repeat_from'>>;
+/**
+ * Documents: a copy of a template's blocks and variables plus the values they were filled with.
+ * A draft is edited whole; issuing and voiding are status moves the api makes through `update`.
+ * The drafts-only and issued-only rules are the api's - the sdk's part is that every status move,
+ * and the delete, is a compare-and-set, so two callers can never both act on the same state.
+ */
+export declare class DocumentsResource {
+    private readonly supabase;
+    private readonly auth;
+    private readonly auditLog;
+    private readonly table;
+    /** This record's history - its own rows. */
+    readonly audit: EntityAuditTrail;
+    constructor(supabase: TypedSupabaseClient, auth: ResourceActor, auditLog: AuditResource);
+    /**
+     * Newest first; `search` matches the title and the number. Recurring parents are a list of
+     * their own: `recurring` lists them alone, and every other list leaves them out. `ids` keeps
+     * the list to (`in`) or away from (`not_in`) the documents named - the api's payment filter
+     * passes the paid ones - and `payable` to issued documents with a total above zero. The
+     * DTO's `payment` itself is the api's to turn into those two; the list ignores it.
+     */
+    list(query: GetDocumentsDto & {
+        organization_id?: string | null;
+        ids?: {
+            in: string[];
+        } | {
+            not_in: string[];
+        };
+        payable?: boolean;
+    }): Promise<MmsList<DocumentListRecord>>;
+    getById(documentId: string): Promise<DocumentRecord>;
+    /** A new draft. A client or template of another organization is refused by the foreign keys (409). */
+    create(row: CreateDocumentRow): Promise<DocumentRecord>;
+    /**
+     * Writes `row` only while the document is still `expected` - the status the api read and
+     * decided on: a draft save and an issue expect a draft, a void an issued document. Resolves to
+     * null when the document has moved on since, so the caller can say so instead of overwriting.
+     * An issue whose number another document took first throws 409 with `code` 23505.
+     */
+    update(documentId: string, expected: DocumentStatus, row: UpdateDocumentRow): Promise<DocumentRecord | null>;
+    /** How many drafts a recurring parent has made - the documents with it as `repeat_from`. */
+    countCopies(parentId: string): Promise<number>;
+    /**
+     * Files a send on the document's history: an audit event of its own (`SEND`), not a change to
+     * the row, holding what was sent as set by it. Like every audit write it never throws.
+     */
+    recordSend(documentId: string, send: DocumentSendEvent): Promise<void>;
+    /** The emails a document went out in, newest first - its `SEND` events. */
+    sends(documentId: string): Promise<DocumentSend[]>;
+    /**
+     * How many emails the organization has sent since `since` (ISO), across every document - on
+     * the service client's organization scope, so private documents count too. The daily cap.
+     */
+    countSendsSince(since: string): Promise<number>;
+    /**
+     * Deletes a draft: a compare-and-set on `draft`, so an issue that lands first wins and the
+     * issued document stays. False when the document is no longer a draft - it is voided instead.
+     */
+    remove(documentId: string): Promise<boolean>;
+    /**
+     * The sequence the next document numbered with `prefix` takes: the organization's highest for
+     * that prefix, plus one (1 for the first). Two issues at once can pick the same one; the unique
+     * index refuses the second with a 409 (`code` 23505) and the api retries.
+     */
+    nextSequence(prefix: string): Promise<number>;
+    /**
+     * Where the browser puts an image block's file: a signed upload URL (two hours, one PUT) into
+     * the supporting-files bucket under `<organization>/documents/images/`, and the `path` the
+     * block stores. The object is named afresh each time, never after the caller's file, and is
+     * never replaced, so an issued document's images cannot change under it. Storage checks the
+     * bucket's INSERT policy as the caller when the URL is minted.
+     */
+    createImageUploadUrl(fileName: string): Promise<DocumentImageUploadTarget>;
+    /**
+     * Signed URLs for image blocks' paths, by path, for the HTML the api renders - one Storage call
+     * however many there are. The paths are inside the caller's organization's folder, so a path
+     * naming anything else signs nothing. A path with no object behind it is left out.
+     */
+    imageUrls(paths: string[]): Promise<Record<string, string>>;
+    /**
+     * `repeat_from` as the parent's identity (`{ mms_id, title }`) rather than its id, in one read for
+     * all the rows. PostgREST embeds a table's many-to-one relationship to itself only through a SQL
+     * function, so the parents are read beside the rows instead. A parent the reader cannot see
+     * (or since deleted) reads as null.
+     */
+    private withParents;
+}
+export {};

package/dist/documents/documents.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentsResource = void 0;
+const node_crypto_1 = require("node:crypto");
+const enum_1 = require("@managemint-solutions/entities/documents/enum");
+const enum_2 = require("@managemint-solutions/entities/audit-trail/enum");
+const audit_1 = require("../audit");
+const errors_1 = require("../errors");
+const paths_1 = require("../supporting-files/paths");
+const tenancy_1 = require("../tenancy");
+const transforms_1 = require("../transforms");
+const content_1 = require("./content");
+// The public contract is the shared DocumentSummary / DocumentEntity from
+// @managemint-solutions/entities; the casts at the returns declare the shape the select strings
+// below produce. The client and the template are embedded through the composite same-organization
+// keys, named, since a client_profiles view carries no organization_id to match them on.
+const DOCUMENT_LIST_SELECT = `
+        mms_id,
+        created_at,
+        title,
+        category,
+        status,
+        number,
+        client:clients!documents_client_fkey ( mms_id, name ),
+        currency,
+        total_minor,
+        issued_at,
+        repeat,
+        repeat_next_at,
+        repeat_until,
+        repeat_paused,
+        repeat_from,
+        issue_at,
+        visibility
+      `;
+const DOCUMENT_DETAIL_SELECT = `
+        mms_id,
+        created_at,
+        created_by:user_profiles!created_by ${transforms_1.USER_PROFILE_EMBED},
+        updated_at,
+        last_updated_by:user_profiles!last_updated_by ${transforms_1.USER_PROFILE_EMBED},
+        template:document_templates!documents_template_fkey ( mms_id, name ),
+        client:clients!documents_client_fkey ( mms_id, name ),
+        category,
+        title,
+        status,
+        number_prefix,
+        number,
+        currency,
+        variables,
+        variable_values,
+        blocks,
+        blocks_version,
+        subtotal_minor,
+        discount_minor,
+        tax_minor,
+        total_minor,
+        issued_at,
+        issued_by:user_profiles!issued_by ${transforms_1.USER_PROFILE_EMBED},
+        voided_at,
+        voided_by:user_profiles!voided_by ${transforms_1.USER_PROFILE_EMBED},
+        void_reason,
+        repeat,
+        repeat_next_at,
+        repeat_until,
+        repeat_paused,
+        repeat_from,
+        issue_at,
+        email,
+        visibility
+      `;
+/** How long a signed image URL in rendered HTML stays valid - long enough to keep a preview open. */
+const IMAGE_URL_TTL_SECONDS = 3600;
+/**
+ * Documents: a copy of a template's blocks and variables plus the values they were filled with.
+ * A draft is edited whole; issuing and voiding are status moves the api makes through `update`.
+ * The drafts-only and issued-only rules are the api's - the sdk's part is that every status move,
+ * and the delete, is a compare-and-set, so two callers can never both act on the same state.
+ */
+class DocumentsResource {
+    supabase;
+    auth;
+    auditLog;
+    table;
+    /** This record's history - its own rows. */
+    audit;
+    constructor(supabase, 
+    // A tenant, staff, or - on the service client's organization scope - the system, for the
+    // public pay page, the Paystack webhook and the daily send cap.
+    auth, auditLog) {
+        this.supabase = supabase;
+        this.auth = auth;
+        this.auditLog = auditLog;
+        this.table = (0, audit_1.auditedTable)(supabase, auth, auditLog, {
+            table: 'documents',
+            entityType: enum_2.AuditTrailEntityType.DOCUMENTS,
+            documentContent: true,
+        });
+        this.audit = new audit_1.EntityAuditTrail(supabase, auth, enum_2.AuditTrailEntityType.DOCUMENTS);
+    }
+    /**
+     * Newest first; `search` matches the title and the number. Recurring parents are a list of
+     * their own: `recurring` lists them alone, and every other list leaves them out. `ids` keeps
+     * the list to (`in`) or away from (`not_in`) the documents named - the api's payment filter
+     * passes the paid ones - and `payable` to issued documents with a total above zero. The
+     * DTO's `payment` itself is the api's to turn into those two; the list ignores it.
+     */
+    async list(query) {
+        const page = query.page;
+        const pageSize = query.page_size;
+        const offset = (page - 1) * pageSize;
+        const trimmedSearch = query.search?.trim();
+        // `order`/`range` return `this`, so the conditional filters below reassign onto the builder.
+        let documentsQuery = (0, tenancy_1.scopeToOrganization)(this.supabase
+            .from('documents')
+            .select((0, tenancy_1.withOrganization)(DOCUMENT_LIST_SELECT, this.auth), { count: 'estimated' }), this.auth)
+            .order('created_at', { ascending: false })
+            .range(offset, offset + pageSize - 1);
+        if (query.organization_id) {
+            documentsQuery = documentsQuery.eq('organization_id', query.organization_id);
+        }
+        if (query.status) {
+            documentsQuery = documentsQuery.eq('status', query.status);
+        }
+        if (query.category) {
+            documentsQuery = documentsQuery.eq('category', query.category);
+        }
+        if (query.client_id) {
+            documentsQuery = documentsQuery.eq('client_id', query.client_id);
+        }
+        if (query.template_id) {
+            documentsQuery = documentsQuery.eq('template_id', query.template_id);
+        }
+        documentsQuery = query.recurring
+            ? documentsQuery.not('repeat', 'is', null)
+            : documentsQuery.is('repeat', null);
+        if (query.repeat_from) {
+            documentsQuery = documentsQuery.eq('repeat_from', query.repeat_from);
+        }
+        if (query.ids && 'in' in query.ids) {
+            documentsQuery = documentsQuery.in('mms_id', query.ids.in);
+        }
+        else if (query.ids && query.ids.not_in.length > 0) {
+            documentsQuery = documentsQuery.not('mms_id', 'in', `(${query.ids.not_in.join(',')})`);
+        }
+        if (query.payable) {
+            documentsQuery = documentsQuery.eq('status', enum_1.DocumentStatus.ISSUED).gt('total_minor', 0);
+        }
+        if (trimmedSearch) {
+            documentsQuery = documentsQuery.or((0, transforms_1.orIlike)(['title', 'number'], trimmedSearch));
+        }
+        const { data, error, count } = await documentsQuery;
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        const rows = await this.withParents((data ?? []));
+        return (0, transforms_1.toMmsList)(rows, page, pageSize, count);
+    }
+    async getById(documentId) {
+        const { data, error } = await (0, tenancy_1.scopeToOrganization)(this.supabase.from('documents').select((0, tenancy_1.withOrganization)(DOCUMENT_DETAIL_SELECT, this.auth)), this.auth)
+            .eq('mms_id', documentId)
+            .single();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (await this.withParents([data]))[0];
+    }
+    /** A new draft. A client or template of another organization is refused by the foreign keys (409). */
+    async create(row) {
+        const created = await this.table.insert({
+            ...row,
+            organization_id: (0, tenancy_1.requireOrganization)(this.auth),
+            created_by: this.auth.mms_id,
+            created_at: new Date().toISOString(),
+        });
+        return this.getById(created.mms_id);
+    }
+    /**
+     * Writes `row` only while the document is still `expected` - the status the api read and
+     * decided on: a draft save and an issue expect a draft, a void an issued document. Resolves to
+     * null when the document has moved on since, so the caller can say so instead of overwriting.
+     * An issue whose number another document took first throws 409 with `code` 23505.
+     */
+    async update(documentId, expected, row) {
+        const updated = await this.table.updateWhere(documentId, (query) => query.eq('status', expected), {
+            ...row,
+            last_updated_by: this.auth.mms_id,
+            updated_at: new Date().toISOString(),
+        });
+        return updated ? this.getById(documentId) : null;
+    }
+    /** How many drafts a recurring parent has made - the documents with it as `repeat_from`. */
+    async countCopies(parentId) {
+        const { error, count } = await (0, tenancy_1.scopeToOrganization)(this.supabase.from('documents').select('mms_id', { count: 'exact', head: true }), this.auth).eq('repeat_from', parentId);
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return count ?? 0;
+    }
+    /**
+     * Files a send on the document's history: an audit event of its own (`SEND`), not a change to
+     * the row, holding what was sent as set by it. Like every audit write it never throws.
+     */
+    async recordSend(documentId, send) {
+        await this.auditLog.record({
+            action: enum_2.AuditTrailAction.SEND,
+            entityType: enum_2.AuditTrailEntityType.DOCUMENTS,
+            entityId: documentId,
+            changes: Object.fromEntries(Object.entries(send).map(([key, value]) => [key, { old: null, new: value }])),
+        });
+    }
+    /** The emails a document went out in, newest first - its `SEND` events. */
+    async sends(documentId) {
+        const { data, error } = await (0, tenancy_1.scopeToOrganization)(this.supabase
+            .from('audit_logs')
+            .select(`mms_id, created_at, created_by:user_profiles!created_by ${transforms_1.USER_PROFILE_EMBED}, changes`), this.auth)
+            .eq('entity_type', enum_2.AuditTrailEntityType.DOCUMENTS)
+            .eq('entity_id', documentId)
+            .eq('action', enum_2.AuditTrailAction.SEND)
+            .order('created_at', { ascending: false });
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (data ?? []).map(({ changes, ...send }) => ({
+            ...send,
+            recipients: (changes.recipients?.new ?? []),
+            cc: (changes.cc?.new ?? []),
+            subject: (changes.subject?.new ?? ''),
+            pay_now: changes.pay_now?.new === true,
+        }));
+    }
+    /**
+     * How many emails the organization has sent since `since` (ISO), across every document - on
+     * the service client's organization scope, so private documents count too. The daily cap.
+     */
+    async countSendsSince(since) {
+        const { error, count } = await this.supabase
+            .from('audit_logs')
+            .select('mms_id', { count: 'exact', head: true })
+            .eq('organization_id', (0, tenancy_1.requireOrganization)(this.auth))
+            .eq('entity_type', enum_2.AuditTrailEntityType.DOCUMENTS)
+            .eq('action', enum_2.AuditTrailAction.SEND)
+            .gte('created_at', since);
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return count ?? 0;
+    }
+    /**
+     * Deletes a draft: a compare-and-set on `draft`, so an issue that lands first wins and the
+     * issued document stays. False when the document is no longer a draft - it is voided instead.
+     */
+    async remove(documentId) {
+        const deleted = await this.table.removeWhere(documentId, (query) => query.eq('status', enum_1.DocumentStatus.DRAFT));
+        return deleted !== null;
+    }
+    /**
+     * The sequence the next document numbered with `prefix` takes: the organization's highest for
+     * that prefix, plus one (1 for the first). Two issues at once can pick the same one; the unique
+     * index refuses the second with a 409 (`code` 23505) and the api retries.
+     */
+    async nextSequence(prefix) {
+        const organizationId = (0, tenancy_1.requireOrganization)(this.auth);
+        const { data, error } = await this.supabase
+            .from('documents')
+            .select('number_sequence')
+            .eq('organization_id', organizationId)
+            .eq('number_prefix', prefix)
+            // Not just for the meaning: a descending order puts nulls first, and this is also the
+            // partial unique index's own predicate, so the read is one index probe.
+            .not('number_sequence', 'is', null)
+            .order('number_sequence', { ascending: false })
+            .limit(1)
+            .maybeSingle();
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        return (data?.number_sequence ?? 0) + 1;
+    }
+    /**
+     * Where the browser puts an image block's file: a signed upload URL (two hours, one PUT) into
+     * the supporting-files bucket under `<organization>/documents/images/`, and the `path` the
+     * block stores. The object is named afresh each time, never after the caller's file, and is
+     * never replaced, so an issued document's images cannot change under it. Storage checks the
+     * bucket's INSERT policy as the caller when the URL is minted.
+     */
+    async createImageUploadUrl(fileName) {
+        const organizationId = (0, tenancy_1.requireOrganization)(this.auth);
+        const extension = (0, paths_1.splitFileName)((0, paths_1.sanitizeFileName)(fileName)).extension.toLowerCase();
+        if (!content_1.IMAGE_EXTENSIONS.has(extension)) {
+            throw new errors_1.SupabaseClientError({
+                status: 400,
+                error: 'Storage Error',
+                message: `Unsupported image type: ${fileName}. Use ${[...content_1.IMAGE_EXTENSIONS].join(', ')}`,
+            });
+        }
+        const key = (0, paths_1.storagePath)(organizationId, 'documents', 'images', (0, node_crypto_1.randomUUID)(), extension);
+        const { data, error } = await this.supabase.storage.from(paths_1.SUPPORTING_FILES_BUCKET).createSignedUploadUrl(key);
+        if (error)
+            throw (0, errors_1.mapStorageError)(error, `Failed to prepare upload: ${fileName}`);
+        return { path: key.slice(organizationId.length + 1), url: data.signedUrl };
+    }
+    /**
+     * Signed URLs for image blocks' paths, by path, for the HTML the api renders - one Storage call
+     * however many there are. The paths are inside the caller's organization's folder, so a path
+     * naming anything else signs nothing. A path with no object behind it is left out.
+     */
+    async imageUrls(paths) {
+        if (paths.length === 0)
+            return {};
+        const organizationId = (0, tenancy_1.requireOrganization)(this.auth);
+        const { data, error } = await this.supabase.storage
+            .from(paths_1.SUPPORTING_FILES_BUCKET)
+            .createSignedUrls(paths.map((path) => `${organizationId}/${path}`), IMAGE_URL_TTL_SECONDS);
+        if (error)
+            throw (0, errors_1.mapStorageError)(error);
+        return Object.fromEntries(data.flatMap(({ path, signedUrl }) => path && signedUrl ? [[path.slice(organizationId.length + 1), signedUrl]] : []));
+    }
+    /**
+     * `repeat_from` as the parent's identity (`{ mms_id, title }`) rather than its id, in one read for
+     * all the rows. PostgREST embeds a table's many-to-one relationship to itself only through a SQL
+     * function, so the parents are read beside the rows instead. A parent the reader cannot see
+     * (or since deleted) reads as null.
+     */
+    async withParents(rows) {
+        const ids = [...new Set(rows.map((row) => row.repeat_from).filter((id) => typeof id === 'string'))];
+        if (ids.length === 0)
+            return rows.map((row) => ({ ...row, repeat_from: null }));
+        const { data, error } = await this.supabase.from('documents').select('mms_id, title').in('mms_id', ids);
+        if (error)
+            throw (0, errors_1.mapPostgrestError)(error);
+        const parents = new Map((data ?? []).map((parent) => [parent.mms_id, parent]));
+        return rows.map((row) => ({ ...row, repeat_from: parents.get(row.repeat_from) ?? null }));
+    }
+}
+exports.DocumentsResource = DocumentsResource;

package/dist/documents/dto.d.ts

@@ -0,0 +1,138 @@
+import type { DocumentBlock, DocumentEmail, DocumentVariable, DocumentVariableValues } from '@managemint-solutions/entities/documents';
+import type { CatalogueTemplateSlugDto as CatalogueTemplateSlugDtoType, CopyCatalogueTemplateDto as CopyCatalogueTemplateDtoType, CreateDocumentDto as CreateDocumentDtoType, CreateDocumentTemplateDto as CreateDocumentTemplateDtoType, DocumentIdDto as DocumentIdDtoType, DocumentImageNameDto as DocumentImageNameDtoType, DocumentImageUrlsDto as DocumentImageUrlsDtoType, DocumentPayQueryDto as DocumentPayQueryDtoType, DocumentPayTokenDto as DocumentPayTokenDtoType, DocumentPaymentIdDto as DocumentPaymentIdDtoType, DocumentTemplateIdDto as DocumentTemplateIdDtoType, GetCatalogueTemplatesDto as GetCatalogueTemplatesDtoType, GetDocumentsDto as GetDocumentsDtoType, GetDocumentTemplatesDto as GetDocumentTemplatesDtoType, PayDocumentDto as PayDocumentDtoType, RecordDocumentPaymentDto as RecordDocumentPaymentDtoType, ReassignPrivateDocumentsDto as ReassignPrivateDocumentsDtoType, SendDocumentDto as SendDocumentDtoType, UpdateDocumentDto as UpdateDocumentDtoType, UpdateDocumentTemplateDto as UpdateDocumentTemplateDtoType, VoidDocumentDto as VoidDocumentDtoType } from '@managemint-solutions/entities/documents/dto';
+import { DocumentPaymentFilter, DocumentRepeat, DocumentStatus, DocumentVisibility } from '@managemint-solutions/entities/documents/enum';
+export declare class GetDocumentTemplatesDto implements GetDocumentTemplatesDtoType {
+    readonly search?: string | null;
+    readonly category?: string | null;
+    readonly archive: boolean;
+    readonly page: number;
+    readonly page_size: number;
+}
+export declare class DocumentTemplateIdDto implements DocumentTemplateIdDtoType {
+    readonly templateId: string;
+}
+/** Saving replaces the whole template. Its visibility changes only through the visibility route. */
+export declare class UpdateDocumentTemplateDto implements UpdateDocumentTemplateDtoType {
+    readonly name: string;
+    readonly category?: string;
+    readonly number_prefix?: string;
+    readonly variables: DocumentVariable[];
+    readonly blocks: DocumentBlock[];
+}
+/** A new template: what a save holds, plus who sees it (omitted: the organization). */
+export declare class CreateDocumentTemplateDto extends UpdateDocumentTemplateDto implements CreateDocumentTemplateDtoType {
+    readonly visibility?: DocumentVisibility;
+}
+export declare class GetDocumentsDto implements GetDocumentsDtoType {
+    readonly search?: string | null;
+    readonly category?: string | null;
+    readonly status?: DocumentStatus | null;
+    readonly client_id?: string | null;
+    readonly template_id?: string | null;
+    readonly recurring?: boolean;
+    readonly repeat_from?: string | null;
+    readonly payment?: DocumentPaymentFilter | null;
+    readonly page: number;
+    readonly page_size: number;
+}
+export declare class DocumentIdDto implements DocumentIdDtoType {
+    readonly documentId: string;
+}
+/**
+ * A recurring parent's schedule and a draft's issue date, on create and on a draft save. Each is
+ * checked alone here; how they go together (a parent needs its first date, never an issue date)
+ * is the api's.
+ */
+declare class DocumentScheduleDto {
+    readonly repeat?: DocumentRepeat | null;
+    readonly repeat_next_at?: string | null;
+    readonly repeat_until?: string | null;
+    readonly repeat_paused?: boolean;
+    readonly issue_at?: string | null;
+    readonly email?: DocumentEmail | null;
+}
+/**
+ * A new draft. Its values cannot be checked here - with a template, the variables they fill are
+ * the template's - so the api checks the draft it composes with `documentProblem`.
+ */
+export declare class CreateDocumentDto extends DocumentScheduleDto implements CreateDocumentDtoType {
+    readonly template_id?: string | null;
+    readonly client_id?: string | null;
+    readonly title?: string;
+    readonly currency?: string | null;
+    readonly variable_values?: DocumentVariableValues;
+    readonly visibility?: DocumentVisibility;
+}
+/** A whole draft, under the same content rules as a template, plus its values and currency. */
+export declare class UpdateDocumentDto extends DocumentScheduleDto implements UpdateDocumentDtoType {
+    readonly client_id: string | null;
+    readonly title: string;
+    readonly category: string;
+    readonly number_prefix: string;
+    readonly currency: string | null;
+    readonly variables: DocumentVariable[];
+    readonly variable_values: DocumentVariableValues;
+    readonly blocks: DocumentBlock[];
+}
+export declare class VoidDocumentDto implements VoidDocumentDtoType {
+    readonly reason: string;
+}
+export declare class DocumentImageNameDto implements DocumentImageNameDtoType {
+    readonly name: string;
+}
+/**
+ * Image paths to sign for reading, as a query (`?paths=a&paths=b`; one `paths` arrives as a plain
+ * string and is taken as a list of one). Each must be one `createImageUploadUrl` handed out
+ * (`documents/images/<uuid>.<ext>`); `imageUrls` then signs it under the caller's own
+ * organization, so nothing outside that folder can be named.
+ */
+export declare class DocumentImageUrlsDto implements DocumentImageUrlsDtoType {
+    readonly paths: string[];
+}
+/** The owner's move of one person's private templates and documents to another; v4 user ids. */
+export declare class ReassignPrivateDocumentsDto implements ReassignPrivateDocumentsDtoType {
+    readonly from_user_id: string;
+    readonly to_user_id: string;
+}
+/** An issued document's email. Who may send it, and whether Pay now may go on it, is the api's. */
+export declare class SendDocumentDto implements SendDocumentDtoType {
+    readonly to: string[];
+    readonly cc?: string[];
+    readonly subject: string;
+    readonly message: string;
+    readonly pay_now: boolean;
+}
+/** A public pay link's token. Only its shape is checked here; the api checks the signature. */
+export declare class DocumentPayTokenDto implements DocumentPayTokenDtoType {
+    readonly token: string;
+}
+/** Paystack's return to the pay page: its reference - letters, digits and - . = only, as Paystack allows. */
+export declare class DocumentPayQueryDto implements DocumentPayQueryDtoType {
+    readonly reference?: string;
+}
+export declare class PayDocumentDto implements PayDocumentDtoType {
+    readonly email: string;
+}
+/** A document marked paid by hand: the date the money arrived, and the bank reference if any. */
+export declare class RecordDocumentPaymentDto implements RecordDocumentPaymentDtoType {
+    readonly paid_at: string;
+    readonly reference?: string | null;
+}
+export declare class DocumentPaymentIdDto implements DocumentPaymentIdDtoType {
+    readonly documentId: string;
+    readonly paymentId: string;
+}
+export declare class GetCatalogueTemplatesDto implements GetCatalogueTemplatesDtoType {
+    readonly search?: string | null;
+    readonly category?: string | null;
+}
+export declare class CatalogueTemplateSlugDto implements CatalogueTemplateSlugDtoType {
+    readonly slug: string;
+}
+/** The copy's own name and prefix are optional and held to a template save's rules when given. */
+export declare class CopyCatalogueTemplateDto implements CopyCatalogueTemplateDtoType {
+    readonly slug: string;
+    readonly name?: string;
+    readonly number_prefix?: string;
+}
+export {};