@printstack/print-studio 0.0.0-stage → 0.1.0

package/designer/plugins/plugin-context.d.ts

@@ -0,0 +1,100 @@
+import { Component } from 'vue';
+import { DesignerEventMap, TypedEventBus } from '../../core/events';
+import { PrintDocument } from '../../core/types';
+import { CommandDefinition } from '../commands/types';
+import { EditorContext } from '../context/editor-context';
+import { PanelDefinition } from '../stores/panel-store';
+import { TemplateLibraryProvider } from '../template-library/types';
+import { PluginLocale } from '../../locales/plugin-locales';
+import { PreferenceStorage } from '../../studio-types';
+import { deserializeDocument } from '../../core/document-model';
+import { ExtensionContribution } from './extension-points';
+import { PluginCanvas } from './plugin-canvas';
+import { PluginScope } from './plugin-scope';
+import { PluginDisposer, PluginManifest } from './types';
+export type PluginCommand = Omit<CommandDefinition, 'run'> & {
+    run(context: PluginContext, ...args: unknown[]): unknown;
+};
+export interface PluginView {
+    component: Component;
+    props?: Record<string, unknown>;
+}
+export interface PluginContext {
+    readonly apiVersion: '1.0';
+    readonly canvas: PluginCanvas;
+    readonly commands: {
+        execute(id: string, ...args: unknown[]): Promise<boolean>;
+        get(id: string): PluginCommand | undefined;
+        register(definition: PluginCommand): PluginDisposer;
+        registerScoped(definitions: PluginCommand[]): PluginDisposer;
+    };
+    readonly data: {
+        provide(point: string, id: string, value: unknown): PluginDisposer;
+    };
+    readonly document: {
+        getDocument(): PrintDocument;
+        getPersistentDocument(): PrintDocument;
+        load(document: PrintDocument): void;
+        normalize(document: PrintDocument): ReturnType<typeof deserializeDocument>;
+        suspendPersistence(): PluginDisposer;
+    };
+    readonly errors: Pick<EditorContext['errors'], 'capture'>;
+    readonly events: {
+        on: TypedEventBus<DesignerEventMap>['on'];
+    };
+    readonly extensions: {
+        contribute<T>(contribution: ExtensionContribution<T>): PluginDisposer;
+    };
+    readonly hooks: {
+        on: TypedEventBus<DesignerEventMap>['on'];
+    };
+    readonly locales: {
+        register(resource: PluginLocale): PluginDisposer;
+    };
+    readonly menu: {
+        add(definition: PluginCommand): PluginDisposer;
+    };
+    onDispose(dispose: PluginDisposer): PluginDisposer;
+    readonly output: {
+        download(filename: string, blob: Blob): void;
+    };
+    readonly overrides: {
+        command(definition: PluginCommand): PluginDisposer;
+    };
+    readonly panels: {
+        register(definition: PanelDefinition): PluginDisposer;
+    };
+    readonly pluginId: string;
+    readonly preferences: {
+        register(storage: PreferenceStorage): PluginDisposer;
+    };
+    readonly rendering: Pick<ReturnType<EditorContext['store']>['rendering'], 'runExternal'> & {
+        readonly active: boolean;
+    };
+    readonly signal: AbortSignal;
+    readonly slots: {
+        add(point: string, id: string, view: PluginView): PluginDisposer;
+    };
+    readonly tabs: {
+        register(definition: PanelDefinition): PluginDisposer;
+    };
+    readonly templateLibrary: {
+        register(provider: TemplateLibraryProvider): PluginDisposer;
+    };
+    readonly tools: {
+        register(definition: PluginCommand): PluginDisposer;
+    };
+    readonly ui: Pick<ReturnType<EditorContext['store']>['ui'], 'completeExportDialog' | 'finishExportDialog' | 'openExportDialog' | 'toast'> & {
+        readonly exportDialog: boolean;
+    };
+}
+export declare const HOST_POINTS: {
+    readonly command: "designer.commands";
+    readonly menu: "designer.menu";
+    readonly override: "designer.commands.override";
+    readonly panel: "designer.panels";
+    readonly tab: "designer.tabs";
+    readonly tool: "designer.tools";
+};
+export declare function installHostExtensionPoints(host: EditorContext): void;
+export declare function createPluginContext(host: EditorContext, manifest: PluginManifest, scope: PluginScope): PluginContext;

package/designer/plugins/plugin-manager.d.ts

