@univerjs-pro/pdfs-ui 1.0.0-alpha.8

package/lib/types/render/pdf-page-thumbnail-renderer.d.ts

@@ -0,0 +1,49 @@
+import type { IPdfDocument, IPdfPageCacheEpoch } from '@univerjs-pro/pdfs';
+import type { IPdfCanvasRenderOptions } from './canvas-renderer';
+export interface IPdfPageThumbnailViewportInput {
+    pageWidthPt: number;
+    pageHeightPt: number;
+    rotation: 0 | 90 | 180 | 270;
+    maxWidthCssPx: number;
+    maxHeightCssPx: number;
+    devicePixelRatio?: number;
+}
+export interface IPdfPageThumbnailViewport {
+    widthCssPx: number;
+    heightCssPx: number;
+    widthDevicePx: number;
+    heightDevicePx: number;
+    devicePixelRatio: number;
+    zoom: number;
+}
+export interface IPdfPageThumbnailRenderInput {
+    document: IPdfDocument;
+    pageId: string;
+    canvas: HTMLCanvasElement;
+    epoch: IPdfPageCacheEpoch;
+    maxWidthCssPx: number;
+    maxHeightCssPx: number;
+    devicePixelRatio?: number;
+    renderOptions?: Omit<IPdfCanvasRenderOptions, 'zoom' | 'devicePixelRatio' | 'scheduler'>;
+}
+export interface IPdfPageThumbnailRenderer {
+    render(input: IPdfPageThumbnailRenderInput): IPdfPageThumbnailViewport;
+    schedule(input: IPdfPageThumbnailRenderInput): () => void;
+    invalidate(documentId: string, pageId?: string): void;
+    reset(): void;
+    getCacheSize(): number;
+}
+export interface IPdfPageThumbnailWorkerRenderer {
+    render(input: IPdfPageThumbnailRenderInput, viewport: IPdfPageThumbnailViewport, signal?: AbortSignal): Promise<ImageBitmap | undefined>;
+    reset(): void;
+}
+export interface IPdfPageThumbnailRendererOptions {
+    maxEntries?: number;
+    createCanvas?: () => HTMLCanvasElement;
+    renderPage?: (document: IPdfDocument, pageId: string, canvas: HTMLCanvasElement, options: Omit<IPdfCanvasRenderOptions, 'scheduler'>) => unknown;
+    schedule?: (callback: () => void) => unknown;
+    cancelScheduled?: (handle: unknown) => void;
+    workerRenderer?: IPdfPageThumbnailWorkerRenderer | null;
+}
+export declare function calculatePdfPageThumbnailViewport(input: IPdfPageThumbnailViewportInput): IPdfPageThumbnailViewport;
+export declare function createPdfPageThumbnailRenderer(options?: IPdfPageThumbnailRendererOptions): IPdfPageThumbnailRenderer;

package/lib/types/render/pdf-page-thumbnail-worker-client.d.ts

@@ -0,0 +1,44 @@
+import type { IPdfDocument, IPdfSourceSuppression, PdfAssetId, PdfObjectId } from '@univerjs-pro/pdfs';
+import type { IPdfPageThumbnailViewport, IPdfPageThumbnailWorkerRenderer } from './pdf-page-thumbnail-renderer';
+export interface IPdfThumbnailWorkerImage {
+    assetId: PdfAssetId;
+    bitmap: ImageBitmap;
+}
+export interface IPdfThumbnailWorkerRenderOptions {
+    background?: string;
+    showPageBoundary?: boolean;
+    showRawObjects?: boolean;
+    showAnnotations?: boolean;
+    showAnnotationBounds?: boolean;
+    enableTransparencyGroups?: boolean;
+    preferPageRaster?: boolean;
+    disableGroupCompositor?: boolean;
+    suppressedDisplayOperationIds?: string[];
+    suppressedObjectIds?: PdfObjectId[];
+    sourceSuppressions?: IPdfSourceSuppression[];
+}
+export interface IPdfThumbnailWorkerRenderRequest {
+    type: 'render';
+    id: number;
+    document: IPdfDocument;
+    pageId: string;
+    viewport: IPdfPageThumbnailViewport;
+    options: IPdfThumbnailWorkerRenderOptions;
+    images: IPdfThumbnailWorkerImage[];
+    pageRaster?: ImageBitmap;
+}
+export type PdfThumbnailWorkerResponse = {
+    type: 'rendered';
+    id: number;
+    bitmap: ImageBitmap;
+} | {
+    type: 'failed';
+    id: number;
+    error: string;
+};
+export interface IPdfPageThumbnailWorkerRendererOptions {
+    createWorker?: () => Worker;
+    createImageBitmap?: (source: ImageBitmapSource) => Promise<ImageBitmap>;
+    workerURL?: string | URL | Worker;
+}
+export declare function createPdfPageThumbnailWorkerRenderer(options?: IPdfPageThumbnailWorkerRendererOptions): IPdfPageThumbnailWorkerRenderer | undefined;

