@a3s-lab/office 0.1.0

package/dist/internal/features/work/work-docx-citation-import.d.ts

@@ -0,0 +1,23 @@
+export interface ImportedDocxCitationMarkers {
+    citations: ImportedDocxCitationMarker[];
+    bibliographies: ImportedDocxBibliographyMarker[];
+}
+interface ImportedDocxCitationMarker {
+    start: string;
+    end: string;
+    id: string;
+    instruction: string;
+    tags: string[];
+    display: string;
+}
+interface ImportedDocxBibliographyMarker {
+    start: string;
+    end: string;
+    id: string;
+    instruction: string;
+    display: string;
+}
+export declare function markDocxCitationFields(document: Document): ImportedDocxCitationMarkers;
+export declare function applyImportedDocxCitationMarkers(document: Document, markers: ImportedDocxCitationMarkers): void;
+export declare function hasImportedDocxCitationMarkers(markers: ImportedDocxCitationMarkers): boolean;
+export {};

package/dist/internal/features/work/work-docx-column-export.d.ts

@@ -0,0 +1,14 @@
+import type { WorkDocumentSectionLayout } from './work-types';
+export declare function docxSectionColumns(layout: WorkDocumentSectionLayout, pageWidth: number, docx: typeof import('docx')): {
+    count: number;
+    space: number;
+    separate: boolean;
+    equalWidth: boolean;
+    children?: undefined;
+} | {
+    count: number;
+    separate: boolean;
+    equalWidth: boolean;
+    children: import("docx").Column[];
+    space?: undefined;
+};

package/dist/internal/features/work/work-docx-column-import.d.ts

@@ -0,0 +1,2 @@
+import type { WorkDocumentColumns } from './work-types';
+export declare function importDocxColumns(element: Element, fallback: WorkDocumentColumns): WorkDocumentColumns;

package/dist/internal/features/work/work-docx-comment-import.d.ts

@@ -0,0 +1,14 @@
+import type { WorkDocumentComment } from './work-types';
+import { type OoxmlPackage } from './work-ooxml-package';
+export interface ImportedDocxCommentRange {
+    id: string;
+    start: string;
+    end: string;
+}
+export interface ImportedDocxCommentMarkers {
+    comments: WorkDocumentComment[];
+    ranges: ImportedDocxCommentRange[];
+}
+export declare function markDocxComments(document: Document, archive: OoxmlPackage): Promise<ImportedDocxCommentMarkers>;
+export declare function applyImportedDocxCommentMarkers(document: Document, markers: ImportedDocxCommentMarkers): void;
+export declare function hasImportedDocxCommentMarkers(markers: ImportedDocxCommentMarkers): boolean;

package/dist/internal/features/work/work-docx-export-formatting.d.ts

@@ -0,0 +1,30 @@
+import type { TabStopDefinition } from 'docx';
+export declare function paragraphAlignment(element: HTMLElement, docx: typeof import('docx')): "right" | "left" | "center" | "both" | undefined;
+export declare function paragraphDirectionOptions(element: HTMLElement): {
+    bidirectional?: boolean;
+};
+export declare function paragraphBidirectional(element: HTMLElement): boolean | undefined;
+export declare function domDirection(element: HTMLElement): 'ltr' | 'rtl' | undefined;
+export declare function paragraphSpacingOptions(element: HTMLElement, heading: boolean, docx: typeof import('docx')): {
+    lineRule?: "auto" | "exact" | "atLeast" | undefined;
+    line: number;
+    before?: number | undefined;
+    after: number;
+};
+export declare function paragraphIndent(element: HTMLElement, tag: string): {
+    left?: number;
+    right?: number;
+    hanging?: number;
+    firstLine?: number;
+} | undefined;
+export declare function paragraphPaginationOptions(element: HTMLElement): {
+    keepLines: boolean | undefined;
+    keepNext: boolean | undefined;
+    pageBreakBefore: boolean | undefined;
+    widowControl: boolean | undefined;
+};
+export declare function paragraphTabStops(element: HTMLElement, docx: typeof import('docx')): TabStopDefinition[] | undefined;
+export declare function dataBoolean(value: string | undefined): boolean | undefined;
+export declare function cssFontFamily(value: string): string | undefined;
+export declare function cssFontSize(value: string): number | undefined;
+export declare function cssColorToHex(source: string): string | undefined;

package/dist/internal/features/work/work-docx-export-image.d.ts

@@ -0,0 +1,2 @@
+import type { ParagraphChild } from 'docx';
+export declare function imageToDocx(element: HTMLImageElement, docx: typeof import('docx')): Promise<ParagraphChild>;

package/dist/internal/features/work/work-docx-export.d.ts

@@ -0,0 +1,2 @@
+import type { WorkDocumentContent } from './work-types';
+export declare function createDocxBlob(content: WorkDocumentContent): Promise<Blob>;

