@a3s-lab/office 0.2.2 → 0.4.0

package/dist/internal/collaboration/office-document-collaboration-sidecars.d.ts

@@ -0,0 +1,16 @@
+import type * as Y from 'yjs';
+import type { WorkDocumentBibliography, WorkDocumentComment, WorkDocumentContent } from '../features/work/work-types';
+import { type WorkOfficeCollaborationOrigin, type WorkOfficeCollaborationSession } from './office-collaboration';
+export interface WorkOfficeDocumentSidecars {
+    pageColor?: string;
+    trackChanges?: boolean;
+    comments?: WorkDocumentComment[];
+    bibliography?: WorkDocumentBibliography;
+}
+export declare function assertWorkOfficeDocumentSidecarsEmpty(session: WorkOfficeCollaborationSession): void;
+export declare function initializeWorkOfficeDocumentSidecars(session: WorkOfficeCollaborationSession, content: WorkDocumentContent): void;
+export declare function readWorkOfficeDocumentSidecars(session: WorkOfficeCollaborationSession): WorkOfficeDocumentSidecars;
+export declare function updateWorkOfficeDocumentSidecars(session: WorkOfficeCollaborationSession, previous: WorkDocumentContent, next: WorkDocumentContent, origin: WorkOfficeCollaborationOrigin): boolean;
+export declare function workOfficeDocumentSidecarUndoScope(session: WorkOfficeCollaborationSession): Array<Y.Map<unknown> | Y.Array<string>>;
+export declare function workOfficeDocumentSidecarsChanged(session: WorkOfficeCollaborationSession, transaction: Y.Transaction): boolean;
+export declare function validatedWorkOfficeDocumentSidecars(content: WorkDocumentContent): WorkOfficeDocumentSidecars;

package/dist/internal/collaboration/office-document-collaboration.d.ts

@@ -0,0 +1,45 @@
+import { type Extensions } from '@tiptap/core';
+import * as Y from 'yjs';
+import { createWorkDocumentExtensions } from '../features/work/work-document-extensions';
+import type { WorkDocumentContent, WorkDocumentNode } from '../features/work/work-types';
+import { type WorkOfficeCollaborationOrigin, type WorkOfficeCollaborationSession } from './office-collaboration';
+export interface WorkOfficeDocumentCollaborationBindingOptions {
+    /**
+     * Behavior-only extensions are supported. Node and mark extensions must be
+     * part of the versioned Office schema before they can enter shared content.
+     */
+    additionalExtensions?: Extensions;
+    captureTimeoutMs?: number;
+    onFirstRender?: () => void;
+    origin?: WorkOfficeCollaborationOrigin;
+    workExtensions?: Omit<Parameters<typeof createWorkDocumentExtensions>[0], 'collaborative'>;
+}
+export interface WorkOfficeDocumentCollaborationChange {
+    content: WorkDocumentContent;
+    local: boolean;
+    origin: unknown;
+}
+export interface WorkOfficeDocumentCollaborationBinding {
+    readonly extensions: Extensions;
+    readonly fragment: Y.XmlFragment;
+    readonly origin: WorkOfficeCollaborationOrigin;
+    content(): WorkDocumentContent;
+    updateSidecars(previous: WorkDocumentContent, next: WorkDocumentContent): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    stopCapturing(): void;
+    subscribe(listener: (change: WorkOfficeDocumentCollaborationChange) => void): () => void;
+    subscribeError(listener: (error: unknown) => void): () => void;
+    subscribeHistory(listener: () => void): () => void;
+    destroy(): void;
+}
+export declare function initializeWorkOfficeDocumentCollaboration(session: WorkOfficeCollaborationSession, content: WorkDocumentContent): {
+    initialized: boolean;
+    content: WorkDocumentContent;
+};
+export declare function readWorkOfficeDocumentCollaboration(session: WorkOfficeCollaborationSession): WorkDocumentContent;
+export declare function createWorkOfficeDocumentCollaborationBinding(session: WorkOfficeCollaborationSession, options?: WorkOfficeDocumentCollaborationBindingOptions): WorkOfficeDocumentCollaborationBinding;
+export declare function workOfficeDocumentCollaborationFragment(session: WorkOfficeCollaborationSession): Y.XmlFragment;
+export declare function workOfficeDocumentCollaborationNode(session: WorkOfficeCollaborationSession): WorkDocumentNode;

package/dist/internal/collaboration/office-markdown-collaboration.d.ts