package/lib/types/render/pdf-page-thumbnail.worker.d.ts

@@ -0,0 +1,9 @@
+import type { IPdfThumbnailWorkerRenderRequest, PdfThumbnailWorkerResponse } from './pdf-page-thumbnail-worker-client';
+interface IPdfThumbnailWorkerScope {
+    readonly document?: unknown;
+    onmessage: ((event: MessageEvent<IPdfThumbnailWorkerRenderRequest>) => void) | null;
+    postMessage(message: PdfThumbnailWorkerResponse, transfer?: Transferable[]): void;
+}
+/** Starts the dedicated PDF thumbnail worker entry. */
+export declare function startPdfPageThumbnailWorker(scope?: IPdfThumbnailWorkerScope): void;
+export {};

package/lib/types/render/source-eraser.d.ts

@@ -0,0 +1,18 @@
+import type { IPdfDocument, IPdfPage } from '@univerjs-pro/pdfs';
+import type { IPdfCanvasSourceSuppressionMatcher } from './source-suppression';
+import type { IPdfCanvasViewport } from './viewport';
+export interface IPdfRasterSourceEraserOptions {
+    document: IPdfDocument;
+    page: IPdfPage;
+    context: CanvasRenderingContext2D;
+    viewport: IPdfCanvasViewport;
+    sourceSuppressionMatcher: IPdfCanvasSourceSuppressionMatcher;
+    background: string;
+}
+/**
+ * Page rasters are the most faithful preview for imported PDFs, but they still
+ * contain native operators that were promoted into editable overlay objects.
+ * Erase only those promoted source regions so the rest of the page can stay on
+ * the high-fidelity raster path.
+ */
+export declare function drawPdfRasterSourceErasers(options: IPdfRasterSourceEraserOptions): void;

package/lib/types/render/source-suppression.d.ts

@@ -0,0 +1,10 @@
+import type { IPdfSourceOperationPathSegment, IPdfSourceSuppression, PdfDisplayOperation, PdfDisplayOperationId } from '@univerjs-pro/pdfs';
+export interface IPdfCanvasSourceSuppressionOptions {
+    suppressedDisplayOperationIds?: Iterable<PdfDisplayOperationId>;
+    sourceSuppressions?: Iterable<IPdfSourceSuppression>;
+}
+export interface IPdfCanvasSourceSuppressionMatcher {
+    readonly hasSuppressions: boolean;
+    isSuppressed(op: PdfDisplayOperation, operationPath: IPdfSourceOperationPathSegment[]): boolean;
+}
+export declare function createPdfCanvasSourceSuppressionMatcher(options: IPdfCanvasSourceSuppressionOptions): IPdfCanvasSourceSuppressionMatcher;

package/lib/types/render/viewport.d.ts

@@ -0,0 +1,21 @@
+import type { IPdfPage, PdfRectPt } from '@univerjs-pro/pdfs';
+export interface IPdfCanvasViewportOptions {
+    zoom?: number;
+    devicePixelRatio?: number;
+}
+export interface IPdfCanvasViewport {
+    zoom: number;
+    devicePixelRatio: number;
+    widthCssPx: number;
+    heightCssPx: number;
+    widthDevicePx: number;
+    heightDevicePx: number;
+    canvasScaleX: number;
+    canvasScaleY: number;
+    rotation: 0 | 90 | 180 | 270;
+    visibleBox: PdfRectPt;
+    mediaBox: PdfRectPt;
+    contentOffsetXCssPx: number;
+    contentOffsetYCssPx: number;
+}
+export declare function createPdfCanvasViewport(page: IPdfPage, options?: IPdfCanvasViewportOptions): IPdfCanvasViewport;

package/lib/types/services/pdf-editor-command.service.d.ts