package/dist/internal/features/work/work-docx-field-export.d.ts

@@ -0,0 +1,2 @@
+import type { ParagraphChild } from 'docx';
+export declare function docxDocumentFieldRun(element: HTMLElement, docx: typeof import('docx')): ParagraphChild;

package/dist/internal/features/work/work-docx-field-import.d.ts

@@ -0,0 +1,16 @@
+import { type WorkDocumentFieldKind } from './work-document-fields';
+export interface ImportedDocxFieldMarkers {
+    fields: ImportedDocxFieldMarker[];
+}
+interface ImportedDocxFieldMarker {
+    start: string;
+    end: string;
+    id: string;
+    kind: WorkDocumentFieldKind;
+    instruction: string;
+    display: string;
+}
+export declare function markDocxBodyFields(document: Document): ImportedDocxFieldMarkers;
+export declare function applyImportedDocxFieldMarkers(document: Document, markers: ImportedDocxFieldMarkers): void;
+export declare function hasImportedDocxFieldMarkers(markers: ImportedDocxFieldMarkers): boolean;
+export {};

package/dist/internal/features/work/work-docx-field-instructions.d.ts

@@ -0,0 +1,8 @@
+export interface DocxFieldOccurrence {
+    instruction: string;
+    start: Element;
+    end: Element;
+}
+export declare function docxFieldInstructions(root: ParentNode): string[];
+export declare function docxFieldOccurrences(root: ParentNode): DocxFieldOccurrence[];
+export declare function docxFieldResultText(field: DocxFieldOccurrence): string;

package/dist/internal/features/work/work-docx-image-layout-import.d.ts

@@ -0,0 +1,12 @@
+import { type WorkDocumentImageLayoutOptions } from './work-document-image-layout';
+export interface ImportedDocxImageLayoutMarker {
+    startMarker: string;
+    endMarker: string;
+    options: WorkDocumentImageLayoutOptions;
+}
+export interface ImportedDocxImageLayoutMarkers {
+    images: ImportedDocxImageLayoutMarker[];
+}
+export declare function markDocxImageLayouts(document: Document): ImportedDocxImageLayoutMarkers;
+export declare function applyImportedDocxImageLayoutMarkers(document: Document, markers: ImportedDocxImageLayoutMarkers): void;
+export declare function hasImportedDocxImageLayoutMarkers(markers: ImportedDocxImageLayoutMarkers): boolean;

package/dist/internal/features/work/work-docx-import.d.ts