@@ -0,0 +1,31 @@
+import type { WorkMarkdownContent } from '../features/work/work-types';
+import { type WorkOfficeCollaborationOrigin, type WorkOfficeCollaborationSession } from './office-collaboration';
+export interface WorkOfficeMarkdownCollaborationChange {
+    content: WorkMarkdownContent;
+    local: boolean;
+    origin: unknown;
+}
+export interface WorkOfficeMarkdownCollaborationBindingOptions {
+    origin?: WorkOfficeCollaborationOrigin;
+    captureTimeoutMs?: number;
+}
+export interface WorkOfficeMarkdownCollaborationBinding {
+    readonly origin: WorkOfficeCollaborationOrigin;
+    content(): WorkMarkdownContent;
+    replace(markdown: string): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    stopCapturing(): void;
+    subscribe(listener: (change: WorkOfficeMarkdownCollaborationChange) => void): () => void;
+    subscribeHistory(listener: () => void): () => void;
+    destroy(): void;
+}
+export declare function initializeWorkOfficeMarkdownCollaboration(session: WorkOfficeCollaborationSession, content: WorkMarkdownContent): {
+    initialized: boolean;
+    content: WorkMarkdownContent;
+};
+export declare function readWorkOfficeMarkdownCollaboration(session: WorkOfficeCollaborationSession): WorkMarkdownContent;
+export declare function replaceWorkOfficeMarkdownCollaboration(session: WorkOfficeCollaborationSession, markdown: string, origin?: WorkOfficeCollaborationOrigin): boolean;
+export declare function createWorkOfficeMarkdownCollaborationBinding(session: WorkOfficeCollaborationSession, options?: WorkOfficeMarkdownCollaborationBindingOptions): WorkOfficeMarkdownCollaborationBinding;

package/dist/internal/collaboration/office-pdf-collaboration-claims.d.ts

@@ -0,0 +1,4 @@
+import type * as Y from 'yjs';
+import type { WorkPdfCollaborationContent } from './office-pdf-collaboration-types';
+export declare function appendWorkOfficePdfRecordClaims(claims: Y.Array<string>, previous: WorkPdfCollaborationContent | undefined, next: WorkPdfCollaborationContent): void;
+export declare function assertWorkOfficePdfRecordClaims(claims: Y.Array<string>, content: WorkPdfCollaborationContent): void;

package/dist/internal/collaboration/office-pdf-collaboration-conflicts.d.ts

@@ -0,0 +1,2 @@
+import type { WorkPdfCollaborationContent } from './office-pdf-collaboration-types';
+export declare function assertWorkOfficePdfPatchSafe(previous: WorkPdfCollaborationContent, next: WorkPdfCollaborationContent, shared: WorkPdfCollaborationContent): void;

package/dist/internal/collaboration/office-pdf-collaboration-model.d.ts

@@ -0,0 +1,26 @@
+import type * as Y from 'yjs';
+import { type WorkOfficePdfRecordCollectionRoots } from './office-pdf-collaboration-records';
+import type { WorkPdfCollaborationContent } from './office-pdf-collaboration-types';
+export { validateWorkOfficePdfCollaborationContent } from './office-pdf-collaboration-validation';
+export declare const PDF_SOURCE_ROOT = "pdf.source";
+export declare const PDF_SOURCE_IDENTITIES_ROOT = "pdf.source-identities";
+export declare const PDF_RECORD_CLAIMS_ROOT = "pdf.record-claims";
+export interface WorkOfficePdfRoots {
+    source: Y.Map<unknown>;
+    sourceIdentities: Y.Array<string>;
+    annotations: WorkOfficePdfRecordCollectionRoots;
+    formValues: WorkOfficePdfRecordCollectionRoots;
+    signaturePlacements: WorkOfficePdfRecordCollectionRoots;
+    redactionProposals: WorkOfficePdfRecordCollectionRoots;
+    pageOperations: WorkOfficePdfRecordCollectionRoots;
+    reviewDecisions: WorkOfficePdfRecordCollectionRoots;
+    recordClaims: Y.Array<string>;
+}
+export declare function workOfficePdfRoots(document: Y.Doc, rootName: (suffix: string) => string): WorkOfficePdfRoots;
+export declare function initializeWorkOfficePdfRoots(roots: WorkOfficePdfRoots, content: WorkPdfCollaborationContent): void;
+export declare function readWorkOfficePdfRoots(roots: WorkOfficePdfRoots): WorkPdfCollaborationContent;
+export declare function patchWorkOfficePdfRoots(roots: WorkOfficePdfRoots, previous: WorkPdfCollaborationContent, next: WorkPdfCollaborationContent): void;
+export declare function assertWorkOfficePdfRootsEmpty(roots: WorkOfficePdfRoots): void;
+export declare function workOfficePdfUndoScope(roots: WorkOfficePdfRoots): Array<Y.Map<unknown> | Y.Array<string>>;
+export declare function workOfficePdfIrreversibleScope(roots: WorkOfficePdfRoots): Array<Y.Map<unknown> | Y.Array<string>>;
+export declare function workOfficePdfIrreversibleChange(roots: WorkOfficePdfRoots, transaction: Y.Transaction): boolean;