@@ -0,0 +1,59 @@
+import type { IPdfEditorCommand, IPdfEditorCommandResult, PdfEditorActorId, PdfEditorClientId, PdfEditorGeneratedIdPrefix } from '@univerjs-pro/pdfs';
+import { Disposable, ICommandService, IUndoRedoService, IUniverInstanceService } from '@univerjs/core';
+import { IPdfEditorRuntimeService } from './pdf-editor-runtime.service';
+/** Outcome category for a UI command entering the formal PDF Unit path. */
+export declare enum PdfEditorCommandExecutionStatus {
+    ACCEPTED = "accepted",
+    REJECTED = "rejected",
+    UNIT_NOT_FOUND = "unit-not-found",
+    RUNTIME_NOT_FOUND = "runtime-not-found",
+    INVALID_RESULT = "invalid-result"
+}
+/** Local identity and deterministic clock supplied by a UI controller. */
+export interface IPdfEditorCommandExecutionOptions {
+    actorId: PdfEditorActorId;
+    clientId?: PdfEditorClientId;
+    now?: number;
+    createId?: (prefix: PdfEditorGeneratedIdPrefix) => string;
+}
+/** Structured result returned to ribbon, pointer, keyboard, or panel callers. */
+export interface IPdfEditorCommandExecutionResult {
+    accepted: boolean;
+    status: PdfEditorCommandExecutionStatus;
+    unitId: string;
+    revision?: number;
+    result?: IPdfEditorCommandResult;
+}
+/** Executes headless PDF editor commands against a formal PDF Unit. */
+export interface IPdfEditorCommandService {
+    execute<TInput>(unitId: string, command: IPdfEditorCommand<TInput>, input: TInput, options: IPdfEditorCommandExecutionOptions): Promise<IPdfEditorCommandExecutionResult>;
+    commit(unitId: string, result: IPdfEditorCommandResult, options: IPdfEditorCommandExecutionOptions): Promise<IPdfEditorCommandExecutionResult>;
+    undo(unitId: string, options: IPdfEditorCommandExecutionOptions): Promise<IPdfEditorCommandExecutionResult>;
+    redo(unitId: string, options: IPdfEditorCommandExecutionOptions): Promise<IPdfEditorCommandExecutionResult>;
+    applyHistory(unitId: string, batchId: string, direction: 'undo' | 'redo', options: IPdfEditorCommandExecutionOptions): IPdfEditorCommandExecutionResult;
+}
+export declare const IPdfEditorCommandService: import("@wendellhu/redi").IdentifierDecorator<IPdfEditorCommandService>;
+/**
+ * Bridges UI intent to the authoritative PDF Unit mutation. Local state is
+ * updated only after the durable mutation has been accepted by Core.
+ */
+export declare class PdfEditorCommandService extends Disposable implements IPdfEditorCommandService {
+    private readonly _commandService;
+    private readonly _undoRedoService;
+    private readonly _instanceService;
+    private readonly _runtimeService;
+    private readonly _idCounters;
+    constructor(_commandService: ICommandService, _undoRedoService: IUndoRedoService, _instanceService: IUniverInstanceService, _runtimeService: IPdfEditorRuntimeService);
+    execute<TInput>(unitId: string, command: IPdfEditorCommand<TInput>, input: TInput, options: IPdfEditorCommandExecutionOptions): Promise<IPdfEditorCommandExecutionResult>;
+    commit(unitId: string, result: IPdfEditorCommandResult, options: IPdfEditorCommandExecutionOptions): Promise<IPdfEditorCommandExecutionResult>;
+    undo(unitId: string, _options: IPdfEditorCommandExecutionOptions): Promise<IPdfEditorCommandExecutionResult>;
+    redo(unitId: string, _options: IPdfEditorCommandExecutionOptions): Promise<IPdfEditorCommandExecutionResult>;
+    applyHistory(unitId: string, batchId: string, direction: 'undo' | 'redo', options: IPdfEditorCommandExecutionOptions): IPdfEditorCommandExecutionResult;
+    private _commitResult;
+    private _executeStandardHistory;
+    private _executeHistorySync;
+    private _reconcileActivePage;
+    private _updateLocalResult;
+    private _createId;
+    private _failure;
+}

package/lib/types/services/pdf-editor-runtime.service.d.ts

