wendang-react 0.0.0-stage → 0.5.5

package/dist/types/engine/shared/video-feedback.d.ts

@@ -0,0 +1 @@
+export declare function videoProblem(value: string, attempted?: boolean): string;

package/dist/types/engine/shared/workbook.d.ts

@@ -0,0 +1 @@
+export * from 'wendang/internal/workbook';

package/dist/types/engine/worksheets/worksheet-engine.d.ts

@@ -0,0 +1,16 @@
+import '@univerjs/preset-sheets-core/lib/index.css';
+import '@univerjs/preset-sheets-filter/lib/index.css';
+import '@univerjs/preset-sheets-sort/lib/index.css';
+import type { WorkbookDocument } from '../shared/workbook';
+export declare function createWorksheetEngine(container: HTMLElement, initial: WorkbookDocument, onChange: () => void, options?: {
+    theme?: 'light' | 'dark';
+}): {
+    snapshot: () => WorkbookDocument;
+    setEditable: (editable: boolean) => import("@univerjs/preset-sheets-core").FWorkbook;
+    setTheme: (theme: "light" | "dark") => void;
+    isEditing: () => boolean;
+    finishEditing(): Promise<void>;
+    settleCalculation(): Promise<void>;
+    replace(doc: WorkbookDocument): void;
+    dispose(): void;
+};

package/dist/types/engine/worksheets/worksheet-format.d.ts

@@ -0,0 +1,20 @@
+import type { WorkbookCell, WorkbookDocument, WorkbookSheet } from '../shared/workbook';
+export declare function cellStyleData(doc: WorkbookDocument, sheet: WorkbookSheet, r: number, c: number): Record<string, unknown>;
+export declare function cellDisplay(cell: WorkbookCell | null | undefined, style?: Record<string, unknown>): {
+    text: string;
+    note?: string;
+};
+export declare function safeColor(value: unknown): string | undefined;
+export declare const FILTER_RESOURCE = "SHEET_FILTER_PLUGIN";
+export interface SheetFilter {
+    ref: {
+        startRow: number;
+        endRow: number;
+        startColumn: number;
+        endColumn: number;
+    };
+    cachedFilteredOut?: number[];
+    filterColumns?: unknown[];
+}
+export declare function workbookFilters(doc: WorkbookDocument): Record<string, SheetFilter>;
+export declare function dateSerial(value: Date): number;

package/dist/types/engine/worksheets/worksheet-preview.d.ts

@@ -0,0 +1,17 @@
+import type { WorkbookDocument, WorkbookSheet } from '../shared/workbook';
+export declare function columnName(index: number): string;
+export declare function previewAxes(doc: WorkbookDocument, sheet: WorkbookSheet, showAll: boolean): {
+    rows: number[];
+    columns: number[];
+    filtered: number;
+    hasFilter: boolean;
+    hasHidden: boolean;
+};
+export interface PreviewMerge {
+    sourceRow: number;
+    sourceColumn: number;
+    rowspan: number;
+    colspan: number;
+    hidden: boolean;
+}
+export declare function previewMerges(sheet: WorkbookSheet, rows: number[], columns: number[]): Map<string, PreviewMerge>;

package/dist/types/engine/worksheets/worksheet-xlsx.d.ts

@@ -0,0 +1,21 @@
+import { type WorkbookDocument } from '../shared/workbook';
+export interface XlsxInspection {
+    sheets: Array<{
+        name: string;
+        rows: number;
+        columns: number;
+        cells: number;
+        hidden: boolean;
+    }>;
+    warnings: string[];
+}
+export interface XlsxImport {
+    doc: WorkbookDocument;
+    warnings: string[];
+    inspection: XlsxInspection;
+}
+export declare function importXlsx(file: {
+    size: number;
+    arrayBuffer(): Promise<ArrayBuffer>;
+}): Promise<XlsxImport>;
+export declare function exportXlsx(raw: WorkbookDocument): Promise<Uint8Array<ArrayBuffer>>;

package/dist/types/engine/wui/core/dialog.d.ts

@@ -0,0 +1,5 @@
+export declare function focusableWithin(container: HTMLElement): HTMLElement[];
+export declare function trapTab(container: HTMLElement, event: KeyboardEvent): boolean;
+export declare function lockScroll(): {
+    release: () => void;
+};

package/dist/types/engine/wui/core/listbox.d.ts