@@ -0,0 +1,50 @@
+import { type ImportedDocxCaptionMarkers } from './work-docx-caption-import';
+import { type ImportedDocxChangeMarkers } from './work-docx-change-import';
+import { type ImportedDocxCitationMarkers } from './work-docx-citation-import';
+import { type ImportedDocxCommentMarkers } from './work-docx-comment-import';
+import { type ImportedDocxFieldMarkers } from './work-docx-field-import';
+import { type ImportedDocxListMarkers } from './work-docx-list-import';
+import { type ImportedDocxImageLayoutMarkers } from './work-docx-image-layout-import';
+import { type ImportedDocxParagraphDirectionMarkers } from './work-docx-paragraph-direction-import';
+import { type ImportedDocxParagraphAlignmentMarkers } from './work-docx-paragraph-alignment-import';
+import { type ImportedDocxParagraphIndentMarkers } from './work-docx-paragraph-indent-import';
+import { type ImportedDocxParagraphPaginationMarkers } from './work-docx-paragraph-pagination-import';
+import { type ImportedDocxParagraphSpacingMarkers } from './work-docx-paragraph-spacing-import';
+import { type ImportedDocxRunFormattingMarkers } from './work-docx-run-formatting-import';
+import { type ImportedDocxParagraphTabStopMarkers } from './work-docx-tab-stop-import';
+import { type ImportedDocxTableCellMarkers } from './work-docx-table-cell-import';
+import { type ImportedDocxTableRowMarkers } from './work-docx-table-row-import';
+import { type ImportedDocxTableSizingMarkers } from './work-docx-table-sizing-import';
+import type { WorkDocumentContent, WorkDocumentSectionLayout } from './work-types';
+type ImportedDocumentLayout = Omit<WorkDocumentContent, 'type' | 'html'>;
+export interface PreparedDocxImport {
+    conversionBuffer: ArrayBuffer;
+    sections: Array<{
+        id: string;
+        layout: WorkDocumentSectionLayout;
+    }>;
+    pageColor?: string;
+    captionMarkers: ImportedDocxCaptionMarkers;
+    changeMarkers: ImportedDocxChangeMarkers;
+    commentMarkers: ImportedDocxCommentMarkers;
+    fieldMarkers: ImportedDocxFieldMarkers;
+    citationMarkers: ImportedDocxCitationMarkers;
+    listMarkers: ImportedDocxListMarkers;
+    imageLayoutMarkers: ImportedDocxImageLayoutMarkers;
+    paragraphAlignmentMarkers: ImportedDocxParagraphAlignmentMarkers;
+    paragraphDirectionMarkers: ImportedDocxParagraphDirectionMarkers;
+    paragraphIndentMarkers: ImportedDocxParagraphIndentMarkers;
+    paragraphPaginationMarkers: ImportedDocxParagraphPaginationMarkers;
+    paragraphSpacingMarkers: ImportedDocxParagraphSpacingMarkers;
+    runFormattingMarkers: ImportedDocxRunFormattingMarkers;
+    tabStopMarkers: ImportedDocxParagraphTabStopMarkers;
+    tableCellMarkers: ImportedDocxTableCellMarkers;
+    tableRowMarkers: ImportedDocxTableRowMarkers;
+    tableSizingMarkers: ImportedDocxTableSizingMarkers;
+    bibliography?: WorkDocumentContent['bibliography'];
+    trackChanges: boolean;
+}
+export declare function prepareDocxImport(buffer: ArrayBuffer): Promise<PreparedDocxImport>;
+export declare function applyDocxSectionsToHtml(html: string, sections: PreparedDocxImport['sections'], captionMarkers?: ImportedDocxCaptionMarkers, changeMarkers?: ImportedDocxChangeMarkers, commentMarkers?: ImportedDocxCommentMarkers, fieldMarkers?: ImportedDocxFieldMarkers, citationMarkers?: ImportedDocxCitationMarkers, listMarkers?: ImportedDocxListMarkers, imageLayoutMarkers?: ImportedDocxImageLayoutMarkers, paragraphAlignmentMarkers?: ImportedDocxParagraphAlignmentMarkers, runFormattingMarkers?: ImportedDocxRunFormattingMarkers, paragraphDirectionMarkers?: ImportedDocxParagraphDirectionMarkers, paragraphIndentMarkers?: ImportedDocxParagraphIndentMarkers, paragraphSpacingMarkers?: ImportedDocxParagraphSpacingMarkers, paragraphPaginationMarkers?: ImportedDocxParagraphPaginationMarkers, bibliography?: WorkDocumentContent['bibliography'], tabStopMarkers?: ImportedDocxParagraphTabStopMarkers, tableCellMarkers?: ImportedDocxTableCellMarkers, tableRowMarkers?: ImportedDocxTableRowMarkers, tableSizingMarkers?: ImportedDocxTableSizingMarkers): string;
+export declare function readDocxLayout(buffer: ArrayBuffer): Promise<ImportedDocumentLayout>;
+export {};

package/dist/internal/features/work/work-docx-list-import.d.ts

@@ -0,0 +1,14 @@
+export interface ImportedDocxListMarker {
+    marker: string;
+    start: number;
+    type?: ImportedDocxOrderedListType;
+    bulletStyle?: ImportedDocxBulletListStyle;
+}
+export interface ImportedDocxListMarkers {
+    lists: ImportedDocxListMarker[];
+}
+export type ImportedDocxOrderedListType = 'a' | 'A' | 'i' | 'I';
+export type ImportedDocxBulletListStyle = 'disc' | 'circle' | 'square';
+export declare function markDocxLists(document: Document, numbering: Document | null): ImportedDocxListMarkers;
+export declare function applyImportedDocxListMarkers(document: Document, markers: ImportedDocxListMarkers): void;
+export declare function hasImportedDocxListMarkers(markers: ImportedDocxListMarkers): boolean;

package/dist/internal/features/work/work-docx-note-diagnostics.d.ts

@@ -0,0 +1,3 @@
+import { type OoxmlPackage } from './work-ooxml-package';
+import type { WorkCompatibilityIssue } from './work-types';
+export declare function diagnoseDocxNotes(archive: OoxmlPackage, document: Document | null): Promise<WorkCompatibilityIssue[]>;

package/dist/internal/features/work/work-docx-note-import.d.ts

@@ -0,0 +1,3 @@
+import { type WorkDocumentNote } from './work-document-notes';
+export declare function extractMammothDocumentNotes(document: Document): WorkDocumentNote[];
+export declare function placeMammothDocumentNotes(document: Document, notes: WorkDocumentNote[]): void;

package/dist/internal/features/work/work-docx-page-chrome-diagnostics.d.ts

@@ -0,0 +1,3 @@
+import { type OoxmlPackage } from './work-ooxml-package';
+import type { WorkCompatibilityIssue } from './work-types';
+export declare function diagnoseDocxPageChrome(archive: OoxmlPackage): Promise<WorkCompatibilityIssue[]>;

package/dist/internal/features/work/work-docx-page-chrome-import.d.ts