package/dist/internal/collaboration/office-pdf-collaboration-records.d.ts

@@ -0,0 +1,21 @@
+import type * as Y from 'yjs';
+export interface WorkOfficePdfRecordCollectionRoots {
+    presence: Y.Map<unknown>;
+    fields: Y.Map<unknown>;
+    order: Y.Array<string>;
+}
+export declare function workOfficePdfRecordCollectionRoots(document: Y.Doc, rootName: (suffix: string) => string, name: string): WorkOfficePdfRecordCollectionRoots;
+export declare function patchWorkOfficePdfRecords<T extends {
+    id: string;
+}>(roots: WorkOfficePdfRecordCollectionRoots, previous: readonly T[], next: readonly T[], label: string): void;
+export declare function readWorkOfficePdfRecords<T extends Record<string, unknown> & {
+    id: string;
+}>(roots: WorkOfficePdfRecordCollectionRoots, label: string): T[];
+export declare function assertWorkOfficePdfRecordCollectionEmpty(roots: WorkOfficePdfRecordCollectionRoots): boolean;
+export declare function workOfficePdfRecordCollectionUndoScope(roots: WorkOfficePdfRecordCollectionRoots): Array<Y.Map<unknown> | Y.Array<string>>;
+/**
+ * Reports whether a transaction changed one recursively addressed record
+ * field. This lets format bindings keep an otherwise mutable collection on
+ * the local undo stack while treating selected fields as irreversible.
+ */
+export declare function workOfficePdfRecordFieldChanged(transaction: Y.Transaction, roots: WorkOfficePdfRecordCollectionRoots, path: readonly string[]): boolean;

package/dist/internal/collaboration/office-pdf-collaboration-types.d.ts

@@ -0,0 +1,91 @@
+export interface WorkPdfCollaborationSource {
+    /** Lowercase SHA-256 digest of the immutable source bytes. */
+    sha256: string;
+    byteLength: number;
+    pageCount: number;
+}
+export interface WorkPdfCollaborationAnnotation {
+    id: string;
+    pageIndex: number;
+    source: 'base' | 'created';
+    /** Portable, JSON-compatible annotation object including matching id/pageIndex. */
+    annotation: Record<string, unknown>;
+    /** Durable tombstone. Annotation records are never physically removed. */
+    deleted?: true;
+}
+export interface WorkPdfCollaborationFormValue {
+    /** Stable fully-qualified PDF field name. */
+    id: string;
+    value: string;
+}
+export interface WorkPdfCollaborationSignatureAppearance {
+    /** Host-owned encrypted/private asset reference; signature bytes are not in Yjs. */
+    assetId: string;
+    sha256: string;
+    byteLength: number;
+    mimeType: string;
+}
+export interface WorkPdfCollaborationSignaturePlacement {
+    id: string;
+    annotationId: string;
+    pageIndex: number;
+    kind: 'signature' | 'initials';
+    actorId: string;
+    createdAt: string;
+    appearance: WorkPdfCollaborationSignatureAppearance;
+}
+export interface WorkPdfCollaborationRect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export interface WorkPdfCollaborationRedactionProposal {
+    id: string;
+    pageIndex: number;
+    rects: WorkPdfCollaborationRect[];
+    proposedBy: string;
+    proposedAt: string;
+    reason?: string;
+    text?: string;
+}
+interface WorkPdfCollaborationPageOperationBase {
+    id: string;
+    proposedBy: string;
+    proposedAt: string;
+}
+export interface WorkPdfCollaborationRotatePagesOperation extends WorkPdfCollaborationPageOperationBase {
+    kind: 'rotate';
+    pageIndices: number[];
+    degrees: 90 | 180 | 270;
+}
+export interface WorkPdfCollaborationDeletePagesOperation extends WorkPdfCollaborationPageOperationBase {
+    kind: 'delete';
+    pageIndices: number[];
+}
+export interface WorkPdfCollaborationReorderPagesOperation extends WorkPdfCollaborationPageOperationBase {
+    kind: 'reorder';
+    /** Complete zero-based permutation of immutable source pages. */
+    pageOrder: number[];
+}
+export type WorkPdfCollaborationPageOperation = WorkPdfCollaborationRotatePagesOperation | WorkPdfCollaborationDeletePagesOperation | WorkPdfCollaborationReorderPagesOperation;
+export interface WorkPdfCollaborationReviewDecision {
+    id: string;
+    targetKind: 'redaction' | 'page-operation';
+    targetId: string;
+    decision: 'approve' | 'reject';
+    actorId: string;
+    createdAt: string;
+}
+export interface WorkPdfCollaborationContent {
+    type: 'pdf';
+    source: WorkPdfCollaborationSource;
+    annotations: WorkPdfCollaborationAnnotation[];
+    formValues: WorkPdfCollaborationFormValue[];
+    signaturePlacements: WorkPdfCollaborationSignaturePlacement[];
+    redactionProposals: WorkPdfCollaborationRedactionProposal[];
+    pageOperations: WorkPdfCollaborationPageOperation[];
+    reviewDecisions: WorkPdfCollaborationReviewDecision[];
+}
+export declare function createWorkPdfCollaborationContent(source: WorkPdfCollaborationSource): WorkPdfCollaborationContent;
+export {};