@@ -0,0 +1,8 @@
+export interface WuiOption {
+    value: unknown;
+    label: string;
+    disabled?: boolean;
+}
+export declare function moveActive(current: number, count: number, step: 1 | -1, isDisabled?: (index: number) => boolean): number;
+export declare function filterOptions(options: readonly WuiOption[], query: string): WuiOption[];
+export declare function optionLabel(options: readonly WuiOption[], value: unknown, fallback?: string): string;

package/dist/types/engine/wui/core/placement.d.ts

@@ -0,0 +1,40 @@
+export type WuiPlacement = 'bottom' | 'top' | 'left' | 'right' | 'bl' | 'br' | 'tl' | 'tr';
+export interface WuiRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface WuiSize {
+    width: number;
+    height: number;
+}
+export interface WuiViewport {
+    width: number;
+    height: number;
+}
+export interface WuiPlaced {
+    left: number;
+    top: number;
+    side: 'top' | 'bottom' | 'left' | 'right';
+    arrow: number;
+    arrowShift: number;
+}
+interface Alignment {
+    side: 'top' | 'bottom' | 'left' | 'right';
+    align: 'start' | 'center' | 'end';
+}
+export declare function resolvePlacement(position: WuiPlacement | undefined): Alignment;
+export declare function placePanel(input: {
+    trigger: WuiRect;
+    panel: WuiSize;
+    position?: WuiPlacement;
+    gap?: number;
+    margin?: number;
+    viewport: WuiViewport;
+    point?: {
+        x: number;
+        y: number;
+    };
+}): WuiPlaced;
+export {};

package/dist/types/hooks.d.ts

@@ -0,0 +1,7 @@
+export declare function useLatest<T>(value: T): import("react").RefObject<T>;
+export declare function useReady(): {
+    markReady: () => void;
+    isReady: () => boolean;
+    whenReady: () => Promise<void>;
+};
+export declare function asError(error: unknown): Error;

package/dist/types/host-types.d.ts

@@ -0,0 +1,58 @@
+import type { CommentItem } from 'wendang/types';
+export type AttachmentFetcher = (id: string) => Promise<Blob>;
+export interface ReferenceCandidate {
+    id: string;
+    title: string;
+}
+export interface ContentHost {
+    scope?: string;
+    attachments?: {
+        fetch: AttachmentFetcher;
+        uploadImage?: (file: File) => Promise<{
+            id: string;
+            alt: string;
+        }>;
+        uploadFile?: (file: File) => Promise<{
+            id: string;
+            filename: string;
+            mimeType: string;
+            size: number;
+        }>;
+    };
+    references?: {
+        search: (query: string, context: {
+            spaceId?: string;
+            excludeId?: string;
+        }) => Promise<ReferenceCandidate[]>;
+        resolve: (id: string, label: string) => {
+            href?: string;
+            external?: boolean;
+        } | null;
+        navigate?: (href: string) => void | Promise<unknown>;
+    };
+    location?: {
+        current: () => string;
+        subscribe: (listener: () => void) => () => void;
+        createLink?: (target: {
+            blockId: string;
+            topicId: string;
+        }) => string | null;
+    };
+    preferences?: {
+        get: (key: string) => string | null;
+        set: (key: string, value: string) => void;
+    };
+    comments?: {
+        list: (resourceId: string) => Promise<{
+            items: CommentItem[];
+        }>;
+        create: (resourceId: string, body: string, parentId?: string, target?: {
+            blockId: string;
+            topicId: string;
+        }) => Promise<unknown>;
+        update?: (commentId: string, body: string) => Promise<unknown>;
+        resolve: (commentId: string, resolved: boolean) => Promise<unknown>;
+        remove: (commentId: string) => Promise<unknown>;
+    };
+}
+export declare const unavailableAttachment: AttachmentFetcher;