@@ -0,0 +1,11 @@
+import { type OoxmlPackage, type OoxmlRelationship } from './work-ooxml-package';
+import type { WorkDocumentPageChrome, WorkDocumentSectionLayout } from './work-types';
+type Relationships = Map<string, OoxmlRelationship>;
+export declare function importSectionPageChrome(section: Element, archive: OoxmlPackage, documentRelationships: Relationships, previous: WorkDocumentSectionLayout, oddEvenEnabled: boolean): Promise<{
+    pageChrome: WorkDocumentPageChrome;
+    headerText?: string;
+    footerText?: string;
+    showPageNumbers?: boolean;
+}>;
+export declare function documentUsesOddEvenPageChrome(settings: Document | null): boolean;
+export {};

package/dist/internal/features/work/work-docx-page-color.d.ts

@@ -0,0 +1,2 @@
+export declare function importDocxPageColor(document: Document): string | undefined;
+export declare function patchDocxPageColor(buffer: ArrayBuffer, value: string | undefined): Promise<ArrayBuffer>;

package/dist/internal/features/work/work-docx-paragraph-alignment-import.d.ts

@@ -0,0 +1,12 @@
+import { type DocxParagraphStyleSource } from './work-docx-paragraph-styles';
+export type ImportedDocxParagraphAlignment = 'left' | 'center' | 'right' | 'justify';
+export interface ImportedDocxParagraphAlignmentMarker {
+    marker: string;
+    alignment: ImportedDocxParagraphAlignment;
+}
+export interface ImportedDocxParagraphAlignmentMarkers {
+    paragraphs: ImportedDocxParagraphAlignmentMarker[];
+}
+export declare function markDocxParagraphAlignments(document: Document, styleSource?: DocxParagraphStyleSource): ImportedDocxParagraphAlignmentMarkers;
+export declare function applyImportedDocxParagraphAlignmentMarkers(document: Document, markers: ImportedDocxParagraphAlignmentMarkers): void;
+export declare function hasImportedDocxParagraphAlignmentMarkers(markers: ImportedDocxParagraphAlignmentMarkers): boolean;

package/dist/internal/features/work/work-docx-paragraph-direction-import.d.ts

@@ -0,0 +1,12 @@
+import type { DocumentParagraphDirection } from './work-document-paragraph-formatting';
+import { type DocxParagraphStyleSource } from './work-docx-paragraph-styles';
+export interface ImportedDocxParagraphDirectionMarker {
+    marker: string;
+    direction: DocumentParagraphDirection;
+}
+export interface ImportedDocxParagraphDirectionMarkers {
+    paragraphs: ImportedDocxParagraphDirectionMarker[];
+}
+export declare function markDocxParagraphDirections(document: Document, styleSource?: DocxParagraphStyleSource): ImportedDocxParagraphDirectionMarkers;
+export declare function applyImportedDocxParagraphDirectionMarkers(document: Document, markers: ImportedDocxParagraphDirectionMarkers): void;
+export declare function hasImportedDocxParagraphDirectionMarkers(markers: ImportedDocxParagraphDirectionMarkers): boolean;

package/dist/internal/features/work/work-docx-paragraph-indent-import.d.ts

@@ -0,0 +1,12 @@
+import { type DocumentParagraphIndent } from './work-document-paragraph-formatting';
+import { type DocxParagraphStyleSource } from './work-docx-paragraph-styles';
+export interface ImportedDocxParagraphIndentMarker {
+    marker: string;
+    indent: DocumentParagraphIndent;
+}
+export interface ImportedDocxParagraphIndentMarkers {
+    paragraphs: ImportedDocxParagraphIndentMarker[];
+}
+export declare function markDocxParagraphIndents(document: Document, styleSource?: DocxParagraphStyleSource): ImportedDocxParagraphIndentMarkers;
+export declare function applyImportedDocxParagraphIndentMarkers(document: Document, markers: ImportedDocxParagraphIndentMarkers): void;
+export declare function hasImportedDocxParagraphIndentMarkers(markers: ImportedDocxParagraphIndentMarkers): boolean;

package/dist/internal/features/work/work-docx-paragraph-pagination-import.d.ts

@@ -0,0 +1,12 @@
+import type { DocumentParagraphPagination } from './work-document-paragraph-formatting';
+import { type DocxParagraphStyleSource } from './work-docx-paragraph-styles';
+export interface ImportedDocxParagraphPaginationMarker {
+    marker: string;
+    pagination: Partial<DocumentParagraphPagination>;
+}
+export interface ImportedDocxParagraphPaginationMarkers {
+    paragraphs: ImportedDocxParagraphPaginationMarker[];
+}
+export declare function markDocxParagraphPagination(document: Document, styleSource?: DocxParagraphStyleSource): ImportedDocxParagraphPaginationMarkers;
+export declare function applyImportedDocxParagraphPaginationMarkers(document: Document, markers: ImportedDocxParagraphPaginationMarkers): void;
+export declare function hasImportedDocxParagraphPaginationMarkers(markers: ImportedDocxParagraphPaginationMarkers): boolean;