package/dist/internal/collaboration/office-pdf-collaboration-validation.d.ts

@@ -0,0 +1,4 @@
+import type { WorkPdfCollaborationContent } from './office-pdf-collaboration-types';
+export declare function validateWorkOfficePdfCollaborationContent(content: WorkPdfCollaborationContent): WorkPdfCollaborationContent;
+export declare function validateSharedWorkOfficePdfCollaborationContent(content: WorkPdfCollaborationContent): WorkPdfCollaborationContent;
+export declare function invalidWorkOfficePdfShared(label: string): never;

package/dist/internal/collaboration/office-pdf-collaboration.d.ts

@@ -0,0 +1,35 @@
+import { type WorkOfficeCollaborationOrigin, type WorkOfficeCollaborationSession } from './office-collaboration';
+import type { WorkPdfCollaborationContent, WorkPdfCollaborationSource } from './office-pdf-collaboration-types';
+export type * from './office-pdf-collaboration-types';
+export interface WorkOfficePdfCollaborationChange {
+    content: WorkPdfCollaborationContent;
+    local: boolean;
+    origin: unknown;
+}
+export interface WorkOfficePdfCollaborationBindingOptions {
+    captureTimeoutMs?: number;
+    origin?: WorkOfficeCollaborationOrigin;
+}
+export interface WorkOfficePdfCollaborationBinding {
+    readonly origin: WorkOfficeCollaborationOrigin;
+    content(): WorkPdfCollaborationContent;
+    replace(previous: WorkPdfCollaborationContent, next: WorkPdfCollaborationContent): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    stopCapturing(): void;
+    subscribe(listener: (change: WorkOfficePdfCollaborationChange) => void): () => void;
+    subscribeError(listener: (error: unknown) => void): () => void;
+    subscribeHistory(listener: () => void): () => void;
+    destroy(): void;
+}
+export declare function initializeWorkOfficePdfCollaboration(session: WorkOfficeCollaborationSession, content: WorkPdfCollaborationContent): {
+    initialized: boolean;
+    content: WorkPdfCollaborationContent;
+};
+export declare function readWorkOfficePdfCollaboration(session: WorkOfficeCollaborationSession): WorkPdfCollaborationContent;
+export declare function assertWorkOfficePdfCollaborationSource(session: WorkOfficeCollaborationSession, source: WorkPdfCollaborationSource): void;
+export declare function readWorkOfficePdfCollaborationSource(session: WorkOfficeCollaborationSession): WorkPdfCollaborationSource;
+export declare function replaceWorkOfficePdfCollaboration(session: WorkOfficeCollaborationSession, previous: WorkPdfCollaborationContent, next: WorkPdfCollaborationContent, origin?: WorkOfficeCollaborationOrigin): boolean;
+export declare function createWorkOfficePdfCollaborationBinding(session: WorkOfficeCollaborationSession, options?: WorkOfficePdfCollaborationBindingOptions): WorkOfficePdfCollaborationBinding;

package/dist/internal/collaboration/office-presentation-collaboration-model.d.ts

