@arbidocs/blocks 0.4.100 → 0.4.102

package/node_modules/@arbidocs/coedit/dist/template.d.ts

@@ -0,0 +1,125 @@
+interface ApplyTemplateOptions {
+    /** Record the template in settings.xml (`w:attachedTemplate`), e.g. "House template.dotx". */
+    attachedTemplate?: string;
+    /** Also take the template's page setup, headers and footers for the final section. */
+    furniture?: boolean;
+}
+interface ApplyTemplateReport {
+    /** Template style ids written into the document (replaced or added). */
+    styles: string[];
+    /** Template style id → the document's id it was matched to by name (localised built-ins). */
+    renamed: Record<string, string>;
+    /** Template numId → new numId in the document. */
+    numbering: Record<string, string>;
+}
+/** Word's Organizer + attach template, optionally with the template's page furniture. */
+declare function applyTemplate(document: Uint8Array, template: Uint8Array, options?: ApplyTemplateOptions): {
+    bytes: Uint8Array;
+    report: ApplyTemplateReport;
+};
+/**
+ * File › New from a template: the template package as a new document. A .dotx/.dotm main part
+ * becomes a document part (macros are not carried), the glossary stays behind, and the template
+ * is recorded as attached.
+ */
+declare function newFromTemplate(template: Uint8Array, options?: {
+    attachedTemplate?: string;
+}): Uint8Array;
+/**
+ * Put content into the house shape: the template's styles, numbering, theme, fonts, settings and
+ * page furniture applied to `content` (an AI draft, a converted Markdown file).
+ */
+declare function composeWithTemplate(content: Uint8Array, template: Uint8Array, attachedTemplate?: string): Uint8Array;
+
+interface BuildingBlockInfo {
+    name: string;
+    gallery: string;
+    category: string;
+    description: string;
+    /** Plain text of the block, for a preview. */
+    text: string;
+}
+/** Quick Parts and AutoText first, as Word's Insert › Quick Parts lists them; sorted by category. */
+declare function listBuildingBlocks(template: Uint8Array): BuildingBlockInfo[];
+/**
+ * One building block as a fragment package: its `w:docPartBody` as the body, with the glossary's
+ * styles (without document defaults: pasted text takes the defaults of the document it lands in),
+ * numbering, and the media its relationships reach. Undefined when the template has no such block.
+ */
+declare function buildingBlockFragment(template: Uint8Array, name: string): Uint8Array | undefined;
+/** A fragment's body as clipboard HTML the editor's paste recognises as its own. */
+declare function fragmentClipboardHtml(fragment: Uint8Array, covered?: boolean): string;
+
+/** Who made a tracked change and when (`w:author`, `w:date`). */
+interface Revision {
+    author: string;
+    /** ISO 8601, seconds precision, e.g. `2026-10-19T09:30:00Z`. */
+    date: string;
+}
+/**
+ * The fragment with every run wrapped in `w:ins` and every new paragraph mark marked inserted. A
+ * table row is marked inserted as a whole, its cells left as they are: the editor rejects an
+ * inserted row whose content is tracked as well only partly. A run is not descended into, so a
+ * text box goes in with its run. `covered`: the fragment's last paragraph mark is pasted too (a
+ * block before the caret's paragraph); otherwise the last paragraph runs into the text after the
+ * caret and its mark is not new.
+ */
+declare function trackInsertion(fragment: Uint8Array, revision: Revision, covered: boolean): Uint8Array;
+
+interface StyleDifference {
+    styleId: string;
+    name: string;
+    /** `changed`: defined differently; `missing`: the template defines it, the document does not. */
+    kind: 'changed' | 'missing';
+}
+interface StyleDivergence {
+    styles: StyleDifference[];
+    /** The documents' default paragraph and run formatting differ. */
+    docDefaults: boolean;
+}
+declare function styleDivergence(document: Uint8Array, template: Uint8Array): StyleDivergence;
+/** The template a document records as attached (`w:attachedTemplate`), by file name. */
+declare function attachedTemplateOf(document: Uint8Array): string | undefined;
+
+/** numIds of the template's lists. */
+declare const LEGAL_NUM: {
+    readonly clauses: 1;
+    readonly parties: 2;
+    readonly background: 3;
+    readonly schedules: 4;
+};
+interface BuildingBlockSpec {
+    name: string;
+    category: string;
+    description: string;
+    body: string;
+}
+/** Generic UK execution blocks and document markings: placeholders only, no names. */
+declare const LEGAL_BUILDING_BLOCKS: readonly BuildingBlockSpec[];
+interface LegalTemplateOptions {
+    /** A neutral placeholder letterhead on the first page and a continuation header after it. */
+    letterhead?: boolean;
+    /** A watermark (e.g. "DRAFT") in the page headers. */
+    watermark?: string;
+    /** Include the Quick Parts glossary (default true). */
+    buildingBlocks?: boolean;
+    /** Write a .docx instead of a .dotx (default false). */
+    asDocument?: boolean;
+    /** The starting body of a new document (paragraph XML); default one empty paragraph. */
+    body?: string;
+}
+declare function defaultLegalTemplate(options?: LegalTemplateOptions): Uint8Array;
+
+interface LinkedLevel {
+    /** The style one level down (Tab), if the list has one. */
+    next?: string;
+    /** The style one level up (Shift+Tab). */
+    previous?: string;
+}
+declare function linkedLevelStyles(document: Uint8Array): Record<string, LinkedLevel>;
+
+declare class TemplateError extends Error {
+    constructor(message: string);
+}
+
+export { type ApplyTemplateOptions, type ApplyTemplateReport, type BuildingBlockInfo, LEGAL_BUILDING_BLOCKS, LEGAL_NUM, type LegalTemplateOptions, type LinkedLevel, type Revision, type StyleDifference, type StyleDivergence, TemplateError, applyTemplate, attachedTemplateOf, buildingBlockFragment, composeWithTemplate, defaultLegalTemplate, fragmentClipboardHtml, linkedLevelStyles, listBuildingBlocks, newFromTemplate, styleDivergence, trackInsertion };