@@ -0,0 +1,62 @@
+import type { IPdfEditorMutationBatch, IPdfEditorStateParts, IPdfEditorViewportState, IPdfEphemeralEditorState, IPdfLocalEditorState, IPdfPageCacheEpoch, PdfDocumentModel, PdfPageId } from '@univerjs-pro/pdfs';
+import type { Observable } from 'rxjs';
+import { Disposable } from '@univerjs/core';
+/** Kind of change emitted by the local PDF editor runtime store. */
+export declare enum PdfEditorRuntimeEventType {
+    ATTACHED = "attached",
+    UNIT_UPDATED = "unit-updated",
+    LOCAL_UPDATED = "local-updated",
+    EPHEMERAL_UPDATED = "ephemeral-updated",
+    VIEWPORT_UPDATED = "viewport-updated",
+    DETACHED = "detached"
+}
+/** Client-only state associated with one live PDF Unit. */
+export interface IPdfEditorRuntimeState {
+    readonly unitId: string;
+    readonly local: IPdfLocalEditorState;
+    readonly ephemeral: IPdfEphemeralEditorState;
+}
+/** Notification emitted after a runtime state transition. */
+export interface IPdfEditorRuntimeEvent {
+    readonly type: PdfEditorRuntimeEventType;
+    readonly unitId: string;
+    readonly state?: IPdfEditorRuntimeState;
+}
+/** Local runtime store consumed by PDF UI controllers and services. */
+export interface IPdfEditorRuntimeService {
+    readonly changed$: Observable<IPdfEditorRuntimeEvent>;
+    attachUnit(model: PdfDocumentModel): IPdfEditorRuntimeState;
+    detachUnit(unitId: string): boolean;
+    getState(unitId: string): IPdfEditorRuntimeState | undefined;
+    getStateParts(unitId: string): IPdfEditorStateParts | undefined;
+    refreshUnit(unitId: string): boolean;
+    updateLocal(unitId: string, updater: (state: IPdfLocalEditorState) => IPdfLocalEditorState): IPdfEditorRuntimeState | undefined;
+    updateEphemeral(unitId: string, updater: (state: IPdfEphemeralEditorState) => IPdfEphemeralEditorState): IPdfEditorRuntimeState | undefined;
+    updateViewport(unitId: string, patch: Partial<IPdfEditorViewportState>): IPdfEditorRuntimeState | undefined;
+    recordMutationBatch(unitId: string, batch: IPdfEditorMutationBatch, notify?: boolean): boolean;
+    getPageRevision(unitId: string, pageId: PdfPageId): number;
+    getPageCacheEpoch(unitId: string, pageId: PdfPageId, resourceRevision?: number): IPdfPageCacheEpoch | undefined;
+}
+export declare const IPdfEditorRuntimeService: import("@wendellhu/redi").IdentifierDecorator<IPdfEditorRuntimeService>;
+/**
+ * Owns state that belongs to the browser editor lifecycle rather than the PDF
+ * Unit snapshot. Durable state is deliberately read from the Unit on demand.
+ */
+export declare class PdfEditorRuntimeService extends Disposable implements IPdfEditorRuntimeService {
+    private readonly _records;
+    private readonly _changed$;
+    readonly changed$: Observable<IPdfEditorRuntimeEvent>;
+    attachUnit(model: PdfDocumentModel): IPdfEditorRuntimeState;
+    detachUnit(unitId: string): boolean;
+    getState(unitId: string): IPdfEditorRuntimeState | undefined;
+    getStateParts(unitId: string): IPdfEditorStateParts | undefined;
+    refreshUnit(unitId: string): boolean;
+    updateLocal(unitId: string, updater: (state: IPdfLocalEditorState) => IPdfLocalEditorState): IPdfEditorRuntimeState | undefined;
+    updateEphemeral(unitId: string, updater: (state: IPdfEphemeralEditorState) => IPdfEphemeralEditorState): IPdfEditorRuntimeState | undefined;
+    updateViewport(unitId: string, patch: Partial<IPdfEditorViewportState>): IPdfEditorRuntimeState | undefined;
+    recordMutationBatch(unitId: string, batch: IPdfEditorMutationBatch, notify?: boolean): boolean;
+    getPageRevision(unitId: string, pageId: PdfPageId): number;
+    getPageCacheEpoch(unitId: string, pageId: PdfPageId, resourceRevision?: number): IPdfPageCacheEpoch | undefined;
+    dispose(): void;
+    private _emit;
+}

package/lib/types/services/pdf-insert.service.d.ts