@@ -0,0 +1,25 @@
+import * as Y from 'yjs';
+import type { WorkPresentationContent } from '../features/work/work-types';
+export { validateWorkOfficePresentationContent } from './office-presentation-collaboration-validation';
+export declare const PRESENTATION_OPTIONS_ROOT = "presentation.options";
+export declare const PRESENTATION_SLIDES_ROOT = "presentation.slides";
+export declare const PRESENTATION_SLIDE_ORDER_ROOT = "presentation.slide-order";
+export declare const PRESENTATION_MASTERS_ROOT = "presentation.masters";
+export declare const PRESENTATION_MASTER_ORDER_ROOT = "presentation.master-order";
+export declare const PRESENTATION_LAYOUTS_ROOT = "presentation.layouts";
+export declare const PRESENTATION_LAYOUT_ORDER_ROOT = "presentation.layout-order";
+export interface WorkOfficePresentationRoots {
+    options: Y.Map<unknown>;
+    slides: Y.Map<unknown>;
+    slideOrder: Y.Array<string>;
+    masters: Y.Map<unknown>;
+    masterOrder: Y.Array<string>;
+    layouts: Y.Map<unknown>;
+    layoutOrder: Y.Array<string>;
+}
+export declare function workOfficePresentationRoots(document: Y.Doc, rootName: (suffix: string) => string): WorkOfficePresentationRoots;
+export declare function initializeWorkOfficePresentationRoots(roots: WorkOfficePresentationRoots, content: WorkPresentationContent): void;
+export declare function readWorkOfficePresentationRoots(roots: WorkOfficePresentationRoots): WorkPresentationContent;
+export declare function patchWorkOfficePresentationRoots(roots: WorkOfficePresentationRoots, previous: WorkPresentationContent, next: WorkPresentationContent): void;
+export declare function assertWorkOfficePresentationRootsEmpty(roots: WorkOfficePresentationRoots): void;
+export declare function workOfficePresentationUndoScope(roots: WorkOfficePresentationRoots): Array<Y.Map<unknown> | Y.Array<string>>;

package/dist/internal/collaboration/office-presentation-collaboration-records.d.ts

@@ -0,0 +1,22 @@
+import * as Y from 'yjs';
+import type { WorkSlideElement } from '../features/work/work-types';
+export declare const PRESENTATION_RECORD_ELEMENTS = "elements";
+export declare const PRESENTATION_RECORD_ELEMENT_ORDER = "elementOrder";
+export declare const PRESENTATION_RECORD_COMMENTS = "comments";
+export declare const PRESENTATION_RECORD_COMMENT_ORDER = "commentOrder";
+export declare const PRESENTATION_RECORD_COMMENTS_PRESENT = "commentsPresent";
+export type WorkOfficePresentationRecord = {
+    id: string;
+    elements: WorkSlideElement[];
+};
+export declare function nestedPresentationMap(parent: Y.Map<unknown>, key: string, label: string): Y.Map<unknown>;
+export declare function nestedPresentationArray(parent: Y.Map<unknown>, key: string, label: string): Y.Array<string>;
+export declare function requiredPresentationMap(parent: Y.Map<unknown>, key: string, label: string): Y.Map<unknown>;
+export declare function requiredPresentationArray(parent: Y.Map<unknown>, key: string, label: string): Y.Array<string>;
+export declare function validatedPresentationOrder(order: Y.Array<string>, records: Y.Map<unknown>, label: string): string[];
+export declare function readPresentationCollection(records: Y.Map<unknown>, order: Y.Array<string>, label: string): WorkOfficePresentationRecord[];
+export declare function patchPresentationElements(records: Y.Map<unknown>, order: Y.Array<string>, previous: WorkSlideElement[], next: WorkSlideElement[], parentLabel: string): void;
+export declare function patchPresentationIdRecords<T extends {
+    id: string;
+}>(records: Y.Map<unknown>, order: Y.Array<string>, previous: T[], next: T[], label: string): void;
+export declare function patchPresentationOrder(order: Y.Array<string>, previous: string[], next: string[]): void;

package/dist/internal/collaboration/office-presentation-collaboration-validation.d.ts

@@ -0,0 +1,4 @@
+import type { WorkPresentationContent } from '../features/work/work-types';
+export declare function validateWorkOfficePresentationContent(content: WorkPresentationContent): WorkPresentationContent;
+export declare function validateSharedWorkOfficePresentationContent(content: WorkPresentationContent): WorkPresentationContent;
+export declare function invalidWorkOfficePresentationShared(label: string): never;

package/dist/internal/collaboration/office-presentation-collaboration.d.ts

