@a3s-lab/office 0.1.0

package/dist/internal/features/work/editors/presentation-chart-canvas.d.ts

@@ -0,0 +1,5 @@
+import type { WorkSlideChart } from '../work-types';
+export declare function SlideChart({ chart, label, }: {
+    chart: WorkSlideChart;
+    label: string;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/presentation-chart-cartesian-canvas.d.ts

@@ -0,0 +1,3 @@
+import type { WorkSlideChart } from '../work-types';
+import { type PresentationChartRect } from './presentation-chart-axis-canvas';
+export declare function drawPresentationCartesianChart(context: CanvasRenderingContext2D, chart: WorkSlideChart, sourceRect: PresentationChartRect): void;

package/dist/internal/features/work/editors/presentation-chart-data-label-editor.d.ts

@@ -0,0 +1,6 @@
+import type { WorkSlideChartDataLabels, WorkSlideChartType } from '../work-types';
+export declare function PresentationChartDataLabelEditor({ chartType, value, onChange, }: {
+    chartType: WorkSlideChartType;
+    value?: WorkSlideChartDataLabels;
+    onChange: (value: WorkSlideChartDataLabels | undefined) => void;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/presentation-chart-data-labels.d.ts

@@ -0,0 +1,26 @@
+import type { WorkSlideChart } from '../work-types';
+export type PresentationChartDataLabelGeometry = {
+    kind: 'point';
+    x: number;
+    y: number;
+} | {
+    kind: 'verticalBar';
+    x: number;
+    valueY: number;
+    baselineY: number;
+    value: number;
+} | {
+    kind: 'horizontalBar';
+    y: number;
+    valueX: number;
+    baselineX: number;
+    value: number;
+} | {
+    kind: 'circular';
+    centerX: number;
+    centerY: number;
+    angle: number;
+    innerRadius: number;
+    outerRadius: number;
+};
+export declare function drawPresentationChartDataLabel(context: CanvasRenderingContext2D, chart: WorkSlideChart, seriesIndex: number, pointIndex: number, geometry: PresentationChartDataLabelGeometry): void;

package/dist/internal/features/work/editors/presentation-chart-layout-editor.d.ts

@@ -0,0 +1,5 @@
+import type { WorkSlideChart } from '../work-types';
+export declare function PresentationChartLayoutEditor({ chart, onChange, }: {
+    chart: WorkSlideChart;
+    onChange: (chart: WorkSlideChart) => void;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/presentation-chart-legend-canvas.d.ts

@@ -0,0 +1,15 @@
+import type { WorkSlideChart, WorkSlideChartLegendPosition } from '../work-types';
+import type { PresentationChartRect } from './presentation-chart-axis-canvas';
+interface PresentationChartLegendItem {
+    color: string;
+    label: string;
+}
+export declare const PRESENTATION_CHART_COLORS: string[];
+export declare function presentationChartCanvasLayout(chart: WorkSlideChart, content: PresentationChartRect, hasLegendItems: boolean): {
+    plot: PresentationChartRect;
+    legend?: PresentationChartRect;
+    legendPosition: WorkSlideChartLegendPosition;
+};
+export declare function presentationChartLegendItems(chart: WorkSlideChart): PresentationChartLegendItem[];
+export declare function drawPresentationChartLegend(context: CanvasRenderingContext2D, items: PresentationChartLegendItem[], rect: PresentationChartRect, position: WorkSlideChartLegendPosition): void;
+export {};

package/dist/internal/features/work/editors/presentation-chart-panel.d.ts

@@ -0,0 +1,7 @@
+import type { WorkSlideChart } from '../work-types';
+export declare function PresentationChartPanel({ chart, onChange, onDelete, onClose, }: {
+    chart: WorkSlideChart;
+    onChange: (chart: WorkSlideChart) => void;
+    onDelete: () => void;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/presentation-chart-series-analysis-editor.d.ts

@@ -0,0 +1,6 @@
+import { type WorkSlideChart } from '../work-types';
+export declare function PresentationChartSeriesAnalysisEditor({ chart, seriesIndex, onChange, }: {
+    chart: WorkSlideChart;
+    seriesIndex: number;
+    onChange: (chart: WorkSlideChart) => void;
+}): import("react").JSX.Element | null;

package/dist/internal/features/work/editors/presentation-chart-series-canvas.d.ts

@@ -0,0 +1,15 @@
+import type { WorkSlideChartSeries, WorkSpreadsheetChartLineDash } from '../work-types';
+export interface PresentationChartSeriesFill {
+    color: string;
+    opacity: number;
+}
+export interface PresentationChartSeriesLine {
+    color: string;
+    width: number;
+    dash: WorkSpreadsheetChartLineDash;
+}
+export declare function presentationChartSeriesFill(series: WorkSlideChartSeries, seriesIndex: number, defaultOpacity?: number, defaultColor?: string): PresentationChartSeriesFill;
+export declare function presentationChartSeriesLine(series: WorkSlideChartSeries, seriesIndex: number, defaultWidth: number, defaultColor?: string): PresentationChartSeriesLine;
+export declare function fillPresentationChartShape(context: CanvasRenderingContext2D, fill: PresentationChartSeriesFill, draw: () => void): void;
+export declare function strokePresentationChartPath(context: CanvasRenderingContext2D, line: PresentationChartSeriesLine): void;
+export declare function drawPresentationChartMarker(context: CanvasRenderingContext2D, series: WorkSlideChartSeries, seriesIndex: number, x: number, y: number, defaultVisible: boolean, defaultColor?: string): void;

package/dist/internal/features/work/editors/presentation-command-controller.d.ts

@@ -0,0 +1,3 @@
+import { type OfficeEditorExtension } from './office-editor-extension';
+import type { PresentationCommandContext, PresentationEditorCommands } from './presentation-command-types';
+export declare function createPresentationEditorExtensions(): readonly OfficeEditorExtension<PresentationCommandContext, PresentationEditorCommands>[];

package/dist/internal/features/work/editors/presentation-command-types.d.ts

@@ -0,0 +1,206 @@
+import type { OfficeKernelPresentationAlignment } from '../../../kernel/office-kernel-protocol';
+import type { WorkPresentationContent, WorkSlideElement, WorkSlideTransition, WorkSlideTextRun } from '../work-types';
+import type { OfficeEditorCanCommands } from './office-editor-extension';
+import type { PresentationDesignMode } from './presentation-editor-types';
+import type { PresentationDistribution } from './presentation-selection';
+import type { OfficeTableDimensions } from './office-table-dimensions';
+export type PresentationViewMode = 'normal' | 'sorter';
+export type PresentationSlideshowStart = 'beginning' | 'current';
+export type PresentationCommandResult = boolean | void | Promise<void>;
+export interface PresentationEditorCommands {
+    addDesignPlaceholder: (type: 'body' | 'title') => PresentationCommandResult;
+    addChart: () => PresentationCommandResult;
+    addComment: () => PresentationCommandResult;
+    addElement: (type: 'shape' | 'text') => PresentationCommandResult;
+    addImage: (file: File) => PresentationCommandResult;
+    addSlide: () => PresentationCommandResult;
+    addTable: (dimensions: OfficeTableDimensions) => PresentationCommandResult;
+    alignElement: (alignment: OfficeKernelPresentationAlignment) => PresentationCommandResult;
+    applyTransitionToAll: (transition: WorkSlideTransition | undefined) => PresentationCommandResult;
+    applyPresentationLayout: (layoutId: string) => PresentationCommandResult;
+    closeComments: () => PresentationCommandResult;
+    closeDesign: () => PresentationCommandResult;
+    copySelection: () => boolean;
+    createPresentationLayout: (copyCurrent: boolean) => PresentationCommandResult;
+    cutSelection: () => boolean;
+    deletePresentationComment: (slideId: string, commentId: string) => PresentationCommandResult;
+    deletePresentationLayout: () => PresentationCommandResult;
+    deleteSelection: () => boolean;
+    deleteSlide: () => PresentationCommandResult;
+    deleteSlideById: (slideId: string) => boolean;
+    distributeElements: (direction: PresentationDistribution) => PresentationCommandResult;
+    duplicateSelection: () => boolean;
+    duplicateSlide: () => PresentationCommandResult;
+    editDesign: (mode: PresentationDesignMode) => PresentationCommandResult;
+    editElement: (id: string) => void;
+    exitEditing: () => void;
+    groupElements: () => boolean;
+    instantiatePlaceholder: (definition: WorkSlideElement) => PresentationCommandResult;
+    locatePresentationComment: (slideId: string, commentId: string) => PresentationCommandResult;
+    nudgeSelection: (key: string, distance: number) => boolean;
+    openComment: (commentId: string) => PresentationCommandResult;
+    pasteSelection: () => boolean;
+    redo: () => boolean;
+    renamePresentationLayout: (name: string) => PresentationCommandResult;
+    renamePresentationMaster: (name: string) => PresentationCommandResult;
+    reorderElement: (direction: -1 | 1) => PresentationCommandResult;
+    requestImage: () => PresentationCommandResult;
+    selectElement: (elementId: string | null, additive?: boolean) => PresentationCommandResult;
+    selectElements: (ids: readonly string[]) => void;
+    selectSlide: (slideId: string, returnToSlideMode?: boolean) => PresentationCommandResult;
+    setPresentationContent: (content: WorkPresentationContent) => PresentationCommandResult;
+    setBackground: (color: string) => PresentationCommandResult;
+    setPresentationLayoutBackground: (color: string | undefined) => PresentationCommandResult;
+    setPresentationMasterBackground: (color: string) => PresentationCommandResult;
+    setTransition: (transition: WorkSlideTransition | undefined) => PresentationCommandResult;
+    setViewMode: (mode: PresentationViewMode) => PresentationCommandResult;
+    startSlideshow: (source: PresentationSlideshowStart) => PresentationCommandResult;
+    toggleBold: () => boolean;
+    toggleItalic: () => boolean;
+    toggleUnderline: () => boolean;
+    toggleComments: () => PresentationCommandResult;
+    toggleDesign: () => PresentationCommandResult;
+    togglePresentationLayoutBackground: (enabled: boolean) => PresentationCommandResult;
+    undo: () => boolean;
+    ungroupElements: () => boolean;
+    updateElement: (patch: Partial<WorkSlideElement>, options?: {
+        restoreTextFocus?: boolean;
+    }) => PresentationCommandResult;
+    updateNotes: (notes: string) => PresentationCommandResult;
+    updatePresentationComment: (slideId: string, commentId: string, text: string) => PresentationCommandResult;
+    updateTextElement: (elementId: string, value: {
+        text: string;
+        textRuns?: WorkSlideTextRun[];
+    }) => PresentationCommandResult;
+}
+export type PresentationEditorCanCommands = OfficeEditorCanCommands<PresentationEditorCommands>;
+export interface PresentationHistoryCommandPort {
+    canRedo: boolean;
+    canUndo: boolean;
+    redo: () => boolean;
+    undo: () => boolean;
+}
+export interface PresentationDocumentCommandPort {
+    setContent: (content: WorkPresentationContent) => PresentationCommandResult;
+}
+export interface PresentationClipboardCommandPort {
+    canCopySelection: boolean;
+    canCutSelection: boolean;
+    canPasteSelection: boolean;
+    copySelection: () => boolean;
+    cutSelection: () => boolean;
+    pasteSelection: () => boolean;
+}
+export interface PresentationSlideCommandPort {
+    canAddSlide: boolean;
+    canApplyTransitionToAll: (transition: WorkSlideTransition | undefined) => boolean;
+    canDeleteSlide: boolean;
+    canDuplicateSlide: boolean;
+    canSetTransition: boolean;
+    addSlide: () => PresentationCommandResult;
+    applyTransitionToAll: (transition: WorkSlideTransition | undefined) => PresentationCommandResult;
+    deleteSlide: () => PresentationCommandResult;
+    deleteSlideById: (slideId: string) => boolean;
+    duplicateSlide: () => PresentationCommandResult;
+    selectSlide: (slideId: string, returnToSlideMode: boolean) => PresentationCommandResult;
+    setBackground: (color: string) => PresentationCommandResult;
+    setTransition: (transition: WorkSlideTransition | undefined) => PresentationCommandResult;
+    updateNotes: (notes: string) => PresentationCommandResult;
+}
+export interface PresentationInsertCommandPort {
+    enabled: boolean;
+    addChart: () => PresentationCommandResult;
+    addElement: (type: 'shape' | 'text') => PresentationCommandResult;
+    addImage: (file: File) => PresentationCommandResult;
+    addTable: (dimensions: OfficeTableDimensions) => PresentationCommandResult;
+    instantiatePlaceholder: (definition: WorkSlideElement) => PresentationCommandResult;
+    requestImage: () => PresentationCommandResult;
+}
+export interface PresentationDesignCommandPort {
+    addPlaceholder: (type: 'body' | 'title') => PresentationCommandResult;
+    applyLayout: (layoutId: string) => PresentationCommandResult;
+    canDeleteLayout: boolean;
+    close: () => PresentationCommandResult;
+    createLayout: (copyCurrent: boolean) => PresentationCommandResult;
+    deleteLayout: () => PresentationCommandResult;
+    edit: (mode: PresentationDesignMode) => PresentationCommandResult;
+    renameLayout: (name: string) => PresentationCommandResult;
+    renameMaster: (name: string) => PresentationCommandResult;
+    setLayoutBackground: (color: string | undefined) => PresentationCommandResult;
+    setMasterBackground: (color: string) => PresentationCommandResult;
+    toggleLayoutBackground: (enabled: boolean) => PresentationCommandResult;
+}
+export interface PresentationElementCommandPort {
+    canAlignElement: boolean;
+    canDistributeElements: boolean;
+    canGroupElements: boolean;
+    canReorderElement: boolean;
+    canUngroupElements: boolean;
+    canUpdateElement: boolean;
+    alignElement: (alignment: OfficeKernelPresentationAlignment) => PresentationCommandResult;
+    distributeElements: (direction: PresentationDistribution) => PresentationCommandResult;
+    groupElements: () => boolean;
+    reorderElement: (direction: -1 | 1) => PresentationCommandResult;
+    ungroupElements: () => boolean;
+    updateElement: (patch: Partial<WorkSlideElement>, options: {
+        restoreTextFocus?: boolean;
+    }) => PresentationCommandResult;
+    updateTextElement: (elementId: string, value: {
+        text: string;
+        textRuns?: WorkSlideTextRun[];
+    }) => PresentationCommandResult;
+}
+export interface PresentationSelectionCommandPort {
+    canDeleteSelection: boolean;
+    canDuplicateSelection: boolean;
+    canEditElement: (id: string) => boolean;
+    canExitEditing: boolean;
+    canNudgeSelection: boolean;
+    canToggleBold: boolean;
+    canToggleItalic: boolean;
+    canToggleUnderline: boolean;
+    deleteSelection: () => boolean;
+    duplicateSelection: () => boolean;
+    editElement: (id: string) => void;
+    exitEditing: () => void;
+    nudgeSelection: (key: string, distance: number) => boolean;
+    selectElement: (elementId: string | null, additive: boolean) => void;
+    selectElements: (ids: readonly string[]) => void;
+    toggleBold: () => boolean;
+    toggleItalic: () => boolean;
+    toggleUnderline: () => boolean;
+}
+export interface PresentationReviewCommandPort {
+    canAddComment: boolean;
+    addComment: () => PresentationCommandResult;
+    closeComments: () => PresentationCommandResult;
+    deleteComment: (slideId: string, commentId: string) => PresentationCommandResult;
+    locateComment: (slideId: string, commentId: string) => PresentationCommandResult;
+    openComment: (commentId: string) => PresentationCommandResult;
+    toggleComments: () => PresentationCommandResult;
+    updateComment: (slideId: string, commentId: string, text: string) => PresentationCommandResult;
+}
+export interface PresentationViewCommandPort {
+    canStartSlideshow: boolean;
+    setViewMode: (mode: PresentationViewMode) => PresentationCommandResult;
+    startSlideshow: (source: PresentationSlideshowStart) => PresentationCommandResult;
+    toggleDesign: () => PresentationCommandResult;
+}
+export interface PresentationKeyboardCommandPort {
+    editingElementId: string | null;
+    selectedElement: WorkSlideElement | null;
+    selectedElementCount: number;
+}
+export interface PresentationCommandContext {
+    clipboard: PresentationClipboardCommandPort;
+    design: PresentationDesignCommandPort;
+    document: PresentationDocumentCommandPort;
+    elements: PresentationElementCommandPort;
+    history: PresentationHistoryCommandPort;
+    insert: PresentationInsertCommandPort;
+    keyboard: PresentationKeyboardCommandPort;
+    review: PresentationReviewCommandPort;
+    selection: PresentationSelectionCommandPort;
+    slides: PresentationSlideCommandPort;
+    view: PresentationViewCommandPort;
+}

package/dist/internal/features/work/editors/presentation-comments-panel.d.ts

@@ -0,0 +1,9 @@
+import type { WorkSlide } from '../work-types';
+import type { PresentationEditorCommands } from './presentation-command-types';
+export type PresentationCommentsPanelCommands = Pick<PresentationEditorCommands, 'closeComments' | 'deletePresentationComment' | 'locatePresentationComment' | 'updatePresentationComment'>;
+export declare function PresentationCommentsPanel({ slides, activeCommentId, commands, }: {
+    slides: WorkSlide[];
+    activeCommentId: string | null;
+    commands: PresentationCommentsPanelCommands;
+}): import("react").JSX.Element;
+export declare function presentationCommentCount(slides: readonly WorkSlide[]): number;

package/dist/internal/features/work/editors/presentation-context-menu.d.ts

@@ -0,0 +1,11 @@
+import type { WorkspaceContextMenuItem } from '../../workspace/components/workspace-context-menu';
+import type { PresentationEditorCanCommands, PresentationEditorCommands } from './presentation-command-types';
+type PresentationContextCan = Pick<PresentationEditorCanCommands, 'addSlide' | 'copySelection' | 'cutSelection' | 'deleteSelection' | 'deleteSlide' | 'duplicateSelection' | 'duplicateSlide' | 'pasteSelection'>;
+type PresentationContextCommands = Pick<PresentationEditorCommands, 'addSlide' | 'copySelection' | 'cutSelection' | 'deleteSelection' | 'deleteSlideById' | 'duplicateSelection' | 'duplicateSlide' | 'pasteSelection'>;
+export declare function presentationCoreContextMenuItems({ can, commands, slideId, target, }: {
+    can: PresentationContextCan;
+    commands: PresentationContextCommands;
+    slideId: string;
+    target: 'slide' | 'element';
+}): WorkspaceContextMenuItem[];
+export {};

package/dist/internal/features/work/editors/presentation-design-panel.d.ts

@@ -0,0 +1,13 @@
+import type { WorkPresentationContent, WorkPresentationLayout, WorkPresentationMaster, WorkSlide } from '../work-types';
+import type { PresentationEditorCanCommands, PresentationEditorCommands } from './presentation-command-types';
+import type { PresentationDesignMode } from './presentation-editor-types';
+export type PresentationDesignPanelCommands = Pick<PresentationEditorCommands, 'addDesignPlaceholder' | 'applyPresentationLayout' | 'closeDesign' | 'createPresentationLayout' | 'deletePresentationLayout' | 'editDesign' | 'renamePresentationLayout' | 'renamePresentationMaster' | 'setPresentationLayoutBackground' | 'setPresentationMasterBackground' | 'togglePresentationLayoutBackground'>;
+export declare function PresentationDesignPanel({ can, commands, content, slide, layout, master, mode, }: {
+    can: Pick<PresentationEditorCanCommands, 'deletePresentationLayout'>;
+    commands: PresentationDesignPanelCommands;
+    content: WorkPresentationContent;
+    slide: WorkSlide;
+    layout: WorkPresentationLayout;
+    master: WorkPresentationMaster;
+    mode: PresentationDesignMode;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/presentation-editor-focus.d.ts

@@ -0,0 +1,12 @@
+import type { PresentationEditorCommands } from './presentation-command-types';
+export interface PresentationObjectFocusState {
+    editingElementId: string | null;
+    selectedElementIds: readonly string[];
+}
+export interface PresentationWorkspaceFocusState extends PresentationObjectFocusState {
+    selectedSlideId: string;
+    viewMode: 'normal' | 'sorter';
+}
+export declare function restorePresentationObjectFocus(container: HTMLElement | null, getState: () => PresentationObjectFocusState): void;
+export declare function restorePresentationWorkspaceFocus(root: HTMLElement | null, getState: () => PresentationWorkspaceFocusState): void;
+export declare function presentationCommandsWithObjectFocus(commands: PresentationEditorCommands, restoreFocus: () => void): PresentationEditorCommands;

package/dist/internal/features/work/editors/presentation-editor-operations.d.ts

@@ -0,0 +1,10 @@
+import type { WorkPresentationContent, WorkSlide, WorkSlideElement } from '../work-types';
+import type { PresentationDesignMode } from './presentation-editor-types';
+export declare function updatePresentationElements(content: WorkPresentationContent, mode: PresentationDesignMode, targetId: string, update: (elements: WorkSlideElement[]) => WorkSlideElement[], onChange: (content: WorkPresentationContent) => void): void;
+export declare function updateSlide(content: WorkPresentationContent, slideId: string, update: (slide: WorkSlide) => WorkSlide, onChange: (content: WorkPresentationContent) => void): void;
+export declare function newSlide(number: number): WorkSlide;
+export declare function newPresentationElement(type: 'shape' | 'text'): WorkSlideElement;
+export declare function newPresentationTableElement(requestedRows?: number, requestedColumns?: number): WorkSlideElement;
+export declare function newPresentationImageElement(file: File): Promise<WorkSlideElement>;
+export declare function clamp(value: number, minimum: number, maximum: number): number;
+export declare function structuredCopy<T>(value: T): T;

package/dist/internal/features/work/editors/presentation-editor-types.d.ts

@@ -0,0 +1,22 @@
+import type { WorkEditorAgentRequest } from '../work-agent-request';
+import type { WorkPresentationContent } from '../work-types';
+import type { WorkOfficeFileAction } from './work-office-chrome';
+export type PresentationDesignMode = 'slide' | 'layout' | 'master';
+export interface PresentationEditorProps {
+    content: WorkPresentationContent;
+    preview: boolean;
+    saveStatus?: string;
+    fileActions?: readonly WorkOfficeFileAction[];
+    kernelWasmUrl?: string;
+    onChange: (content: WorkPresentationContent) => void;
+    onAgentRequest?: (request: WorkEditorAgentRequest) => void | Promise<void>;
+    onStartSlideshow?: () => void;
+}
+export interface PresentationAgentMenuState {
+    x: number;
+    y: number;
+    selection: string;
+    target: 'slide' | 'element';
+    slideId: string;
+    elementId: string | null;
+}

package/dist/internal/features/work/editors/presentation-editor.d.ts

@@ -0,0 +1,3 @@
+import type { PresentationEditorProps } from './presentation-editor-types';
+export type { PresentationEditorProps } from './presentation-editor-types';
+export declare function PresentationEditor(props: PresentationEditorProps): import("react").JSX.Element | null;

package/dist/internal/features/work/editors/presentation-keyboard-extension.d.ts

@@ -0,0 +1,3 @@
+import { type OfficeEditorExtension } from './office-editor-extension';
+import type { PresentationCommandContext, PresentationEditorCommands } from './presentation-command-types';
+export declare function createPresentationKeyboardExtension(): OfficeEditorExtension<PresentationCommandContext, PresentationEditorCommands>;

package/dist/internal/features/work/editors/presentation-player.d.ts

@@ -0,0 +1,7 @@
+import type { WorkPresentationContent } from '../work-types';
+export declare function PresentationPlayer({ autoFullscreen, content, initialIndex, onExit, }: {
+    autoFullscreen?: boolean;
+    content: WorkPresentationContent;
+    initialIndex?: number;
+    onExit?: () => void;
+}): import("react").JSX.Element | null;

package/dist/internal/features/work/editors/presentation-presenter-view.d.ts

@@ -0,0 +1,15 @@
+import type { WorkPresentationContent, WorkSlide } from '../work-types';
+export interface PresentationTimerController {
+    elapsedMilliseconds: number;
+    runningSinceMilliseconds: number | null;
+}
+export declare function createPresentationTimerController(now?: number): PresentationTimerController;
+export declare function PresentationPresenterView({ content, slide, nextSlide, index, total, aspectRatio, timer, }: {
+    content: WorkPresentationContent;
+    slide: WorkSlide;
+    nextSlide?: WorkSlide;
+    index: number;
+    total: number;
+    aspectRatio: string;
+    timer: PresentationTimerController;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/presentation-selection.d.ts

@@ -0,0 +1,21 @@
+import type { OfficeKernelPresentationAlignment } from '../../../kernel/office-kernel-protocol';
+import type { WorkSlideElement } from '../work-types';
+export type PresentationDistribution = 'horizontal' | 'vertical';
+export interface PresentationSelectionBounds {
+    bottom: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    width: number;
+}
+export declare function selectPresentationElement(selectedIds: readonly string[], elementId: string, additive: boolean): string[];
+export declare function selectPresentationElementUnit(elements: readonly WorkSlideElement[], selectedIds: readonly string[], elementId: string, additive: boolean): string[];
+export declare function selectedPresentationElements(elements: readonly WorkSlideElement[], selectedIds: readonly string[]): WorkSlideElement[];
+export declare function presentationSelectionBounds(elements: readonly WorkSlideElement[]): PresentationSelectionBounds | null;
+export declare function translatePresentationSelection(elements: readonly WorkSlideElement[], selectedIds: readonly string[], deltaX: number, deltaY: number): WorkSlideElement[];
+export declare function alignPresentationSelection(elements: readonly WorkSlideElement[], selectedIds: readonly string[], alignment: OfficeKernelPresentationAlignment): WorkSlideElement[];
+export declare function distributePresentationSelection(elements: readonly WorkSlideElement[], selectedIds: readonly string[], direction: PresentationDistribution): WorkSlideElement[];
+export declare function reorderPresentationSelection(elements: readonly WorkSlideElement[], selectedIds: readonly string[], direction: -1 | 1): WorkSlideElement[];
+export declare function presentationElementCanEditContent(element: WorkSlideElement): boolean;
+export declare function presentationElementSupportsTextFormatting(element: WorkSlideElement): boolean;

package/dist/internal/features/work/editors/presentation-slide-canvas.d.ts

@@ -0,0 +1,26 @@
+import type { WorkPresentationContent, WorkSlide, WorkSlideElement } from '../work-types';
+export declare function SlideCanvas({ content, slide, interactive, aspectRatio, showPlaceholders, }: {
+    content?: WorkPresentationContent;
+    slide: WorkSlide;
+    interactive: boolean;
+    aspectRatio: string;
+    showPlaceholders?: boolean;
+}): import("react").JSX.Element;
+export declare function SlideElementPreview({ element, origin, showPlaceholder, }: {
+    element: WorkSlideElement;
+    origin: 'inherited' | 'slide';
+    showPlaceholder?: boolean;
+}): import("react").JSX.Element;
+export declare function EditableSlideTable({ element, onChange, }: {
+    element: WorkSlideElement;
+    onChange: (rows: string[][]) => void;
+}): import("react").JSX.Element | null;
+export declare function slideElementStyle(element: WorkSlideElement): React.CSSProperties;
+export declare function slideTextStyle(element: WorkSlideElement): React.CSSProperties;
+export declare function SlideElementTextPreview({ element, showPlaceholder, }: {
+    element: WorkSlideElement;
+    showPlaceholder?: boolean;
+}): import("react").JSX.Element;
+export declare function SlideTablePreview({ element }: {
+    element: WorkSlideElement;
+}): import("react").JSX.Element | null;

package/dist/internal/features/work/editors/presentation-slide-thumbnail.d.ts

@@ -0,0 +1,18 @@
+import type { WorkspaceContextMenuEvent } from '../../workspace/components/workspace-context-menu';
+import type { WorkPresentationContent, WorkSlide } from '../work-types';
+export declare function PresentationSlideThumbnail({ content, slide, index, selected, slideCount, aspectRatio, variant, renderPreview, onFocus, onSelect, onDelete, onNavigate, onContextMenu, onDoubleClick, }: {
+    content: WorkPresentationContent;
+    slide: WorkSlide;
+    index: number;
+    selected: boolean;
+    slideCount: number;
+    aspectRatio: string;
+    variant: 'strip' | 'sorter';
+    renderPreview: boolean;
+    onFocus: () => void;
+    onSelect: () => void;
+    onDelete: () => boolean;
+    onNavigate: (index: number) => void;
+    onContextMenu?: (event: WorkspaceContextMenuEvent<HTMLButtonElement>) => void;
+    onDoubleClick?: () => void;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/presentation-status-bar.d.ts

@@ -0,0 +1,10 @@
+import type { WorkPresentationContent, WorkSlide } from '../work-types';
+export declare function PresentationStatusBar({ content, selectedSlide, viewMode, zoom, saveStatus, onViewModeChange, onZoomChange, }: {
+    content: WorkPresentationContent;
+    selectedSlide: WorkSlide;
+    viewMode: 'normal' | 'sorter';
+    zoom: number;
+    saveStatus: string;
+    onViewModeChange: (mode: 'normal' | 'sorter') => void;
+    onZoomChange: (zoom: number) => void;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/presentation-text-editor.d.ts

@@ -0,0 +1,22 @@
+import type { Editor, Extensions } from '@tiptap/core';
+import type { WorkSlideElement, WorkSlideTextRun } from '../work-types';
+export interface PresentationTextValue {
+    text: string;
+    textRuns?: WorkSlideTextRun[];
+}
+export interface PresentationTextEditorProps {
+    autoFocus?: boolean;
+    element: WorkSlideElement;
+    onChange: (value: PresentationTextValue) => void;
+    onEditorChange?: (editor: Editor | null) => void;
+    onExitEditing?: () => void;
+    onSelectionChange?: () => void;
+}
+export declare function PresentationTextEditor({ autoFocus, element, onChange, onEditorChange, onExitEditing, onSelectionChange, }: PresentationTextEditorProps): import("react").JSX.Element | null;
+export declare function createPresentationTextEditorExtensions(placeholder?: string): Extensions;
+export declare function presentationTextElementHtml(element: WorkSlideElement): string;
+export declare function presentationTextValue(editor: Editor, element: WorkSlideElement): PresentationTextValue;
+export declare function presentationTextToolbarState(editor: Editor, element: WorkSlideElement): WorkSlideElement;
+export declare function applyPresentationTextFormatting(editor: Editor, patch: Partial<WorkSlideElement>, options?: {
+    restoreFocus?: boolean;
+}): boolean;

package/dist/internal/features/work/editors/presentation-text-formatting.d.ts

@@ -0,0 +1,3 @@
+import type { WorkSlideElement } from '../work-types';
+export declare function presentationElementToolbarState(element: WorkSlideElement): WorkSlideElement;
+export declare function applyPresentationElementFormattingPatch(element: WorkSlideElement, patch: Partial<WorkSlideElement>): WorkSlideElement;

package/dist/internal/features/work/editors/presentation-thumbnail-rail.d.ts

@@ -0,0 +1,20 @@
+import { type RefObject } from 'react';
+import type { WorkspaceContextMenuEvent } from '../../workspace/components/workspace-context-menu';
+import type { WorkPresentationContent, WorkSlide, WorkSlideElement } from '../work-types';
+export declare function PresentationThumbnailRail({ aspectRatio, content, designContent, selectedSlide, viewMode, zoom, mobileCloseButtonRef, mobileNavigationModal, mobileNavigationId, onAddSlide, onCloseMobileNavigation, onDeleteSlide, onOpenContextMenu, onSelectSlide, onViewModeChange, }: {
+    aspectRatio: string;
+    content: WorkPresentationContent;
+    designContent: WorkPresentationContent;
+    selectedSlide: WorkSlide;
+    viewMode: 'normal' | 'sorter';
+    zoom: number;
+    mobileCloseButtonRef?: RefObject<HTMLButtonElement | null>;
+    mobileNavigationModal?: boolean;
+    mobileNavigationId?: string;
+    onAddSlide: () => void;
+    onCloseMobileNavigation?: () => void;
+    onDeleteSlide: (slideId: string) => boolean;
+    onOpenContextMenu: (event: WorkspaceContextMenuEvent, slide: WorkSlide, slideIndex: number, element?: WorkSlideElement | null) => void;
+    onSelectSlide: (slideId: string, returnToSlideMode: boolean, dismissMobileNavigation?: boolean) => void;
+    onViewModeChange: (mode: 'normal' | 'sorter') => void;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/presentation-toolbar.d.ts

@@ -0,0 +1,19 @@
+import type { WorkSlide, WorkSlideElement } from '../work-types';
+import type { PresentationEditorCanCommands, PresentationEditorCommands } from './presentation-command-types';
+import { type WorkOfficeFileAction } from './work-office-chrome';
+export declare function PresentationToolbar({ selectedSlide, selectedElement, selectedUnitCount, can, textFormattingAvailable, commentsOpen, commentCount, designOpen, editingDesign, background, transition, fileActions, viewMode, commands, }: {
+    selectedSlide: WorkSlide;
+    selectedElement: WorkSlideElement | null;
+    selectedUnitCount: number;
+    can: PresentationEditorCanCommands;
+    textFormattingAvailable: boolean;
+    commentsOpen: boolean;
+    commentCount: number;
+    designOpen: boolean;
+    editingDesign: boolean;
+    background?: string;
+    transition: WorkSlide['transition'];
+    fileActions?: readonly WorkOfficeFileAction[];
+    viewMode?: 'normal' | 'sorter';
+    commands: PresentationEditorCommands;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/presentation-transition-panel.d.ts

@@ -0,0 +1,9 @@
+import type { WorkSlideTransition } from '../work-types';
+export declare function PresentationTransitionPanel({ slideId, transition, editable, canApplyToAll, onChange, onApplyToAll, }: {
+    slideId: string;
+    transition: WorkSlideTransition | undefined;
+    editable: boolean;
+    canApplyToAll: (transition: WorkSlideTransition | undefined) => boolean;
+    onChange: (transition: WorkSlideTransition | undefined) => void;
+    onApplyToAll: (transition: WorkSlideTransition | undefined) => void;
+}): import("react").JSX.Element;