package/dist/internal/features/work/work-docx-paragraph-spacing-import.d.ts

@@ -0,0 +1,12 @@
+import type { DocumentParagraphSpacing } from './work-document-paragraph-formatting';
+import { type DocxParagraphStyleSource } from './work-docx-paragraph-styles';
+export interface ImportedDocxParagraphSpacingMarker {
+    marker: string;
+    spacing: Partial<DocumentParagraphSpacing>;
+}
+export interface ImportedDocxParagraphSpacingMarkers {
+    paragraphs: ImportedDocxParagraphSpacingMarker[];
+}
+export declare function markDocxParagraphSpacing(document: Document, styleSource?: DocxParagraphStyleSource): ImportedDocxParagraphSpacingMarkers;
+export declare function applyImportedDocxParagraphSpacingMarkers(document: Document, markers: ImportedDocxParagraphSpacingMarkers): void;
+export declare function hasImportedDocxParagraphSpacingMarkers(markers: ImportedDocxParagraphSpacingMarkers): boolean;

package/dist/internal/features/work/work-docx-paragraph-styles.d.ts

@@ -0,0 +1,18 @@
+interface DocxStyle {
+    basedOn?: string;
+    paragraphProperties?: Element;
+    runProperties?: Element;
+}
+export interface DocxParagraphStyleResolver {
+    defaultProperties?: Element;
+    defaultRunProperties?: Element;
+    defaultStyleId?: string;
+    styles: ReadonlyMap<string, DocxStyle>;
+    characterStyles: ReadonlyMap<string, DocxStyle>;
+}
+export type DocxParagraphStyleSource = Document | DocxParagraphStyleResolver | null | undefined;
+export declare function createDocxParagraphStyleResolver(stylesDocument?: Document | null): DocxParagraphStyleResolver;
+export declare function resolveDocxParagraphStyleResolver(source: DocxParagraphStyleSource): DocxParagraphStyleResolver;
+export declare function docxParagraphPropertySources(directProperties: Element | undefined, resolver: DocxParagraphStyleResolver): Element[];
+export declare function docxRunPropertySources(paragraphProperties: Element | undefined, runProperties: Element | undefined, resolver: DocxParagraphStyleResolver): Element[];
+export {};

package/dist/internal/features/work/work-docx-run-formatting-import.d.ts

@@ -0,0 +1,19 @@
+import { type DocxParagraphStyleSource } from './work-docx-paragraph-styles';
+import { type DocxThemeSource } from './work-docx-theme';
+export interface ImportedDocxRunFormatting {
+    fontFamily?: string;
+    fontSize?: number;
+    color?: string;
+    backgroundColor?: string;
+}
+export interface ImportedDocxRunFormattingMarker {
+    startMarker: string;
+    endMarker: string;
+    formatting: ImportedDocxRunFormatting;
+}
+export interface ImportedDocxRunFormattingMarkers {
+    runs: ImportedDocxRunFormattingMarker[];
+}
+export declare function markDocxRunFormatting(document: Document, styleSource?: DocxParagraphStyleSource, themeSource?: DocxThemeSource): ImportedDocxRunFormattingMarkers;
+export declare function applyImportedDocxRunFormattingMarkers(document: Document, markers: ImportedDocxRunFormattingMarkers): void;
+export declare function hasImportedDocxRunFormattingMarkers(markers: ImportedDocxRunFormattingMarkers): boolean;

package/dist/internal/features/work/work-docx-tab-stop-import.d.ts

@@ -0,0 +1,13 @@
+import { type DocumentTabStop } from './work-document-tab-stops';
+import { type DocxParagraphStyleSource } from './work-docx-paragraph-styles';
+export interface ImportedDocxParagraphTabStopMarker {
+    marker: string;
+    tabStops: DocumentTabStop[];
+}
+export interface ImportedDocxParagraphTabStopMarkers {
+    paragraphs: ImportedDocxParagraphTabStopMarker[];
+    inlineTabs: string[];
+}
+export declare function markDocxParagraphTabStops(document: Document, styleSource?: DocxParagraphStyleSource): ImportedDocxParagraphTabStopMarkers;
+export declare function applyImportedDocxParagraphTabStopMarkers(document: Document, markers: ImportedDocxParagraphTabStopMarkers): void;
+export declare function hasImportedDocxParagraphTabStopMarkers(markers: ImportedDocxParagraphTabStopMarkers): boolean;

package/dist/internal/features/work/work-docx-table-cell-export.d.ts

@@ -0,0 +1,4 @@
+import type { ITableCellOptions } from 'docx';
+type TableCellPresentationOptions = Partial<Pick<ITableCellOptions, 'borders' | 'shading' | 'verticalAlign'>>;
+export declare function documentTableCellDocxOptions(cell: HTMLTableCellElement, docx: typeof import('docx')): TableCellPresentationOptions;
+export {};