@@ -0,0 +1,32 @@
+import type { WorkPresentationContent } from '../features/work/work-types';
+import { type WorkOfficeCollaborationOrigin, type WorkOfficeCollaborationSession } from './office-collaboration';
+export interface WorkOfficePresentationCollaborationChange {
+    content: WorkPresentationContent;
+    local: boolean;
+    origin: unknown;
+}
+export interface WorkOfficePresentationCollaborationBindingOptions {
+    captureTimeoutMs?: number;
+    origin?: WorkOfficeCollaborationOrigin;
+}
+export interface WorkOfficePresentationCollaborationBinding {
+    readonly origin: WorkOfficeCollaborationOrigin;
+    content(): WorkPresentationContent;
+    replace(previous: WorkPresentationContent, next: WorkPresentationContent): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    stopCapturing(): void;
+    subscribe(listener: (change: WorkOfficePresentationCollaborationChange) => void): () => void;
+    subscribeError(listener: (error: unknown) => void): () => void;
+    subscribeHistory(listener: () => void): () => void;
+    destroy(): void;
+}
+export declare function initializeWorkOfficePresentationCollaboration(session: WorkOfficeCollaborationSession, content: WorkPresentationContent): {
+    initialized: boolean;
+    content: WorkPresentationContent;
+};
+export declare function readWorkOfficePresentationCollaboration(session: WorkOfficeCollaborationSession): WorkPresentationContent;
+export declare function replaceWorkOfficePresentationCollaboration(session: WorkOfficeCollaborationSession, previous: WorkPresentationContent, next: WorkPresentationContent, origin?: WorkOfficeCollaborationOrigin): boolean;
+export declare function createWorkOfficePresentationCollaborationBinding(session: WorkOfficeCollaborationSession, options?: WorkOfficePresentationCollaborationBindingOptions): WorkOfficePresentationCollaborationBinding;

package/dist/internal/collaboration/office-spreadsheet-collaboration-cells.d.ts

@@ -0,0 +1,13 @@
+import * as Y from 'yjs';
+import type { WorkSpreadsheetSheet } from '../features/work/work-types';
+export declare const SPREADSHEET_RECORD_CELLS = "cells";
+export declare const SPREADSHEET_RECORD_CELL_PRESENCE = "cellPresence";
+export declare const SPREADSHEET_RECORD_CELL_MODE = "cellMode";
+export declare const SPREADSHEET_RECORD_DATA_ROW_LENGTHS = "dataRowLengths";
+/**
+ * Cells use one field map rather than assigning a nested map per coordinate.
+ * Two clients can therefore populate different fields of the same blank cell
+ * without Y.Map's concurrent child-type assignment discarding one child map.
+ */
+export declare function patchSpreadsheetCells(record: Y.Map<unknown>, previous: WorkSpreadsheetSheet | undefined, next: WorkSpreadsheetSheet): void;
+export declare function readSpreadsheetCells(record: Y.Map<unknown>, sheet: WorkSpreadsheetSheet): void;

package/dist/internal/collaboration/office-spreadsheet-collaboration-claims.d.ts

@@ -0,0 +1,4 @@
+import type * as Y from 'yjs';
+import type { WorkSpreadsheetContent } from '../features/work/work-types';
+export declare function appendWorkOfficeSpreadsheetRecordClaims(claims: Y.Array<string>, previous: WorkSpreadsheetContent | undefined, next: WorkSpreadsheetContent): void;
+export declare function assertWorkOfficeSpreadsheetRecordClaims(claims: Y.Array<string>, content: WorkSpreadsheetContent): void;

package/dist/internal/collaboration/office-spreadsheet-collaboration-conflicts.d.ts

@@ -0,0 +1,2 @@
+import type { WorkSpreadsheetContent } from '../features/work/work-types';
+export declare function assertWorkOfficeSpreadsheetPatchSafe(previous: WorkSpreadsheetContent, next: WorkSpreadsheetContent, shared: WorkSpreadsheetContent): void;

package/dist/internal/collaboration/office-spreadsheet-collaboration-flat-json.d.ts

@@ -0,0 +1,10 @@
+import { type WorkOfficeCollaborationFlatJsonMap } from './office-collaboration-flat-json';
+/**
+ * Recursively flattens object fields into one stable Y.Map. Arrays remain atomic
+ * because their positional meaning varies across OOXML features. This avoids a
+ * concurrent first-write race for nested Y.Map instances while still letting
+ * independent object leaves converge.
+ */
+export declare function patchSpreadsheetFlatJsonMap(target: SpreadsheetFlatJsonMap, previous: Record<string, unknown> | undefined, next: Record<string, unknown> | undefined, label: string): void;
+export declare function readSpreadsheetFlatJsonMap(target: SpreadsheetFlatJsonMap, label: string): Record<string, unknown>;
+export type SpreadsheetFlatJsonMap = WorkOfficeCollaborationFlatJsonMap;