package/dist/types/host.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from 'react';
+import type { ContentHost } from './host-types';
+import './styles.css';
+export interface ContentContext {
+    host: ContentHost;
+    theme: 'light' | 'dark';
+    accent: string;
+    portal: HTMLElement | null;
+}
+export declare function useContentContext(): ContentContext;
+export declare function useContentHost(): ContentHost;
+export declare function ContentContextBridge({ value, children }: {
+    value: ContentContext;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export interface ContentProviderProps {
+    host?: ContentHost;
+    theme?: 'light' | 'dark';
+    accent?: string;
+    unstyled?: boolean;
+    children?: ReactNode;
+    className?: string;
+}
+export declare function ContentProvider({ host, theme, accent, unstyled, children, className }: ContentProviderProps): import("react").JSX.Element;

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export { ContentProvider, useContentContext, useContentHost } from './host';
+export type { ContentProviderProps } from './host';
+export type { ContentHost, AttachmentFetcher, ReferenceCandidate } from './host-types';
+export { unavailableAttachment } from './host-types';
+export type * from 'wendang/types';

package/dist/types/mindmap/Comments.d.ts

@@ -0,0 +1,9 @@
+export declare function MindMapComments({ pageId, blockId, topicId, topicLabel, canComment, onClose, onChanged }: {
+    pageId: string;
+    blockId: string;
+    topicId: string;
+    topicLabel: string;
+    canComment?: boolean;
+    onClose: () => void;
+    onChanged?: () => void;
+}): import("react").JSX.Element;

package/dist/types/mindmap/Details.d.ts

@@ -0,0 +1,13 @@
+import type { MindMapModel } from 'wendang/mindmap';
+import type { MindMapController } from '../engine/editor/mind-map-controller';
+export declare function MindMapDetails({ model, id, controller, range, onClose, onNotice }: {
+    model: MindMapModel;
+    id: string;
+    controller?: MindMapController;
+    range: {
+        from: number;
+        to: number;
+    };
+    onClose: () => void;
+    onNotice?: (message: string) => void;
+}): import("react").JSX.Element | null;

package/dist/types/mindmap/Field.d.ts

@@ -0,0 +1,10 @@
+import type { MindMapController } from '../engine/editor/mind-map-controller';
+export declare function MindMapField({ id, field, value, controller, label, onFocus, onCommand }: {
+    id: string;
+    field: 'title' | 'description' | 'note';
+    value: string;
+    controller?: MindMapController;
+    label: string;
+    onFocus?: () => void;
+    onCommand?: (event: React.KeyboardEvent<HTMLTextAreaElement>) => void;
+}): import("react").JSX.Element;

package/dist/types/mindmap/MindMapCanvas.d.ts

@@ -0,0 +1,19 @@
+import { type MindMapModel } from 'wendang/mindmap';
+import { type MindMapController } from '../engine/editor/mind-map-controller';
+import '../engine/shared/mind-topic-text';
+import type { AttachmentFetcher } from '../host-types';
+export interface MindMapCanvasProps {
+    model: MindMapModel;
+    controller?: MindMapController;
+    allowExport?: boolean;
+    showSaveHint?: boolean;
+    saveStatus?: string;
+    pageId?: string;
+    canComment?: boolean;
+    openComments?: boolean;
+    onClose?: () => void;
+    onCommentsChanged?: () => void;
+    fetchAttachment?: AttachmentFetcher;
+    inline?: boolean;
+}
+export declare function MindMapCanvas(props: MindMapCanvasProps): import("react").JSX.Element;

package/dist/types/mindmap/MindMapEditor.d.ts

@@ -0,0 +1,30 @@
+import { type MindMapJson } from 'wendang/mindmap';
+import type { Awareness } from 'y-protocols/awareness';
+import type { MindMapViewState } from 'wendang/mindmap';
+export interface MindMapEditorProps {
+    value?: MindMapJson;
+    defaultValue?: MindMapJson;
+    disabled?: boolean;
+    allowExport?: boolean;
+    resourceId?: string;
+    canComment?: boolean;
+    saveStatus?: string;
+    showSaveHint?: boolean;
+    openComments?: boolean;
+    collabAwareness?: Awareness | null;
+    viewState?: MindMapViewState;
+    onCommentsChanged?: () => void;
+    onChange?: (value: MindMapJson) => void;
+    onReady?: () => void;
+    onError?: (error: Error) => void;
+}
+export interface MindMapEditorHandle {
+    isReady: () => boolean;
+    whenReady: () => Promise<void>;
+    getSnapshot: () => MindMapJson;
+    prepareSnapshot: () => Promise<MindMapJson>;
+    undo: () => boolean;
+    redo: () => boolean;
+    focus: () => void;
+}
+export declare const MindMapEditor: import("react").ForwardRefExoticComponent<MindMapEditorProps & import("react").RefAttributes<MindMapEditorHandle>>;

package/dist/types/mindmap/MindMapViewer.d.ts

@@ -0,0 +1,23 @@
+import { type MindMapJson, type MindMapModel } from 'wendang/mindmap';
+import type { MindMapController } from '../engine/editor/mind-map-controller';
+import type { AttachmentFetcher } from '../host-types';
+import '../engine/shared/mind-topic-text';
+export interface MindMapViewerProps {
+    value?: MindMapModel;
+    modelValue?: MindMapModel;
+    height?: number;
+    fetchAttachment?: AttachmentFetcher;
+}
+export declare function MindMapViewer({ value, modelValue, height, fetchAttachment }: MindMapViewerProps): import("react").JSX.Element;
+export interface MindMapBlockProps {
+    node?: MindMapJson;
+    value?: MindMapJson;
+    modelValue?: MindMapJson;
+    allowExport?: boolean;
+    pageId?: string;
+    canComment?: boolean;
+    onCommentsChanged?: () => void;
+    fetchAttachment?: AttachmentFetcher;
+    controller?: MindMapController;
+}
+export declare function MindMapBlock(props: MindMapBlockProps): import("react").JSX.Element;

package/dist/types/mindmap/TopicLabel.d.ts

@@ -0,0 +1,4 @@
+import type { MindTopic } from 'wendang/mindmap';
+export declare function TopicLabel({ topic }: {
+    topic: MindTopic;
+}): import("react").JSX.Element;

package/dist/types/mindmap/viewer.d.ts

@@ -0,0 +1,2 @@
+export { MindMapViewer, MindMapBlock } from './MindMapViewer';
+export type { MindMapViewerProps, MindMapBlockProps } from './MindMapViewer';

package/dist/types/mindmap.d.ts

@@ -0,0 +1,4 @@
+export { MindMapEditor } from './mindmap/MindMapEditor';
+export type { MindMapEditorProps, MindMapEditorHandle } from './mindmap/MindMapEditor';
+export { createMindMapController } from './engine/editor/mind-map-controller';
+export type { MindMapController, MindMapContext } from './engine/editor/mind-map-controller';

package/dist/types/renderer/CodeToolbar.d.ts

@@ -0,0 +1,10 @@
+import { type CodeBlockDisplay } from '../engine/shared/code-block';
+export declare function CodeToolbar({ text, language, editable, canCopy, display, onLanguage, onDisplay }: {
+    text: string;
+    language: string;
+    editable: boolean;
+    canCopy: boolean;
+    display: CodeBlockDisplay;
+    onLanguage: (value: string) => void;
+    onDisplay: (value: CodeBlockDisplay) => void;
+}): import("react").JSX.Element;

package/dist/types/renderer/DocumentViewer.d.ts

@@ -0,0 +1,23 @@
+import type { ProseMirrorNode, CommentItem } from 'wendang/types';
+import { type InlineMark } from 'wendang/shared';
+import type { AttachmentFetcher } from '../host-types';
+export interface DocumentViewerProps {
+    value?: ProseMirrorNode | null;
+    modelValue?: ProseMirrorNode | null;
+    inlineComments?: CommentItem[];
+    inlineMarks?: Map<number, InlineMark[]>;
+    activeCommentId?: string | null;
+    onMarkClick?: (id: string) => void;
+    attachmentFetcher?: AttachmentFetcher;
+    resolvePageLink?: (id: string, label: string) => {
+        href?: string;
+        external?: boolean;
+    } | null;
+    pageId?: string;
+    spaceId?: string;
+    canComment?: boolean;
+    allowExport?: boolean;
+    onCommentsChanged?: () => void;
+}
+export declare function DocumentViewer(props: DocumentViewerProps): import("react").JSX.Element;
+export declare const DocRenderer: typeof DocumentViewer;

package/dist/types/renderer/media.d.ts

@@ -0,0 +1,33 @@
+import { type AttachmentFetcher } from '../host-types';
+export declare function useAttachment(id?: string, fetcher?: AttachmentFetcher): {
+    url: string;
+    error: string;
+};
+export declare function AttachmentImage({ id, alt, width, fetcher, src, align, aspectRatio, galleryScale, className }: {
+    id?: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+    fetcher?: AttachmentFetcher;
+    src?: string;
+    allowExport?: boolean;
+    align?: 'left' | 'center' | 'right' | null;
+    aspectRatio?: number | null;
+    galleryScale?: number | null;
+    className?: string;
+}): import("react").JSX.Element;
+export declare function MathView({ latex, block }: {
+    latex: string;
+    block?: boolean;
+}): import("react").JSX.Element;
+export declare function FileView({ id, filename, mimeType, size, fetcher, allowExport }: {
+    id: string;
+    filename: string;
+    mimeType?: string;
+    size?: number;
+    fetcher?: AttachmentFetcher;
+    allowExport?: boolean;
+}): import("react").JSX.Element;
+export declare function VideoView({ attrs }: {
+    attrs: Record<string, unknown>;
+}): import("react").JSX.Element;

package/dist/types/shared.d.ts

@@ -0,0 +1,12 @@
+export * from 'wendang/shared';
+export * from './engine/shared/code-block';
+export * from './engine/shared/code-highlight';
+export * from './engine/shared/code-highlight-engine';
+export * from './engine/shared/fuzzy-match';
+export * from './engine/shared/inline-comments';
+export * from './engine/shared/modal-stack';
+export * from './engine/shared/pinyin';
+export * from './engine/editor/ime/composition-state';
+export * from './engine/editor/popover-placement';
+export * from './engine/editor/mind-map-input';
+export * from './engine/editor/mind-map-delete';

package/dist/types/spreadsheet/SpreadsheetEditor.d.ts

@@ -0,0 +1,23 @@
+import { type WorkbookDocument } from 'wendang/spreadsheet';
+export interface SpreadsheetEditorProps {
+    value?: WorkbookDocument;
+    defaultValue?: WorkbookDocument;
+    disabled?: boolean;
+    theme?: 'light' | 'dark';
+    onChange?: (value: WorkbookDocument) => void;
+    onReady?: () => void;
+    onError?: (error: Error) => void;
+}
+export interface SpreadsheetEditorHandle {
+    isReady: () => boolean;
+    whenReady: () => Promise<void>;
+    getSnapshot: () => WorkbookDocument;
+    snapshot: () => WorkbookDocument;
+    prepareSnapshot: () => Promise<WorkbookDocument>;
+    isEditing: () => boolean;
+    finishEditing: () => Promise<void>;
+    settleCalculation: () => Promise<void>;
+    replace: (value: WorkbookDocument) => void;
+    dispose: () => void;
+}
+export declare const SpreadsheetEditor: import("react").ForwardRefExoticComponent<SpreadsheetEditorProps & import("react").RefAttributes<SpreadsheetEditorHandle>>;

package/dist/types/spreadsheet/SpreadsheetViewer.d.ts

@@ -0,0 +1,13 @@
+import { type WorkbookDocument } from 'wendang/spreadsheet';
+export interface SpreadsheetViewerProps {
+    value?: WorkbookDocument;
+    modelValue?: WorkbookDocument;
+    allowExport?: boolean;
+    standalone?: boolean;
+    pageId?: string;
+    exportSnapshot?: () => Promise<{
+        title: string;
+        doc: WorkbookDocument;
+    }>;
+}
+export declare function SpreadsheetViewer({ value, modelValue, allowExport, standalone, exportSnapshot }: SpreadsheetViewerProps): import("react").JSX.Element;

package/dist/types/spreadsheet/viewer.d.ts

@@ -0,0 +1,2 @@
+export { SpreadsheetViewer } from './SpreadsheetViewer';
+export type { SpreadsheetViewerProps } from './SpreadsheetViewer';

package/dist/types/spreadsheet/xlsx.d.ts

@@ -0,0 +1,2 @@
+export { importXlsx, exportXlsx } from '../engine/worksheets/worksheet-xlsx';
+export type { XlsxInspection, XlsxImport } from '../engine/worksheets/worksheet-xlsx';

package/dist/types/spreadsheet.d.ts

@@ -0,0 +1,3 @@
+export { SpreadsheetEditor } from './spreadsheet/SpreadsheetEditor';
+export type { SpreadsheetEditorHandle, SpreadsheetEditorProps } from './spreadsheet/SpreadsheetEditor';
+export type { WorkbookDocument } from 'wendang/spreadsheet';

package/dist/types/wui/AnchoredPanel.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from 'react';
+export declare function AnchoredPanel({ anchor, onClose, align, prefer, gap, label, role, className, portal: portalOverride, children, onKeyDown }: {
+    anchor: HTMLElement | null;
+    onClose: () => void;
+    align?: 'start' | 'center' | 'end';
+    prefer?: 'above' | 'below';
+    gap?: number;
+    label?: string;
+    role?: 'dialog' | 'menu' | 'listbox' | 'tooltip';
+    onKeyDown?: React.KeyboardEventHandler<HTMLDivElement>;
+    className?: string;
+    portal?: HTMLElement | null | (() => HTMLElement | null);
+    children: ReactNode;
+}): import("react").JSX.Element | null;

package/dist/types/wui/Dropdown.d.ts

@@ -0,0 +1,18 @@
+import { type ReactNode } from 'react';
+import { type WButtonProps } from './index';
+export interface DropdownItem {
+    value: string;
+    label: ReactNode;
+    disabled?: boolean;
+    shortcut?: string;
+}
+export interface DropdownGroup {
+    title?: string;
+    items: DropdownItem[];
+}
+export declare function WDropdown({ label, groups, onSelect, buttonProps }: {
+    label: ReactNode;
+    groups: DropdownGroup[];
+    onSelect: (value: string) => void;
+    buttonProps?: WButtonProps;
+}): import("react").JSX.Element;

package/dist/types/wui/Icon.d.ts

@@ -0,0 +1,7 @@
+import { type CSSProperties } from 'react';
+export declare function WIcon({ name, size, className, style }: {
+    name: string;
+    size?: number;
+    className?: string;
+    style?: CSSProperties;
+}): import("react").ReactSVGElement | null;

package/dist/types/wui/Tooltip.d.ts

@@ -0,0 +1,5 @@
+import { type ReactNode } from 'react';
+export declare function WTooltip({ children, content }: {
+    children: ReactNode;
+    content: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/wui/index.d.ts

@@ -0,0 +1,69 @@
+import { type ButtonHTMLAttributes, type ReactNode } from 'react';
+import { WIcon } from './Icon';
+export { WIcon };
+type Variant = 'default' | 'text' | 'primary' | 'outline';
+type Size = 'mini' | 'small' | 'medium';
+export interface WButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'type'> {
+    variant?: Variant;
+    size?: Size;
+    narrow?: boolean;
+    block?: boolean;
+    loading?: boolean;
+    htmlType?: 'button' | 'submit' | 'reset';
+    icon?: ReactNode;
+}
+export declare const WButton: import("react").ForwardRefExoticComponent<WButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare function WAlert({ children, closable, closeLabel, onClose, tone, className }: {
+    children: ReactNode;
+    closable?: boolean;
+    closeLabel?: string;
+    onClose?: () => void;
+    tone?: 'info' | 'success' | 'warning' | 'danger';
+    className?: string;
+}): import("react").JSX.Element | null;
+interface Layer {
+    contains: (target: Node) => boolean;
+    children: Set<Layer>;
+}
+export declare function LayerProvider({ layer, children }: {
+    layer: Layer;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useLayer(anchor: React.RefObject<HTMLElement | null>, panel: React.RefObject<HTMLElement | null>, open: boolean, onClose: () => void): Layer;
+export declare function WPopover({ label, children, onClose, align, ariaLabel, disabled }: {
+    label?: ReactNode;
+    children: ReactNode;
+    onClose?: () => void;
+    align?: 'start' | 'end';
+    ariaLabel?: string;
+    disabled?: boolean;
+}): import("react").JSX.Element;
+export interface WSelectOption {
+    value: string | number;
+    label: string;
+    disabled?: boolean;
+}
+export declare function WSelect({ label, ariaLabel, value, onChange, options, disabled, size, searchable, width, className }: {
+    label?: string;
+    ariaLabel?: string;
+    value: string | number;
+    onChange: (value: string) => void;
+    options: WSelectOption[];
+    disabled?: boolean;
+    size?: Size;
+    searchable?: boolean;
+    width?: number | string;
+    className?: string;
+}): import("react").JSX.Element;
+export declare function WDialog({ title, children, onClose, fullscreen, hideFooter, footer, workspace, className, ariaLabel, escToClose }: {
+    title: ReactNode;
+    children: ReactNode;
+    onClose: () => void;
+    fullscreen?: boolean;
+    hideFooter?: boolean;
+    footer?: ReactNode;
+    workspace?: boolean;
+    className?: string;
+    ariaLabel?: string;
+    escToClose?: boolean;
+}): import("react").JSX.Element | null;