@@ -0,0 +1,58 @@
+import type { IPdfDurableEditState, PdfDurableResourceBinding, PdfListPresetId } from '@univerjs-pro/pdfs';
+import type { Observable } from 'rxjs';
+import type { IPdfFontOutline } from '../render/font-outline';
+import { Disposable, Injector, IUniverInstanceService } from '@univerjs/core';
+import { IPdfEditorCommandService } from './pdf-editor-command.service';
+import { IPdfEditorRuntimeService } from './pdf-editor-runtime.service';
+export interface IPdfInsertTableOptions {
+    rows: number;
+    columns: number;
+}
+/** Executes the PDF insertion actions exposed by the standard Univer ribbon. */
+export declare class PdfInsertService extends Disposable {
+    private readonly _instanceService;
+    private readonly _commandService;
+    private readonly _runtimeService;
+    private readonly _imageAdapter;
+    private readonly _imageIoService;
+    private readonly _fontFaces;
+    private readonly _fontOutlines;
+    private readonly _loadingFontAssets;
+    private readonly _failedFontAssets;
+    private readonly _loadingFontOutlines;
+    private readonly _failedFontOutlines;
+    private readonly _fontResourceUrls;
+    private readonly _fontChangedSubject;
+    private readonly _resourceChangedSubject;
+    private readonly _textEditRequestedSubject;
+    private readonly _textEditExitRequestedSubject;
+    private readonly _imageChangedSubscription;
+    private _fontGeneration;
+    private _resourceRevision;
+    private _fontResourcesDisposed;
+    readonly imageChanged$: Observable<number>;
+    readonly fontChanged$: Observable<number>;
+    readonly resourceChanged$: Observable<number>;
+    readonly textEditRequested$: Observable<string>;
+    readonly textEditExitRequested$: Observable<string>;
+    constructor(_instanceService: IUniverInstanceService, _commandService: IPdfEditorCommandService, _runtimeService: IPdfEditorRuntimeService, injector: Injector);
+    getResourceRevision(): number;
+    requestTextEditExit(unitId: string): void;
+    insertTextBox(): Promise<boolean>;
+    insertParagraph(): Promise<boolean>;
+    insertDivider(): Promise<boolean>;
+    insertTable(options: IPdfInsertTableOptions): Promise<boolean>;
+    insertList(presetId: PdfListPresetId): Promise<boolean>;
+    insertImage(file: File): Promise<boolean>;
+    insertPage(): Promise<boolean>;
+    resolveManagedImage(editState: Pick<IPdfDurableEditState, 'managedResources'>, assetId: string): CanvasImageSource | undefined;
+    resolveResourceImage(binding: PdfDurableResourceBinding | undefined): CanvasImageSource | undefined;
+    resolveResourceFontFamily(binding: PdfDurableResourceBinding | undefined, assetId: string): string | undefined;
+    resolveResourceFontOutline(binding: PdfDurableResourceBinding | undefined, assetId: string): IPdfFontOutline | undefined;
+    dispose(): void;
+    private _loadResourceFont;
+    private _loadResourceFontOutline;
+    private _getFontResourceUrl;
+    private _notifyResourceChanged;
+    private _getContext;
+}

package/lib/types/services/pdf-managed-image-runtime.adapter.d.ts

@@ -0,0 +1,37 @@
+import type { Injector } from '@univerjs/core';
+import type { Observable } from 'rxjs';
+import { ImageSourceType } from '@univerjs/core';
+export interface IPdfResolvedManagedImage {
+    source: string;
+    imageSourceType: ImageSourceType.UUID;
+    width: number;
+    height: number;
+    mimeType?: string;
+    fileName?: string;
+    byteLength?: number;
+}
+/** Runtime boundary for temporary and server-backed managed PDF images. */
+export interface IPdfManagedImageRuntimeAdapter {
+    readonly changed$: Observable<number>;
+    save(file: File): Promise<IPdfResolvedManagedImage>;
+    resolve(source: string): CanvasImageSource | undefined;
+    release(source: string): void;
+    dispose(): void;
+}
+export interface IPdfDecodedManagedImage {
+    image: CanvasImageSource;
+    width: number;
+    height: number;
+}
+export interface IPdfManagedImageRuntimeAdapterOptions {
+    createSource?: () => string;
+    decode?: (file: File) => Promise<IPdfDecodedManagedImage>;
+}
+/**
+ * Keep browser-decoded images in memory while returning metadata that is safe
+ * to persist in PDF editor state. No file bytes or data URLs cross this API.
+ */
+export declare function createPdfInMemoryManagedImageRuntimeAdapter(options?: IPdfManagedImageRuntimeAdapterOptions): IPdfManagedImageRuntimeAdapter;
+/** Uses Univer's configured image service for durable collaboration resources. */
+export declare function createPdfImageIoManagedImageRuntimeAdapter(injector: Injector, options?: IPdfManagedImageRuntimeAdapterOptions): IPdfManagedImageRuntimeAdapter;
+export declare function isSupportedBrowserImageMimeType(mimeType: string): boolean;

package/lib/types/services/pdf-page-region-index.service.d.ts