package/dist/internal/collaboration/office-spreadsheet-collaboration-model.d.ts

@@ -0,0 +1,31 @@
+import * as Y from 'yjs';
+import type { WorkSpreadsheetContent } from '../features/work/work-types';
+export { validateWorkOfficeSpreadsheetContent } from './office-spreadsheet-collaboration-validation';
+export declare const SPREADSHEET_OPTIONS_ROOT = "spreadsheet.options";
+export declare const SPREADSHEET_SHEETS_ROOT = "spreadsheet.sheets";
+export declare const SPREADSHEET_SHEET_ORDER_ROOT = "spreadsheet.sheet-order";
+export declare const SPREADSHEET_NAMED_RANGES_ROOT = "spreadsheet.named-ranges";
+export declare const SPREADSHEET_NAMED_RANGE_ORDER_ROOT = "spreadsheet.named-range-order";
+export declare const SPREADSHEET_RECORD_CLAIMS_ROOT = "spreadsheet.record-claims";
+export declare const SPREADSHEET_PRINT_AREAS_ROOT = "spreadsheet.print-areas";
+export declare const SPREADSHEET_PRINT_TITLES_ROOT = "spreadsheet.print-titles";
+export declare const SPREADSHEET_PAGE_BREAKS_ROOT = "spreadsheet.page-breaks";
+export declare const SPREADSHEET_PAGE_SETUPS_ROOT = "spreadsheet.page-setups";
+export interface WorkOfficeSpreadsheetRoots {
+    options: Y.Map<unknown>;
+    sheets: Y.Map<unknown>;
+    sheetOrder: Y.Array<string>;
+    namedRanges: Y.Map<unknown>;
+    namedRangeOrder: Y.Array<string>;
+    recordClaims: Y.Array<string>;
+    printAreas: Y.Map<unknown>;
+    printTitles: Y.Map<unknown>;
+    pageBreaks: Y.Map<unknown>;
+    pageSetups: Y.Map<unknown>;
+}
+export declare function workOfficeSpreadsheetRoots(document: Y.Doc, rootName: (suffix: string) => string): WorkOfficeSpreadsheetRoots;
+export declare function initializeWorkOfficeSpreadsheetRoots(roots: WorkOfficeSpreadsheetRoots, content: WorkSpreadsheetContent): void;
+export declare function readWorkOfficeSpreadsheetRoots(roots: WorkOfficeSpreadsheetRoots): WorkSpreadsheetContent;
+export declare function patchWorkOfficeSpreadsheetRoots(roots: WorkOfficeSpreadsheetRoots, previous: WorkSpreadsheetContent, next: WorkSpreadsheetContent): void;
+export declare function assertWorkOfficeSpreadsheetRootsEmpty(roots: WorkOfficeSpreadsheetRoots): void;
+export declare function workOfficeSpreadsheetUndoScope(roots: WorkOfficeSpreadsheetRoots): Array<Y.Map<unknown> | Y.Array<string>>;

package/dist/internal/collaboration/office-spreadsheet-collaboration-records.d.ts

@@ -0,0 +1,17 @@
+import * as Y from 'yjs';
+import type { WorkSpreadsheetSheet } from '../features/work/work-types';
+export declare const SPREADSHEET_RECORD_CONFIG = "config";
+export declare const SPREADSHEET_RECORD_FORMULA_METADATA = "formulaMetadata";
+export declare const SPREADSHEET_RECORD_IMAGES = "images";
+export declare const SPREADSHEET_RECORD_IMAGE_ORDER = "imageOrder";
+export declare const SPREADSHEET_RECORD_CHARTS = "charts";
+export declare const SPREADSHEET_RECORD_CHART_ORDER = "chartOrder";
+export declare const SPREADSHEET_RECORD_PIVOTS = "pivotTables";
+export declare const SPREADSHEET_RECORD_PIVOT_ORDER = "pivotOrder";
+export declare function initializeSpreadsheetSheetRecord(record: Y.Map<unknown>, sheet: WorkSpreadsheetSheet): void;
+export declare function patchSpreadsheetSheetRecord(record: Y.Map<unknown>, previous: WorkSpreadsheetSheet | undefined, next: WorkSpreadsheetSheet): void;
+export declare function readSpreadsheetSheetRecord(record: Y.Map<unknown>, id: string): WorkSpreadsheetSheet;
+export declare function patchSpreadsheetOrder(order: Y.Array<string>, previous: string[], next: string[]): void;
+export declare function validatedSpreadsheetOrder(order: Y.Array<string>, records: Y.Map<unknown>, label: string): string[];
+export declare function nestedSpreadsheetMap(parent: Y.Map<unknown>, key: string, label: string): Y.Map<unknown>;
+export declare function requiredSpreadsheetMap(parent: Y.Map<unknown>, key: string, label: string): Y.Map<unknown>;