package/dist/internal/features/work/work-docx-table-cell-import.d.ts

@@ -0,0 +1,16 @@
+export type ImportedDocxTableCellVerticalAlign = 'top' | 'middle' | 'bottom';
+export type ImportedDocxTableCellBorderStyle = 'solid' | 'dashed' | 'dotted' | 'double' | 'none';
+export interface ImportedDocxTableCellMarker {
+    marker: string;
+    backgroundColor?: string;
+    verticalAlign?: ImportedDocxTableCellVerticalAlign;
+    borderColor?: string;
+    borderStyle?: ImportedDocxTableCellBorderStyle;
+    borderWidth?: number;
+}
+export interface ImportedDocxTableCellMarkers {
+    cells: ImportedDocxTableCellMarker[];
+}
+export declare function markDocxTableCells(document: Document): ImportedDocxTableCellMarkers;
+export declare function applyImportedDocxTableCellMarkers(document: Document, markers: ImportedDocxTableCellMarkers): void;
+export declare function hasImportedDocxTableCellMarkers(markers: ImportedDocxTableCellMarkers): boolean;

package/dist/internal/features/work/work-docx-table-row-import.d.ts

@@ -0,0 +1,13 @@
+export interface ImportedDocxTableRowMarker {
+    marker: string;
+    cantSplit?: boolean;
+    repeatHeader?: boolean;
+    rowHeight?: number;
+    rowHeightRule?: 'atLeast' | 'exact';
+}
+export interface ImportedDocxTableRowMarkers {
+    rows: ImportedDocxTableRowMarker[];
+}
+export declare function markDocxTableRows(document: Document): ImportedDocxTableRowMarkers;
+export declare function applyImportedDocxTableRowMarkers(document: Document, markers: ImportedDocxTableRowMarkers): void;
+export declare function hasImportedDocxTableRowMarkers(markers: ImportedDocxTableRowMarkers): boolean;

package/dist/internal/features/work/work-docx-table-sizing-export.d.ts

@@ -0,0 +1,8 @@
+import type { ITableCellOptions, ITableOptions, ITableRowOptions } from 'docx';
+type TableSizingDocxOptions = Pick<ITableOptions, 'columnWidths' | 'layout' | 'width'>;
+type TableCellSizingDocxOptions = Pick<ITableCellOptions, 'width'>;
+type TableRowSizingDocxOptions = Pick<ITableRowOptions, 'height'>;
+export declare function documentTableSizingDocxOptions(table: HTMLTableElement, docx: typeof import('docx')): TableSizingDocxOptions;
+export declare function documentTableCellSizingDocxOptions(cell: HTMLTableCellElement, docx: typeof import('docx')): TableCellSizingDocxOptions;
+export declare function documentTableRowSizingDocxOptions(row: HTMLTableRowElement, docx: typeof import('docx')): TableRowSizingDocxOptions;
+export {};

package/dist/internal/features/work/work-docx-table-sizing-import.d.ts

@@ -0,0 +1,12 @@
+import type { DocumentTableLayoutMode } from './work-document-table-sizing';
+export interface ImportedDocxTableSizingMarker {
+    marker: string;
+    layoutMode: DocumentTableLayoutMode;
+    columnWidths: number[];
+}
+export interface ImportedDocxTableSizingMarkers {
+    tables: ImportedDocxTableSizingMarker[];
+}
+export declare function markDocxTableSizing(document: Document): ImportedDocxTableSizingMarkers;
+export declare function applyImportedDocxTableSizingMarkers(document: Document, markers: ImportedDocxTableSizingMarkers): void;
+export declare function hasImportedDocxTableSizingMarkers(markers: ImportedDocxTableSizingMarkers): boolean;

package/dist/internal/features/work/work-docx-theme.d.ts

@@ -0,0 +1,9 @@
+export interface DocxThemeResolver {
+    colors: ReadonlyMap<string, string>;
+    fonts: ReadonlyMap<string, string>;
+}
+export type DocxThemeSource = Document | DocxThemeResolver | null | undefined;
+export declare function createDocxThemeResolver(themeDocument?: Document | null): DocxThemeResolver;
+export declare function resolveDocxThemeResolver(source: DocxThemeSource): DocxThemeResolver;
+export declare function docxThemeFont(resolver: DocxThemeResolver, key: string | null): string | undefined;
+export declare function docxThemeColor(resolver: DocxThemeResolver, key: string | null, tint?: string | null, shade?: string | null): string | undefined;

package/dist/internal/features/work/work-file-data.d.ts

@@ -0,0 +1 @@
+export declare function materializeWorkFile(file: File): Promise<File>;

package/dist/internal/features/work/work-file-download.d.ts