@@ -0,0 +1,44 @@
+import { EditorContext } from '../context/editor-context';
+import { DesignerPlugin, DesignerPluginFactory, LazyPlugin, PluginDefinition, PluginDisposer, PluginInput, PluginPermission, PluginStatus } from './types';
+export interface PluginPolicy {
+    allowLegacy?: boolean;
+    /** 宿主授予插件的最大权限；未声明权限的旧插件仍为受信任兼容入口。 */
+    permissions?: readonly PluginPermission[];
+}
+export declare class PluginManager {
+    #private;
+    private readonly getContext;
+    private readonly policy;
+    constructor(getContext: () => EditorContext, policy?: PluginPolicy);
+    close(): void;
+    disable(id: string): boolean;
+    dispose(id: string): boolean;
+    disposeAll(): void;
+    enable(id: string): Promise<void> | void;
+    has(id: string): boolean;
+    install(plugin: LazyPlugin | PluginInput): string;
+    list(): string[];
+    load(plugin: LazyPlugin): Promise<void>;
+    status(id: string): 'missing' | PluginStatus;
+    /** 仅宿主装配层使用；不暴露给 Plugin Context。 */
+    trustHostPlugin(plugin: DesignerPlugin): void;
+    uninstall(id: string): boolean;
+    use(plugin: DesignerPlugin): void;
+    use(plugin: PluginDefinition): Promise<void> | void;
+    use(plugin: PluginInput): Promise<void> | void;
+    use<Options>(factory: DesignerPluginFactory<Options>, options?: Options): Promise<void> | void;
+    useScoped(plugin: DesignerPlugin): PluginDisposer;
+    useScoped(plugin: PluginInput): PluginDisposer | Promise<PluginDisposer>;
+    private activate;
+    private assertNoDependents;
+    private checkDependencies;
+    private createLegacyContext;
+    private deactivate;
+    private fail;
+    private loadDefinition;
+    private removeFailedInstallation;
+    private report;
+    private require;
+    private setStatus;
+    private validate;
+}

package/designer/plugins/plugin-scope.d.ts

@@ -0,0 +1,10 @@
+import { PluginDisposer } from './types';
+export declare class PluginScope {
+    #private;
+    private readonly report;
+    readonly controller: AbortController;
+    constructor(report: (error: unknown) => void);
+    assertActive(): void;
+    dispose(): void;
+    track(dispose: PluginDisposer): PluginDisposer;
+}

package/designer/plugins/sandbox-plugin.d.ts

@@ -0,0 +1,9 @@
+import { PluginDefinition, PluginManifest } from './types';
+export interface SandboxedPluginOptions {
+    manifest: PluginManifest;
+    timeoutMs?: number;
+    /** 宿主显式选择的模块地址；模块在 opaque-origin iframe 内执行。 */
+    url: string;
+}
+/** 隔离插件只通过结构化消息注册命令、执行授权命令和访问文档快照。 */
+export declare function createSandboxedPlugin(options: SandboxedPluginOptions): PluginDefinition;

package/designer/plugins/tdesign-forms.d.ts

@@ -0,0 +1,32 @@
+import { DesignerPlugin } from './types';
+import { default as FieldBoolean } from '../components/fields/field-boolean.vue';
+import { default as FieldDataPreview } from '../components/fields/field-data-preview.vue';
+import { default as FieldImage } from '../components/fields/field-image.vue';
+import { default as FieldTableBorders } from '../components/fields/field-table-borders.vue';
+import { default as FieldTableContinuationLayout } from '../components/fields/field-table-continuation-layout.vue';
+import { default as TableInspectorControl } from '../components/forms/table-inspector-control.vue';
+import { default as VariableTextField } from '../components/variable-text/variable-text-field.vue';
+declare module '../../components/s-form/types' {
+    interface SFormComponentRegistry {
+        booleanField: typeof FieldBoolean;
+        imageField: typeof FieldImage;
+        tableBordersField: typeof FieldTableBorders;
+        tableContinuationLayoutField: typeof FieldTableContinuationLayout;
+        tableDataPreview: typeof FieldDataPreview;
+        tableField: typeof TableInspectorControl;
+        variableTextField: typeof VariableTextField;
+    }
+    interface SFormComponentRegistry extends DeclareSFormComponent<'colorField', {
+        allowNone?: boolean;
+        modelValue?: string;
+        onCommit?: () => void;
+        resetValue?: string;
+    }> {
+    }
+    interface SFormComponentRegistry extends DeclareSFormComponent<'collectionPicker', {
+        modelValue?: string;
+        onOpen?: () => void;
+    }> {
+    }
+}
+export declare const tdesignFormsPlugin: DesignerPlugin;