@@ -0,0 +1,48 @@
+import type { IPdfDocument, IPdfEditorFormFieldHitTarget, IPdfEditorNativeFormXObjectHitTarget, IPdfEditorNativeTextHitTarget, IPdfEditorSession, IPdfPage, IPdfPageCacheEpoch, PdfDisplayListId, PdfDocumentModel, PdfObjectId, PdfPageId } from '@univerjs-pro/pdfs';
+import { Disposable } from '@univerjs/core';
+export interface IPdfPageRegion {
+    readonly pageId: PdfPageId;
+    readonly pageIndex: number;
+    readonly page: IPdfPage;
+    readonly document: IPdfDocument;
+    readonly objectIds: readonly PdfObjectId[];
+    readonly rootDisplayListIds: readonly PdfDisplayListId[];
+    readonly displayListIds: readonly PdfDisplayListId[];
+    readonly nativeTextTargets: readonly IPdfEditorNativeTextHitTarget[];
+    readonly nativeFormXObjectTargets: readonly IPdfEditorNativeFormXObjectHitTarget[];
+    readonly formFieldTargets: readonly IPdfEditorFormFieldHitTarget[];
+}
+export interface IPdfPageRegionIndexService {
+    attachUnit(model: PdfDocumentModel): void;
+    detachUnit(unitId: string): boolean;
+    preparePage(model: PdfDocumentModel, pageId: PdfPageId, sourcePage?: IPdfPage): IPdfPageRegion | undefined;
+    activatePage(model: PdfDocumentModel, pageId: PdfPageId, pageOrder?: readonly IPdfPage[]): () => void;
+    peekPage(unitId: string, pageId: PdfPageId): IPdfPageRegion | undefined;
+    getPageIndex(model: PdfDocumentModel, pageId: PdfPageId): number;
+    getPageProjection(model: PdfDocumentModel, pageId: PdfPageId, session: IPdfEditorSession, variant?: string, epoch?: IPdfPageCacheEpoch): IPdfDocument | undefined;
+}
+export interface IPdfPageRegionScheduler {
+    schedule(callback: () => void): unknown;
+    cancel(handle: unknown): void;
+}
+export declare const IPdfPageRegionIndexService: import("@wendellhu/redi").IdentifierDecorator<IPdfPageRegionIndexService>;
+/** Runtime-only page index and derived page cache owned by live PDF units. */
+export declare class PdfPageRegionIndexService extends Disposable implements IPdfPageRegionIndexService {
+    private readonly _capacity;
+    private readonly _scheduler;
+    private readonly _records;
+    private readonly _pageOrderIndexes;
+    constructor(_capacity?: number, _scheduler?: IPdfPageRegionScheduler);
+    attachUnit(model: PdfDocumentModel): void;
+    detachUnit(unitId: string): boolean;
+    preparePage(model: PdfDocumentModel, pageId: PdfPageId, sourcePage?: IPdfPage): IPdfPageRegion | undefined;
+    activatePage(model: PdfDocumentModel, pageId: PdfPageId, pageOrder?: readonly IPdfPage[]): () => void;
+    peekPage(unitId: string, pageId: PdfPageId): IPdfPageRegion | undefined;
+    getPageIndex(model: PdfDocumentModel, pageId: PdfPageId): number;
+    getPageProjection(model: PdfDocumentModel, pageId: PdfPageId, session: IPdfEditorSession, variant?: string, epoch?: IPdfPageCacheEpoch): IPdfDocument | undefined;
+    dispose(): void;
+    private _ensureRecord;
+    private _destroyRecord;
+    private _touch;
+    private _getPageOrderIndex;
+}

package/lib/types/services/pdf-page-thumbnail-action.service.d.ts

@@ -0,0 +1,15 @@
+import type { IPdfPageThumbnailActionState, IPdfPageThumbnailContext } from './pdf-page-thumbnail-context.service';
+/** Command-backed actions exposed by a PDF page thumbnail. */
+export declare enum PdfPageThumbnailAction {
+    MOVE_UP = "move-up",
+    MOVE_DOWN = "move-down",
+    COPY = "copy",
+    ROTATE_CLOCKWISE = "rotate-clockwise",
+    DELETE = "delete"
+}
+/** Host adapter that maps page-rail intent onto PDF mutations. */
+export interface IPdfPageThumbnailActionService {
+    getState(context: IPdfPageThumbnailContext): IPdfPageThumbnailActionState;
+    execute(action: PdfPageThumbnailAction, context: IPdfPageThumbnailContext): Promise<boolean>;
+}
+export declare const IPdfPageThumbnailActionService: import("@wendellhu/redi").IdentifierDecorator<IPdfPageThumbnailActionService>;

package/lib/types/services/pdf-page-thumbnail-context.service.d.ts