package/dist/internal/collaboration/office-spreadsheet-collaboration-validation.d.ts

@@ -0,0 +1,4 @@
+import type { WorkSpreadsheetContent } from '../features/work/work-types';
+export declare function validateWorkOfficeSpreadsheetContent(content: WorkSpreadsheetContent): WorkSpreadsheetContent;
+export declare function validateSharedWorkOfficeSpreadsheetContent(content: WorkSpreadsheetContent): WorkSpreadsheetContent;
+export declare function invalidWorkOfficeSpreadsheetShared(label: string): never;

package/dist/internal/collaboration/office-spreadsheet-collaboration.d.ts

@@ -0,0 +1,32 @@
+import type { WorkSpreadsheetContent } from '../features/work/work-types';
+import { type WorkOfficeCollaborationOrigin, type WorkOfficeCollaborationSession } from './office-collaboration';
+export interface WorkOfficeSpreadsheetCollaborationChange {
+    content: WorkSpreadsheetContent;
+    local: boolean;
+    origin: unknown;
+}
+export interface WorkOfficeSpreadsheetCollaborationBindingOptions {
+    captureTimeoutMs?: number;
+    origin?: WorkOfficeCollaborationOrigin;
+}
+export interface WorkOfficeSpreadsheetCollaborationBinding {
+    readonly origin: WorkOfficeCollaborationOrigin;
+    content(): WorkSpreadsheetContent;
+    replace(previous: WorkSpreadsheetContent, next: WorkSpreadsheetContent): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    stopCapturing(): void;
+    subscribe(listener: (change: WorkOfficeSpreadsheetCollaborationChange) => void): () => void;
+    subscribeError(listener: (error: unknown) => void): () => void;
+    subscribeHistory(listener: () => void): () => void;
+    destroy(): void;
+}
+export declare function initializeWorkOfficeSpreadsheetCollaboration(session: WorkOfficeCollaborationSession, content: WorkSpreadsheetContent): {
+    initialized: boolean;
+    content: WorkSpreadsheetContent;
+};
+export declare function readWorkOfficeSpreadsheetCollaboration(session: WorkOfficeCollaborationSession): WorkSpreadsheetContent;
+export declare function replaceWorkOfficeSpreadsheetCollaboration(session: WorkOfficeCollaborationSession, previous: WorkSpreadsheetContent, next: WorkSpreadsheetContent, origin?: WorkOfficeCollaborationOrigin): boolean;
+export declare function createWorkOfficeSpreadsheetCollaborationBinding(session: WorkOfficeCollaborationSession, options?: WorkOfficeSpreadsheetCollaborationBindingOptions): WorkOfficeSpreadsheetCollaborationBinding;

package/dist/internal/design-system/primitives/navigation/tabs.d.ts

@@ -5,15 +5,17 @@ export type TabItem<T extends string> = {
     compactLabel?: string;
     icon?: ReactNode;
     badge?: ReactNode;
+    contextual?: boolean;
     disabled?: boolean;
     tabId?: string;
     panelId?: string;
 };
-export declare function Tabs<T extends string>({ ariaLabel, value, items, onChange, variant, size, className, containerRef, }: {
+export declare function Tabs<T extends string>({ ariaLabel, value, items, onChange, onTabDoubleClick, variant, size, className, containerRef, }: {
     ariaLabel: string;
     value: T;
     items: readonly TabItem<T>[];
     onChange: (value: T) => void;
+    onTabDoubleClick?: (value: T) => void;
     variant?: 'segment' | 'line';
     size?: 'standard' | 'compact';
     className?: string;

package/dist/internal/features/work/components/work-document-page-border.d.ts

@@ -0,0 +1,6 @@
+import type { WorkDocumentSectionLayout } from '../work-types';
+export declare function WorkDocumentPageBorder({ layout, physicalPage, sectionPage, }: {
+    layout: WorkDocumentSectionLayout;
+    physicalPage?: number;
+    sectionPage: number;
+}): import("react").JSX.Element | null;