package/designer/plugins/template-library.d.ts

@@ -0,0 +1,7 @@
+import { DesignerPlugin } from './types';
+/**
+ * 模板库：注册「文件 > 模板库」命令与内置来源。
+ * 扩展方式：在宿主插件中 `ctx.templateLibrary.register(provider)`（可用
+ * createRemoteTemplateProvider 接入远程清单），或注册同 id 命令替换行为。
+ */
+export declare const templateLibraryPlugin: DesignerPlugin;

package/designer/plugins/tutorials.d.ts

@@ -0,0 +1,2 @@
+import { DesignerPlugin } from './types';
+export declare const tutorialsPlugin: DesignerPlugin;

package/designer/plugins/types.d.ts

@@ -0,0 +1,63 @@
+import { ElementDefinition } from '../../core/element-registry';
+import { EditorContext } from '../context/editor-context';
+import { PluginLocale } from '../../locales/plugin-locales';
+import { PluginContext } from './plugin-context';
+/** 清理函数：解绑监听、注销命令等；插件 dispose 时按注册逆序调用 */
+export type PluginDisposer = () => void;
+/** 在文档反序列化前提供纯数据资源，不依赖已创建的编辑器上下文。 */
+export interface PluginResources {
+    elements(): ElementDefinition[];
+    locales?: PluginLocale[];
+}
+export interface DesignerPluginFactory<Options> {
+    createPlugin(options?: Options): PluginInput;
+}
+export type PluginPermission = 'canvas' | 'commands' | 'data' | 'document:read' | 'document:write' | 'events' | 'locales' | 'panels' | 'preferences' | 'rendering' | 'templates' | 'ui';
+export interface PluginManifest {
+    apiVersion: '1.0';
+    /** 除自身命令外，可执行的宿主命令 ID。 */
+    commands?: string[];
+    dependencies?: PluginDependency[];
+    description?: string;
+    id: string;
+    permissions?: PluginPermission[];
+    version: string;
+}
+export interface PluginDependency {
+    id: string;
+    optional?: boolean;
+    version?: string;
+}
+export interface PluginDefinition {
+    manifest: PluginManifest;
+    setup(context: PluginContext): PluginDisposer | Promise<PluginDisposer | void> | void;
+}
+export type PluginFunction = ((context: PluginContext) => PluginDisposer | Promise<PluginDisposer | void> | void) & {
+    manifest?: PluginManifest;
+};
+export type PluginInput = DesignerPlugin | PluginDefinition | PluginFunction;
+export interface LazyPlugin {
+    load(): Promise<PluginDefinition | {
+        default: PluginDefinition;
+    }>;
+    manifest: PluginManifest;
+}
+export type PluginStatus = 'disabled' | 'disabling' | 'enabled' | 'enabling' | 'failed' | 'installed' | 'loading';
+export declare function definePlugin(plugin: PluginDefinition): PluginDefinition;
+export interface DesignerPlugin {
+    /** 可选描述（调试 / 文档展示） */
+    description?: string;
+    /** 全局唯一名称，如 'my-company:autosync'；重复安装同一名称会被跳过 */
+    name: string;
+    /**
+     * 安装钩子。可返回清理函数：
+     * ```ts
+     * setup(ctx) {
+     *   const off = ctx.events.on('selection:changed', payload => { ... })
+     *   ctx.commands.register({ id: 'my.cmd', title: '我的命令', run: () => {} })
+     *   return off
+     * }
+     * ```
+     */
+    setup: (ctx: EditorContext) => PluginDisposer | void;
+}

package/designer/presets.d.ts

@@ -0,0 +1,8 @@
+import { DataSource, PageTemplate, PrintDocument } from '../core/types';
+import { DesignerPlugin } from './plugins/types';
+export interface DesignerPresets {
+    dataSources?: DataSource[];
+    pageTemplates?: PageTemplate[];
+}
+export declare function createPresetDocument(presets?: DesignerPresets): PrintDocument;
+export declare function createPresetsPlugin(presets: DesignerPresets): DesignerPlugin;

package/designer/print-designer.vue.d.ts