@@ -0,0 +1,36 @@
+import type { Observable } from 'rxjs';
+import { Disposable } from '@univerjs/core';
+/** The one PDF page targeted by a page-rail context menu. */
+export interface IPdfPageThumbnailContext {
+    unitId: string;
+    pageId: string;
+    pageIndex: number;
+    pageCount: number;
+}
+/** Availability derived from the target page's current position. */
+export interface IPdfPageThumbnailActionState {
+    canMoveUp: boolean;
+    canMoveDown: boolean;
+    canCopy: boolean;
+    canRotateClockwise: boolean;
+    canDelete: boolean;
+}
+/** Owns transient single-page context-menu state outside the PDF model. */
+export interface IPdfPageThumbnailContextService {
+    readonly context: IPdfPageThumbnailContext | null;
+    readonly context$: Observable<IPdfPageThumbnailContext | null>;
+    setContext(context: IPdfPageThumbnailContext): void;
+    clearContext(): void;
+}
+export declare const IPdfPageThumbnailContextService: import("@wendellhu/redi").IdentifierDecorator<IPdfPageThumbnailContextService>;
+/** Default transient context store used by formal and standalone PDF hosts. */
+export declare class PdfPageThumbnailContextService extends Disposable implements IPdfPageThumbnailContextService {
+    private readonly _context$;
+    readonly context$: Observable<IPdfPageThumbnailContext | null>;
+    get context(): IPdfPageThumbnailContext | null;
+    setContext(context: IPdfPageThumbnailContext): void;
+    clearContext(): void;
+    dispose(): void;
+}
+/** Resolve page actions without consulting mutable document state. */
+export declare function getPdfPageThumbnailActionState(context: IPdfPageThumbnailContext): IPdfPageThumbnailActionState;

package/lib/types/services/pdf-page-thumbnail-unit-action.service.d.ts

@@ -0,0 +1,18 @@
+import type { IPdfPageThumbnailActionService } from './pdf-page-thumbnail-action.service';
+import type { IPdfPageThumbnailActionState, IPdfPageThumbnailContext } from './pdf-page-thumbnail-context.service';
+import { IUniverInstanceService } from '@univerjs/core';
+import { IPdfEditorCommandService } from './pdf-editor-command.service';
+import { IPdfEditorRuntimeService } from './pdf-editor-runtime.service';
+import { PdfPageThumbnailAction } from './pdf-page-thumbnail-action.service';
+/** Formal Unit adapter for page-rail operations. */
+export declare class PdfPageThumbnailUnitActionService implements IPdfPageThumbnailActionService {
+    private readonly _instanceService;
+    private readonly _commandService;
+    private readonly _runtimeService;
+    private _copyId;
+    constructor(_instanceService: IUniverInstanceService, _commandService: IPdfEditorCommandService, _runtimeService: IPdfEditorRuntimeService);
+    getState(context: IPdfPageThumbnailContext): IPdfPageThumbnailActionState;
+    execute(action: PdfPageThumbnailAction, context: IPdfPageThumbnailContext): Promise<boolean>;
+    private _resolve;
+    private _createCopyPageId;
+}

package/lib/types/services/pdf-render-resource-resolvers.d.ts

@@ -0,0 +1,6 @@
+import type { PdfDocumentModel } from '@univerjs-pro/pdfs';
+import type { IPdfCanvasRenderOptions } from '../render/canvas-renderer';
+import type { PdfInsertService } from './pdf-insert.service';
+type PdfRenderResourceResolvers = Pick<IPdfCanvasRenderOptions, 'fontFamilyResolver' | 'fontOutlineResolver' | 'imageResolver' | 'pageRasterResolver' | 'preferPageRaster'>;
+export declare function createPdfRenderResourceResolvers(model: PdfDocumentModel, insertService: PdfInsertService, generation?: string | number): PdfRenderResourceResolvers;
+export {};

package/lib/types/views/PdfCanvasView.d.ts

@@ -0,0 +1,2 @@
+/** Standard Univer content host backed by the PDF canvas renderer. */
+export declare function PdfCanvasView(): import("react").JSX.Element | null;

package/lib/types/views/PdfFooter.d.ts

@@ -0,0 +1,2 @@
+/** Standard footer host for PDF page and zoom state. */
+export declare function PdfFooter(): import("react").JSX.Element | null;

package/lib/types/views/PdfInsertTableMenu.d.ts

@@ -0,0 +1,2 @@
+/** Table-size picker rendered in the standard Univer Insert ribbon. */
+export declare function PdfInsertTableMenu(): import("react").JSX.Element;

package/lib/types/views/PdfInspectorPanel.d.ts

@@ -0,0 +1,3 @@
+export declare const PDF_INSPECTOR_PANEL = "pdfs-ui.inspector-panel";
+/** Standard Univer sidebar content for the active PDF selection. */
+export declare function PdfInspectorPanel(): import("react").JSX.Element | null;

package/lib/types/views/PdfPageThumbnailBar.d.ts

@@ -0,0 +1,2 @@
+/** Standard left sidebar host for PDF page thumbnails. */
+export declare function PdfPageThumbnailBar(): import("react").JSX.Element | null;

package/lib/types/views/PdfTableThemeGallery.d.ts