@@ -0,0 +1,3 @@
+export declare function fileNameWithoutExtension(value: string): string;
+export declare function safeFileName(value: string): string;
+export declare function downloadBlob(blob: Blob, name: string): void;

package/dist/internal/features/work/work-file-io.d.ts

@@ -0,0 +1,8 @@
+import { type WorkPresentationExportOptions } from './work-presentation-file-io';
+import { type WorkArtifact, type WorkArtifactKind } from './work-types';
+export declare const WORK_IMPORT_ACCEPT: string;
+export type WorkArtifactExportOptions = WorkPresentationExportOptions;
+export declare function importWorkFile(file: File): Promise<WorkArtifact>;
+export declare function exportWorkArtifact(artifact: WorkArtifact, options?: WorkArtifactExportOptions): Promise<void>;
+export declare function createWorkArtifactBlob(artifact: WorkArtifact, options?: WorkArtifactExportOptions): Promise<Blob>;
+export declare function workKindForFile(file: File): WorkArtifactKind | null;

package/dist/internal/features/work/work-markdown-extensions.d.ts

@@ -0,0 +1,19 @@
+import { Extension, type Extensions } from '@tiptap/core';
+export interface SetWorkMarkdownOptions {
+    emitUpdate?: boolean;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        workMarkdown: {
+            setWorkMarkdown: (markdown: string, options?: SetWorkMarkdownOptions) => ReturnType;
+        };
+    }
+}
+export declare const WorkMarkdown: Extension<any, any>;
+export declare function createWorkMarkdownExtensions(): Extensions;
+export declare function markdownTaskCheckboxLabel(node: {
+    attrs: {
+        checked?: boolean;
+    };
+    textContent: string;
+}): string;

package/dist/internal/features/work/work-markdown-file-io.d.ts

@@ -0,0 +1,3 @@
+import type { WorkArtifact } from './work-types';
+export declare function importWorkMarkdownFile(file: File): Promise<WorkArtifact>;
+export declare function createWorkMarkdownBlob(artifact: WorkArtifact): Blob;

package/dist/internal/features/work/work-markdown-selection-menu.d.ts

@@ -0,0 +1,57 @@
+import type { Editor } from '@tiptap/core';
+import type { MarkdownSourceEdit, MarkdownSourceSelection } from './editors/markdown-source-commands';
+import type { WorkDocumentSelectionMenuIcon } from './work-document-selection-menu';
+import type { WorkMarkdownContent } from './work-types';
+export type WorkMarkdownSelectionMenuIcon = WorkDocumentSelectionMenuIcon;
+export type WorkMarkdownSelectionCommandFailure = 'command-rejected' | 'editor-unavailable' | 'invalid-text' | 'read-only' | 'stale-selection';
+export type WorkMarkdownSelectionCommandResult = {
+    applied: true;
+} | {
+    applied: false;
+    reason: WorkMarkdownSelectionCommandFailure;
+};
+export interface WorkMarkdownSelectionCommands {
+    copyText(): Promise<boolean>;
+    insertAfter(text: string): WorkMarkdownSelectionCommandResult;
+    insertBefore(text: string): WorkMarkdownSelectionCommandResult;
+    replaceText(text: string): WorkMarkdownSelectionCommandResult;
+}
+export interface WorkMarkdownSelectionSnapshot {
+    selection: {
+        surface: 'source' | 'visual';
+        from: number;
+        to: number;
+        text: string;
+        rawText: string;
+        beforeText: string;
+        afterText: string;
+    };
+    document: {
+        content: WorkMarkdownContent;
+        markdown: string;
+        text: string;
+    };
+}
+export interface WorkMarkdownSelectionContext extends WorkMarkdownSelectionSnapshot {
+    commands: WorkMarkdownSelectionCommands;
+}
+export interface WorkMarkdownSelectionMenuItem {
+    id: string;
+    label: string;
+    icon?: WorkMarkdownSelectionMenuIcon;
+    shortcut?: string;
+    ariaKeyShortcut?: string;
+    danger?: boolean;
+    disabled?: boolean;
+    separatorBefore?: boolean;
+    onSelect(context: WorkMarkdownSelectionContext): void | Promise<void>;
+}
+export type WorkGetMarkdownSelectionMenuItems = (context: WorkMarkdownSelectionSnapshot) => readonly WorkMarkdownSelectionMenuItem[];
+export interface WorkMarkdownSelectionAction {
+    context: WorkMarkdownSelectionContext;
+    dispose(): void;
+}
+export declare function createWorkMarkdownSourceSelectionSnapshot(markdown: string, selection: MarkdownSourceSelection, content: WorkMarkdownContent): WorkMarkdownSelectionSnapshot | null;
+export declare function createWorkMarkdownVisualSelectionSnapshot(editor: Editor, content: WorkMarkdownContent): WorkMarkdownSelectionSnapshot | null;
+export declare function createWorkMarkdownSourceSelectionAction(snapshot: WorkMarkdownSelectionSnapshot, getMarkdown: () => string, applyEdit: (edit: MarkdownSourceEdit) => boolean): WorkMarkdownSelectionAction;
+export declare function createWorkMarkdownVisualSelectionAction(editor: Editor, snapshot: WorkMarkdownSelectionSnapshot): WorkMarkdownSelectionAction;