@@ -0,0 +1,25 @@
+import { PrintDocument } from '../core/types';
+import { PrintDesignerProps } from './types';
+declare function getDocument(): PrintDocument;
+declare function loadDocument(document: PrintDocument): void;
+declare function save(): Promise<void>;
+declare function isDirty(): boolean;
+declare const __VLS_export: import('vue').DefineComponent<PrintDesignerProps, {
+    context: import('./context/editor-context').EditorContext;
+    getDocument: typeof getDocument;
+    isDirty: typeof isDirty;
+    loadDocument: typeof loadDocument;
+    save: typeof save;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    ready: (context: import('./context/editor-context').EditorContext) => any;
+    error: (error: unknown) => any;
+    dispose: () => any;
+    "dirty-change": (dirty: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<PrintDesignerProps> & Readonly<{
+    onReady?: ((context: import('./context/editor-context').EditorContext) => any) | undefined;
+    onError?: ((error: unknown) => any) | undefined;
+    onDispose?: (() => any) | undefined;
+    "onDirty-change"?: ((dirty: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/designer/services/document-actions.d.ts

@@ -0,0 +1,17 @@
+import { EditorContext } from '../context/editor-context';
+import { RenderExecutionOptions } from '../../parser';
+export declare function useDocumentActions(ctx: EditorContext): {
+    cancelExport: () => void;
+    clearActivePage: () => void;
+    exportHtml: (input?: Record<string, unknown>) => Promise<void>;
+    exportPdf: (input?: Record<string, unknown>) => Promise<void>;
+    openJson: () => Promise<void>;
+    pauseExport: () => void;
+    printDocument: (input?: Record<string, unknown>) => Promise<void>;
+    renderPreviewHtml: (input?: Record<string, unknown>, execution?: RenderExecutionOptions) => Promise<{
+        html: string;
+        warnings: string[];
+    }>;
+    resumeExport: () => void;
+    saveJson: () => Promise<void>;
+};

package/designer/services/editor-resources.d.ts

@@ -0,0 +1,6 @@
+import { ErrorRuntime } from '../../components/error-fallback/core';
+import { ElementRegistry } from '../../core/element-registry';
+export declare function bindEditorErrors(store: object, errors: ErrorRuntime): void;
+export declare function getEditorErrors(store: object): ErrorRuntime;
+export declare function bindEditorElements(store: object, elements: ElementRegistry): void;
+export declare function getEditorElements(store: object): ElementRegistry;

package/designer/services/element-drop.d.ts

@@ -0,0 +1,4 @@
+import { Point } from '../../core/geometry';
+import { PageNode } from '../../core/types';
+import { EditorContext } from '../context/editor-context';
+export declare function importElementFile(ctx: EditorContext, file: File, page: PageNode, point: Point): Promise<void>;

package/designer/services/file-reader.d.ts

@@ -0,0 +1,2 @@
+export declare function readFile(file: File, format: 'dataUrl' | 'text'): Promise<string>;
+export declare function pickFile(accept: string): Promise<File | undefined>;

package/designer/services/file-service.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 文件与打印输出服务：下载、通过隐藏 iframe 调用浏览器打印。
+ */
+export declare function downloadBlob(filename: string, blob: Blob): void;
+export declare function downloadText(filename: string, text: string, mime?: string): void;
+/** 用隐藏 iframe 加载 HTML 并唤起系统打印对话框 */
+export declare function printHtml(html: string): Promise<void>;

package/designer/services/preference-storage.d.ts

@@ -0,0 +1,9 @@
+import { PreferenceStorage } from '../../studio-types';
+export declare class PreferenceStorageRegistry implements PreferenceStorage {
+    #private;
+    private readonly fallback?;
+    constructor(fallback?: PreferenceStorage | undefined);
+    get(key: string): null | string;
+    register(storage: PreferenceStorage): () => void;
+    set(key: string, value: string): void;
+}

package/designer/services/sample-preview.d.ts

@@ -0,0 +1,16 @@
+import { SchemaFieldType } from '../../core/types';
+export declare const SAMPLE_PREVIEW_TEXT_LIMIT = 200;
+export declare const SAMPLE_PREVIEW_FORMAT_LIMIT = 4096;
+export interface SamplePreview {
+    count?: number;
+    formattingSkipped: boolean;
+    kind: 'array' | 'emptyString' | 'missing' | 'null' | 'object' | 'text' | 'unsupported';
+    length?: number;
+    text: string;
+    typeMismatch: boolean;
+}
+export interface SamplePreviewOptions {
+    expectedType?: SchemaFieldType;
+    format?: (value: unknown) => unknown;
+}
+export declare function createSamplePreview(value: unknown, options?: SamplePreviewOptions): SamplePreview;

package/designer/services/stage-service.d.ts

@@ -0,0 +1,24 @@
+import { Point } from '../../core/geometry';
+import { PageNode } from '../../core/types';
+export declare function createStageService(): {
+    contentMmFromClient: (clientX: number, clientY: number, zoom: number) => Point;
+    getScrollElement: () => HTMLElement | null;
+    getStageController: () => null | StageController;
+    registerStageController: (controller: null | StageController) => void;
+    registerStageElements: (scrollEl: HTMLElement | null, contentEl: HTMLElement | null) => void;
+    scrollToContentPoint: (pointMm: Point, viewportX: number, viewportY: number, zoom: number) => void;
+};
+/** 舞台能力接口：由实际渲染舞台的组件（默认 canvas-stage）注册 */
+export interface StageController {
+    /** 定位画布：不改变缩放，把指定页面平滑滚回视口中央；缺省为全部页面并集 */
+    centerPages(page?: PageNode): void;
+    /** 缩放并滚动到内容完整可见 */
+    fitToViewport(): void;
+    /** 平滑滚动到指定页面 */
+    scrollToPage(page: PageNode): void;
+    /** 缩放复位为 1:1 */
+    zoomReset(): void;
+}
+export declare function getStageService(owner?: object): ReturnType<typeof createStageService>;
+export declare function bindStageService(owner: object): void;
+export declare const contentMmFromClient: (clientX: number, clientY: number, zoom: number) => Point, getScrollElement: () => HTMLElement | null, getStageController: () => null | StageController, registerStageController: (controller: null | StageController) => void, registerStageElements: (scrollEl: HTMLElement | null, contentEl: HTMLElement | null) => void, scrollToContentPoint: (pointMm: Point, viewportX: number, viewportY: number, zoom: number) => void;

package/designer/services/text-input.d.ts

@@ -0,0 +1,10 @@
+export interface TextInputControl {
+    editable(): boolean;
+    element: HTMLElement;
+    multiline(): boolean;
+    read(): string;
+    write(value: string): void;
+}
+export declare function registerTextInput(control: TextInputControl): () => void;
+export declare function getTextInput(element: HTMLElement): TextInputControl | undefined;
+export declare function resolveTextInput(container: HTMLElement): TextInputControl | undefined;

package/designer/stores/canvas-store.d.ts

@@ -0,0 +1,33 @@
+import { ElementRegistry } from '../../core/element-registry';
+import { ElementNode, PageNode } from '../../core/types';
+import { createDocumentStore } from './document-store';
+import { createRepeatGroupStore } from './repeat-group-store';
+import { createScopeStore } from './scope-store';
+import { createTemplateStore } from './template-store';
+import { createViewStore } from './view-store';
+export declare function createCanvasStore(deps: {
+    document: Pick<ReturnType<typeof createDocumentStore>, 'data'>;
+    elements?: ElementRegistry;
+    repeatGroup: Pick<ReturnType<typeof createRepeatGroupStore>, 'getByPage'>;
+    scope: Pick<ReturnType<typeof createScopeStore>, 'pages'>;
+    template: Pick<ReturnType<typeof createTemplateStore>, 'editingId'>;
+    view: Pick<ReturnType<typeof createViewStore>, 'settings'>;
+}): import('pinia').Store<"editor-canvas", Pick<{
+    getPage: import('vue').ComputedRef<(id: string) => PageNode | undefined>;
+    resolve: import('vue').ComputedRef<(page: PageNode, nodes: ElementNode[], options?: {
+        resetSize?: boolean;
+        withData?: boolean;
+    }) => ElementNode[]>;
+}, never>, Pick<{
+    getPage: import('vue').ComputedRef<(id: string) => PageNode | undefined>;
+    resolve: import('vue').ComputedRef<(page: PageNode, nodes: ElementNode[], options?: {
+        resetSize?: boolean;
+        withData?: boolean;
+    }) => ElementNode[]>;
+}, "getPage" | "resolve">, Pick<{
+    getPage: import('vue').ComputedRef<(id: string) => PageNode | undefined>;
+    resolve: import('vue').ComputedRef<(page: PageNode, nodes: ElementNode[], options?: {
+        resetSize?: boolean;
+        withData?: boolean;
+    }) => ElementNode[]>;
+}, never>>;

package/designer/stores/clipboard-store.d.ts

@@ -0,0 +1,143 @@
+import { ElementRegistry } from '../../core/element-registry';
+import { ElementNode } from '../../core/types';
+import { createDocumentStore } from './document-store';
+import { createElementStore } from './element-store';
+import { createHistoryStore } from './history-store';
+import { createScopeStore } from './scope-store';
+import { createSelectionStore } from './selection-store';
+import { createUiStore } from './ui-store';
+export declare function createClipboardStore(deps: {
+    document: Pick<ReturnType<typeof createDocumentStore>, 'data'>;
+    element: Pick<ReturnType<typeof createElementStore>, 'removeSelected'>;
+    elements?: ElementRegistry;
+    history: Pick<ReturnType<typeof createHistoryStore>, 'commit'>;
+    scope: Pick<ReturnType<typeof createScopeStore>, 'active'>;
+    selection: Pick<ReturnType<typeof createSelectionStore>, 'set' | 'unlockedNodes'>;
+    ui: Pick<ReturnType<typeof createUiStore>, 'toast'>;
+}): import('pinia').Store<"editor-clipboard", Pick<{
+    copy: () => void;
+    cut: () => void;
+    isEmpty: import('vue').ComputedRef<boolean>;
+    nodes: import('vue').Ref<{
+        bindings?: Record<string, string> | undefined;
+        height: number;
+        id: import('../../core/types').ElementId;
+        locked: boolean;
+        name: string;
+        opacity: number;
+        points?: {
+            x: number;
+            y: number;
+        }[] | undefined;
+        props: Record<string, unknown>;
+        rotation: number;
+        type: string;
+        visible: boolean;
+        width: number;
+        x: number;
+        y: number;
+    }[], ElementNode[] | {
+        bindings?: Record<string, string> | undefined;
+        height: number;
+        id: import('../../core/types').ElementId;
+        locked: boolean;
+        name: string;
+        opacity: number;
+        points?: {
+            x: number;
+            y: number;
+        }[] | undefined;
+        props: Record<string, unknown>;
+        rotation: number;
+        type: string;
+        visible: boolean;
+        width: number;
+        x: number;
+        y: number;
+    }[]>;
+    paste: () => void;
+}, "nodes">, Pick<{
+    copy: () => void;
+    cut: () => void;
+    isEmpty: import('vue').ComputedRef<boolean>;
+    nodes: import('vue').Ref<{
+        bindings?: Record<string, string> | undefined;
+        height: number;
+        id: import('../../core/types').ElementId;
+        locked: boolean;
+        name: string;
+        opacity: number;
+        points?: {
+            x: number;
+            y: number;
+        }[] | undefined;
+        props: Record<string, unknown>;
+        rotation: number;
+        type: string;
+        visible: boolean;
+        width: number;
+        x: number;
+        y: number;
+    }[], ElementNode[] | {
+        bindings?: Record<string, string> | undefined;
+        height: number;
+        id: import('../../core/types').ElementId;
+        locked: boolean;
+        name: string;
+        opacity: number;
+        points?: {
+            x: number;
+            y: number;
+        }[] | undefined;
+        props: Record<string, unknown>;
+        rotation: number;
+        type: string;
+        visible: boolean;
+        width: number;
+        x: number;
+        y: number;
+    }[]>;
+    paste: () => void;
+}, "isEmpty">, Pick<{
+    copy: () => void;
+    cut: () => void;
+    isEmpty: import('vue').ComputedRef<boolean>;
+    nodes: import('vue').Ref<{
+        bindings?: Record<string, string> | undefined;
+        height: number;
+        id: import('../../core/types').ElementId;
+        locked: boolean;
+        name: string;
+        opacity: number;
+        points?: {
+            x: number;
+            y: number;
+        }[] | undefined;
+        props: Record<string, unknown>;
+        rotation: number;
+        type: string;
+        visible: boolean;
+        width: number;
+        x: number;
+        y: number;
+    }[], ElementNode[] | {
+        bindings?: Record<string, string> | undefined;
+        height: number;
+        id: import('../../core/types').ElementId;
+        locked: boolean;
+        name: string;
+        opacity: number;
+        points?: {
+            x: number;
+            y: number;
+        }[] | undefined;
+        props: Record<string, unknown>;
+        rotation: number;
+        type: string;
+        visible: boolean;
+        width: number;
+        x: number;
+        y: number;
+    }[]>;
+    paste: () => void;
+}, "copy" | "cut" | "paste">>;