@@ -0,0 +1,8 @@
+import type { IPdfTableObject, IPdfTableStyleOptions, IPdfTableThemePalette } from '@univerjs-pro/pdfs';
+export interface IPdfTableThemeGalleryProps {
+    table: IPdfTableObject;
+    palette?: IPdfTableThemePalette;
+    onApplyTheme: (styleId: string) => void;
+    onChangeOptions: (options: IPdfTableStyleOptions) => void;
+}
+export declare function PdfTableThemeGallery(props: IPdfTableThemeGalleryProps): import("react").JSX.Element;

package/lib/types/views/PdfToolbar.d.ts

@@ -0,0 +1,2 @@
+/** PDF toolbar host. Commands are registered through Univer services. */
+export declare function PdfToolbar(): import("react").JSX.Element | null;

package/lib/types/views/pdf-canvas-pixel-alignment.d.ts

@@ -0,0 +1 @@
+export declare function getDevicePixelSnapOffset(cssCoordinate: number, devicePixelRatio: number): number;

package/lib/types/views/pdf-canvas-text-edit-state.d.ts

@@ -0,0 +1,34 @@
+import type { IPdfEditorSession, IPdfPageCacheEpoch, PdfPageId } from '@univerjs-pro/pdfs';
+import type { IPdfCanvasTextEditController, IPdfCanvasTextEditState } from '../editor/canvas-text-editor';
+interface IPdfCanvasTextEditControllerRef {
+    current: Pick<IPdfCanvasTextEditController, 'cancel' | 'getState'> | undefined;
+}
+export interface IPdfCanvasBaseRenderKeyInput {
+    unitId: string;
+    pageId: string;
+    zoom: number;
+    devicePixelRatio: number;
+    epoch: IPdfPageCacheEpoch;
+    activeTextObjectId?: string;
+    selectedObjectIds: readonly string[];
+    /** Draft-only fields are accepted to make their exclusion explicit. */
+    draftText?: unknown;
+    selectionRange?: unknown;
+}
+/** Stable key for work that must not rerun for draft text or caret changes. */
+export declare function createPdfCanvasBaseRenderKey(input: IPdfCanvasBaseRenderKeyInput): string;
+/** Take the current edit value and synchronously leave edit mode before saving it. */
+export declare function takePdfCanvasTextEditState(controllerRef: IPdfCanvasTextEditControllerRef): IPdfCanvasTextEditState | undefined;
+export declare function shouldResetPdfCanvasTextEdit(baselineRevision: number | undefined, currentRevision: number | undefined): boolean;
+/** A style-only revision may keep the active draft when its source text still matches. */
+export declare function canRebasePdfCanvasTextEdit(state: IPdfCanvasTextEditState, session: IPdfEditorSession): boolean;
+export declare function shouldSyncPdfCanvasWorkingSession(activeTextEdit: boolean, pointerActive: boolean): boolean;
+/**
+ * Keep untouched promoted native text on the authoritative page raster.
+ *
+ * Promotion is needed to enter edit mode, but it is not itself a visual edit.
+ * Until a text/style/geometry patch exists, omit the replacement only from the
+ * display session so the persisted source and editor history remain intact.
+ */
+export declare function createPdfCanvasDisplaySession(session: IPdfEditorSession, activeTextObjectId?: string, pageId?: PdfPageId): IPdfEditorSession;
+export {};

package/lib/types/views/pdf-thumbnail-virtualizer.d.ts

@@ -0,0 +1,22 @@
+export interface IPdfThumbnailVirtualRangeInput {
+    itemCount: number;
+    scrollTop: number;
+    viewportHeight: number;
+    rowHeight: number;
+    overscan?: number;
+}
+export interface IPdfThumbnailVirtualRange {
+    startIndex: number;
+    endIndex: number;
+    offsetTop: number;
+    totalHeight: number;
+}
+export interface IPdfThumbnailScrollTopInput {
+    itemCount: number;
+    itemIndex: number;
+    scrollTop: number;
+    viewportHeight: number;
+    rowHeight: number;
+}
+export declare function calculatePdfThumbnailVirtualRange(input: IPdfThumbnailVirtualRangeInput): IPdfThumbnailVirtualRange;
+export declare function calculatePdfThumbnailScrollTop(input: IPdfThumbnailScrollTopInput): number;

package/lib/types/views/pdf-workbench-state.d.ts

@@ -0,0 +1,8 @@
+import type { IPdfDocument, IPdfEditorViewportState, PdfDocumentModel } from '@univerjs-pro/pdfs';
+import type { IPdfEditorRuntimeService } from '../services/pdf-editor-runtime.service';
+export declare function usePdfWorkbench(): {
+    document?: IPdfDocument;
+    model?: PdfDocumentModel;
+    viewport?: IPdfEditorViewportState;
+};
+export declare function updatePdfWorkbenchViewport(runtimeService: IPdfEditorRuntimeService, unitId: string, patch: Partial<IPdfEditorViewportState>): void;