package/dist/internal/features/work/work-office-diagnostics.d.ts

@@ -0,0 +1,9 @@
+import type { WorkBook } from 'xlsx';
+import type { WorkCompatibilityReport } from './work-types';
+interface ConversionMessage {
+    type: string;
+    message: string;
+}
+export declare function analyzeDocxCompatibility(file: File, messages: ConversionMessage[]): Promise<WorkCompatibilityReport>;
+export declare function analyzeSpreadsheetCompatibility(file: File, extension: string, workbook: WorkBook): Promise<WorkCompatibilityReport | null>;
+export {};

package/dist/internal/features/work/work-ooxml-package.d.ts

@@ -0,0 +1,28 @@
+export interface OoxmlRelationship {
+    id: string;
+    target: string;
+    type: string;
+    targetMode?: string;
+}
+export declare class OoxmlPackage {
+    private readonly zip;
+    private constructor();
+    static load(buffer: ArrayBuffer): Promise<OoxmlPackage>;
+    has(partPath: string): boolean;
+    paths(prefix: string): string[];
+    text(partPath: string): Promise<string>;
+    xml(partPath: string): Promise<Document>;
+    bytes(partPath: string): Promise<Uint8Array>;
+    relationships(sourcePart: string): Promise<Map<string, OoxmlRelationship>>;
+}
+export declare function parseXml(source: string, label?: string): Document;
+export declare function attribute(element: Element, name: string): string | null;
+export declare function xmlNamespacePrefix(element: Element, namespace: string | null): string | null;
+export declare function directChildren(parent: ParentNode, localName?: string): Element[];
+export declare function directChild(parent: ParentNode, localName: string): Element | undefined;
+export declare function descendants(parent: ParentNode, localName: string): Element[];
+export declare function firstDescendant(parent: ParentNode | null | undefined, localName: string): Element | undefined;
+export declare function childPath(parent: ParentNode | null | undefined, ...localNames: string[]): Element | undefined;
+export declare function resolvePartTarget(sourcePart: string, target: string): string;
+export declare function contentTypeForPart(partPath: string): string;
+export declare function bytesToDataUrl(bytes: Uint8Array, contentType: string): string;

package/dist/internal/features/work/work-pdf-export.d.ts

@@ -0,0 +1,23 @@
+import type { WorkArtifact, WorkSpreadsheetPaperSize } from './work-types';
+type PdfPageSize = WorkSpreadsheetPaperSize;
+export interface WorkPdfExportOptions {
+    pageIndexes?: number[];
+}
+export interface WorkLiveDocumentPdfSurface {
+    element: HTMLElement;
+    orientation: 'portrait' | 'landscape';
+    pageCount: number;
+    pageGap: number;
+    pageHeight: number;
+    pageSize: PdfPageSize;
+    pageWidth: number;
+}
+export declare function exportWorkArtifactPdf(artifact: WorkArtifact, options?: WorkPdfExportOptions): Promise<void>;
+export declare function workLiveDocumentPdfSurfaceForExport(artifactId: string): WorkLiveDocumentPdfSurface | null;
+export declare function workPdfPagesForExport(artifactId: string, options?: WorkPdfExportOptions): HTMLElement[];
+export declare function workLiveDocumentPdfCaptureBatches(pageIndexes: readonly number[], page: Pick<WorkLiveDocumentPdfSurface, 'pageGap' | 'pageHeight' | 'pageCount'>): Array<{
+    captureHeight: number;
+    firstPageIndex: number;
+    pageIndexes: number[];
+}>;
+export {};

package/dist/internal/features/work/work-pptx-chart-axes.d.ts

@@ -0,0 +1,3 @@
+import type { WorkSlide, WorkSlideChart, WorkSlideChartAxis, WorkSpreadsheetChartAxisPosition } from './work-types';
+export declare function patchPptxChartAxes(buffer: ArrayBuffer, slides: readonly WorkSlide[]): Promise<ArrayBuffer>;
+export declare function writePptxChartAxis(document: Document, axisNode: Element, chart: WorkSlideChart, position: WorkSpreadsheetChartAxisPosition, axis: WorkSlideChartAxis | undefined): void;

package/dist/internal/features/work/work-pptx-chart-axis-diagnostics.d.ts

@@ -0,0 +1,5 @@
+export interface PptxChartAxisDiagnostic {
+    code: string;
+    message: string;
+}
+export declare function readPptxChartAxisDiagnostics(document: Document): PptxChartAxisDiagnostic[];