@mirohq/websdk-types/index.d.ts

Provides typing for the Miro WebSDK v2.

declare module "@mirohq/websdk-types/core/symbols" {
    export const EventManagerSymbol: unique symbol;
    export const CommanderSymbol: unique symbol;
}
declare module "@mirohq/websdk-types/core/commander" {
    export type Command<T = unknown> = {
        name: string;
        payload?: T;
        id: string;
    };
    export enum CommandStatus {
        Success = "S",
        Fail = "F"
    }
    export type RemoteCommand<T = unknown> = {
        id: string;
        payload: T;
        status?: CommandStatus;
    };
    export type RemoteCommandHandler = (command: RemoteCommand) => Promise<unknown>;
    export interface Commander<AllowedCommandTypes extends string> {
        exec<ReturnType = unknown, PayloadType = unknown>(commandName: AllowedCommandTypes, payload?: PayloadType): Promise<ReturnType>;
        subscribe(event: string, handler: RemoteCommandHandler): void;
        unsubscribe(event: string, handler: RemoteCommandHandler): void;
        hasEventSubscriptions(event: string): boolean;
    }
}
declare module "@mirohq/websdk-types/core/features/sensors" {
    export type DraggableElement = HTMLElement;
    export type SensorEventType = 'drag' | 'drop' | 'dragend' | 'dragstart';
    export type SensorEvent = CustomEvent<{
        readonly target: HTMLElement;
        readonly clientX: number;
        readonly clientY: number;
        readonly screenX: number;
        readonly screenY: number;
    }>;
    export interface Sensor {
        addListener(event: SensorEventType, handler: (event: SensorEvent) => void): void;
        removeListener(event: SensorEventType, handler?: (event: SensorEvent) => void): void;
        resetDragging(): void;
    }
    class BaseDragSensor {
        listeners: {
            type: SensorEventType;
            selector: string;
            handler: (event: SensorEvent) => void;
        }[];
        private originalBodyStyle;
        private dragStartPosition;
        private static DRAG_THRESHOLD;
        protected setDragStartPosition(x: number, y: number): void;
        protected shouldDispatchDrag(x: number, y: number): boolean;
        resetDragging(): void;
        addListener(type: SensorEventType, selector: string, handler: (event: SensorEvent) => void): void;
        removeListener(type: SensorEventType, selector?: string, handler?: (event: SensorEvent) => void): void;
        protected isDraggableElement(element: EventTarget | null): element is DraggableElement;
        protected disableClickEvents(): void;
        protected restoreClickEvents(): void;
        protected dragEnd(target: HTMLElement): void;
        protected dispatch(type: SensorEventType, params: SensorEvent['detail']): void;
    }
    class MouseDragSensor extends BaseDragSensor {
        private target;
        private isDragging;
        constructor();
        private onMouseDown;
        private onMouseMove;
        private onMouseUp;
        resetDragging: () => void;
    }
    class TouchDragSensor extends BaseDragSensor {
        private tapTimeout;
        private target;
        constructor();
        private onTouchStart;
        private onTouchMove;
        private onTouchEnd;
        private startDragging;
        resetDragging: () => void;
    }
    export class DragSensor implements Sensor {
        selector: string;
        touchSensor: TouchDragSensor;
        mouseSensor: MouseDragSensor;
        constructor(props: {
            selector: string;
        });
        addListener(event: SensorEventType, handler: (event: SensorEvent) => void): void;
        removeListener(event: SensorEventType, handler?: (event: SensorEvent) => void): void;
        reset(): void;
        resetDragging(): void;
    }
}
declare module "@mirohq/websdk-types/core/features/dragAndDrop" {
    import { Commander } from "@mirohq/websdk-types/core/commander";
    export type DropEvent = {
        x: number;
        y: number;
        target: HTMLElement;
    };
    export type DropEventListener = (event: DropEvent) => void;
    export const initDragSensor: () => void;
    export const resetDragSensor: () => void;
    export function attachDragAndDropListeners(commander: Commander<string>, handler: DropEventListener): Promise<void>;
    export function detachDragAndDropListeners(commander: Commander<string>, handler: DropEventListener): Promise<void>;
}
declare module "@mirohq/websdk-types/core/utils" {
    export type DeepPartial<T> = {
        [P in keyof T]?: DeepPartial<T[P]>;
    };
    export function keys<O extends Record<string, any>>(o: O): (keyof O)[];
    export function mergeDeep(target: any, ...sources: any[]): Record<string, unknown>;
    export function asProps<T extends object>(item: T): Record<string, unknown>;
    export function omit<TItem, TKey extends keyof TItem>(item: TItem, key: TKey): Omit<TItem, TKey>;
    export function normalizeDataUrl(dataUrl: string): string;
    export function dataURLToBlob(dataURL: string): Blob;
    export const blobToDataUrl: (blobData: Blob) => Promise<string>;
    export function generateId(): string;
    export function isTransferableObject(obj: unknown): obj is Transferable;
    export function getTransferable(payload: unknown): Promise<Transferable[]>;
}
declare module "@mirohq/websdk-types/core/SdkPostMessageBus" {
    import { Command } from "@mirohq/websdk-types/core/commander";
    export const COMMAND_ID = "sdkv2-plugin-message";
    export interface SdkCommandMessage<CommandType = Command> {
        commandId?: string;
        payload: CommandType[];
        msgId: string;
    }
    export type WindowGetter = () => Window;
    export class SdkPostMessageBus {
        private hostWindow;
        private clientOrigin;
        private messageHandler;
        private windowGetter;
        private waiting;
        constructor(hostWindow: Window, clientOrigin: string, messageHandler: (commands: unknown) => Promise<unknown[]>, windowGetter: WindowGetter);
        init(): void;
        destroy(): void;
        private handlePostMessage;
        dispatch(payload: unknown, messageId?: string | undefined): Promise<unknown>;
    }
}
declare module "@mirohq/websdk-types/core/iframeCommander" {
    import { Commander, RemoteCommandHandler } from "@mirohq/websdk-types/core/commander";
    export class IframeCommander implements Commander<string> {
        private prefix?;
        private bus;
        private waitingResponse;
        private handlers;
        constructor(clientWindow: Window, prefix?: string | undefined);
        destroy(): void;
        exec<ReturnType, PayloadType>(commandName: string, payload?: PayloadType): Promise<ReturnType>;
        private responseHandler;
        handle: (message: unknown) => Promise<unknown[]>;
        subscribe(event: string, handler: RemoteCommandHandler): void;
        unsubscribe(event: string, handler: RemoteCommandHandler): void;
        hasEventSubscriptions(event: string): boolean;
    }
}
declare module "@mirohq/websdk-types/core/commanderProxy" {
    import { Commander, RemoteCommandHandler } from "@mirohq/websdk-types/core/commander";
    export class CommanderProxy implements Commander<string> {
        private realCommander;
        private prefix;
        constructor(realCommander: Commander<string>, prefix: string);
        exec<ReturnType, PayloadType>(commandName: string, payload?: PayloadType | undefined): Promise<ReturnType>;
        subscribe(event: string, handler: RemoteCommandHandler): void;
        unsubscribe(event: string, handler: RemoteCommandHandler): void;
        hasEventSubscriptions(event: string): boolean;
    }
}
declare module "@mirohq/websdk-types/core/privateField" {
    export const setPrivateField: <Obj, Value>(object: Obj, field: PropertyKey, value: Value) => void;
}
declare module "@mirohq/websdk-types/core/index" {
    export type { Commander, Command, RemoteCommand, RemoteCommandHandler } from "@mirohq/websdk-types/core/commander";
    export { CommandStatus } from "@mirohq/websdk-types/core/commander";
    export { IframeCommander } from "@mirohq/websdk-types/core/iframeCommander";
    export { CommanderProxy } from "@mirohq/websdk-types/core/commanderProxy";
    export { generateId, isTransferableObject, getTransferable } from "@mirohq/websdk-types/core/utils";
    export { setPrivateField } from "@mirohq/websdk-types/core/privateField";
    export { SdkPostMessageBus, COMMAND_ID } from "@mirohq/websdk-types/core/SdkPostMessageBus";
    export type { SdkCommandMessage } from "@mirohq/websdk-types/core/SdkPostMessageBus";
}
declare module "@mirohq/websdk-types/core/builder/symbols" {
    export const ContextSymbol: unique symbol;
}
declare module "@mirohq/websdk-types/core/builder/utils/queries" {
    import { GetFilter } from "@mirohq/websdk-types/core/api/common";
    import { BaseItem, Context } from "@mirohq/websdk-types/core/builder/types";
    export const getItems: (ctx: Context, filter: GetFilter | undefined) => Promise<BaseItem[]>;
}
declare module "@mirohq/websdk-types/core/api/data" {
    import { Json } from "@mirohq/websdk-types/core/api/common";
    export type AppDataValue = Json;
    export type AppData = Record<string, AppDataValue>;
    export type ItemMetadata = AppData;
    export type ItemMetadataValue = AppDataValue;
}
declare module "@mirohq/websdk-types/core/features/widgets/connector" {
    import { ContextSymbol } from "@mirohq/websdk-types/core/builder/symbols";
    import { Context, ItemProps } from "@mirohq/websdk-types/core/builder/types";
    import { Origin, RelativeTo, StrokeCapShape, StrokeStyle, TextAlignVertical, TextOrientation } from "@mirohq/websdk-types/core/api/common";
    import { AppData, AppDataValue } from "@mirohq/websdk-types/core/api/data";
    export type SnapToValues = 'auto' | 'top' | 'left' | 'bottom' | 'right';
    export type Endpoint = {
        item?: string;
        position?: {
            x: number;
            y: number;
        };
        snapTo?: SnapToValues;
    };
    export type ConnectorShape = 'straight' | 'elbowed' | 'curved';
    export type ConnectorStyle = {
        startStrokeCap?: StrokeCapShape;
        endStrokeCap?: StrokeCapShape;
        strokeStyle?: StrokeStyle;
        strokeWidth?: number;
        strokeColor?: string;
        fontSize?: number;
        color?: string;
        textOrientation?: TextOrientation;
    };
    export type ConnectorCaption = {
        content?: string;
        position?: number;
        textAlignVertical?: TextAlignVertical;
    };
    export class Connector {
        readonly type: "connector";
        readonly id: string;
        origin: Origin;
        relativeTo: RelativeTo;
        readonly parentId: string | null;
        readonly groupId?: string;
        readonly createdAt: string;
        readonly createdBy: string;
        readonly modifiedAt: string;
        readonly modifiedBy: string;
        readonly width: number;
        readonly height: number;
        shape: ConnectorShape;
        start?: Endpoint;
        end?: Endpoint;
        style: ConnectorStyle;
        captions?: ConnectorCaption[];
        protected [ContextSymbol]: Context<string>;
        constructor(ctx: Context<string>, props: ItemProps<Connector>);
        sync(): Promise<void>;
        getMetadata(): Promise<AppData>;
        getMetadata<T extends AppDataValue>(key: string): Promise<T>;
        setMetadata<T extends AppData>(key: string, value: AppDataValue): Promise<T>;
    }
}
declare module "@mirohq/websdk-types/core/features/widgets/base" {
    import { Context, ItemProps } from "@mirohq/websdk-types/core/builder/types";
    import { ContextSymbol } from "@mirohq/websdk-types/core/builder/symbols";
    import { Origin, RelativeTo } from "@mirohq/websdk-types/core/api/common";
    import { AppData, AppDataValue } from "@mirohq/websdk-types/core/api/data";
    import type { Connector } from "@mirohq/websdk-types/core/features/widgets/connector";
    export abstract class BaseItem {
        abstract type: string;
        readonly id: string;
        origin: Origin;
        relativeTo: RelativeTo;
        linkedTo?: string | undefined;
        readonly connectorIds?: string[];
        readonly parentId: string | null;
        readonly groupId?: string;
        readonly createdAt: string;
        readonly createdBy: string;
        readonly modifiedAt: string;
        readonly modifiedBy: string;
        x: number;
        y: number;
        protected [ContextSymbol]: Context<string>;
        constructor(ctx: Context<string>, _props?: ItemProps<BaseItem>);
        sync(): Promise<void>;
        getMetadata(): Promise<AppData>;
        getMetadata<T extends AppDataValue>(key: string): Promise<T>;
        setMetadata<T extends AppData>(key: string, value: AppDataValue): Promise<T>;
        goToLink(): Promise<boolean>;
        bringToFront(): Promise<void>;
        sendToBack(): Promise<void>;
        bringInFrontOf(target: BaseItem): Promise<void>;
        sendBehindOf(target: BaseItem): Promise<void>;
        getLayerIndex(): Promise<number>;
        getConnectors(): Promise<Connector[]>;
    }
}
declare module "@mirohq/websdk-types/core/features/widgets/unsupported" {
    import type { Context, ItemProps } from "@mirohq/websdk-types/core/builder/types";
    import { BaseItem } from "@mirohq/websdk-types/core/features/widgets/base";
    export class Unsupported extends BaseItem {
        readonly type: string;
        readonly width: number;
        readonly height: number;
        constructor(ctx: Context, props: ItemProps<Unsupported>);
    }
}
declare module "@mirohq/websdk-types/core/builder/types" {
    import type { Commander } from "@mirohq/websdk-types/core/commander";
    import type { GetFilter } from "@mirohq/websdk-types/core/api/common";
    import type { Unsupported } from "@mirohq/websdk-types/core/features/widgets/unsupported";
    export type GenericObject = {};
    export type Identity<T> = T extends object ? GenericObject & {
        [P in keyof T]: T[P];
    } : T;
    export type BaseItem = {
        id: string;
        readonly type: string;
    };
    export type MethodKeys<T> = {
        [K in keyof T]: T[K] extends Function ? K : never;
    }[keyof T];
    export type DeepPartial<T> = {
        [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : DeepPartial<T[P]>;
    };
    export type FlattenUnion<T> = T extends infer U ? (U extends any ? U : never) : never;
    export type ItemProps<T extends {
        readonly type: string;
    }> = Identity<DeepPartial<Omit<T, MethodKeys<T>>>>;
    export type ItemsProps<T extends {
        readonly type: string;
    }> = T extends {
        readonly type: string;
    } ? ItemProps<T> : never;
    export type ItemsWithField<T extends {
        readonly type: string;
    }, K extends string> = T extends {
        [Key in K]?: any;
    } ? T : never;
    export type CamelCase<S extends string> = S extends `${infer First}_${infer Rest}` ? `${Capitalize<First>}${CamelCase<Rest>}` : Capitalize<S>;
    export type QueryFilter<Item extends BaseItem> = {
        type?: Item['type'] | Item['type'][];
    } | GetFilter;
    export type QueryReturn<Item extends BaseItem, F extends QueryFilter<Item>> = F extends {
        type: infer Type;
    } ? Type extends Item['type'][] ? Extract<Item, {
        type: Type[number];
    }>[] : Type extends Item['type'] ? Extract<Item, {
        type: Type;
    }>[] : (Item | Unsupported)[] : (Item | Unsupported)[];
    export type BaseFeature<Item extends BaseItem> = {
        get<F extends QueryFilter<Item>>(filter?: F): Promise<QueryReturn<Item, F>>;
        getById(id: string): Promise<Item | Unsupported>;
        getSelection(): Promise<(Item | Unsupported)[]>;
        select<F extends QueryFilter<Item>>(filter?: F): Promise<QueryReturn<Item, F>>;
        deselect<F extends QueryFilter<Item>>(filter?: F): Promise<QueryReturn<Item, F>>;
    };
    export type SdkClient<Item extends BaseItem, Definition extends GenericObject> = Definition extends BaseFeature<Item> ? Identity<BaseFeature<Item> & Omit<Definition, keyof BaseFeature<Item>>> : Definition;
    export type SdkClientFeature<CmdTypes extends string = string, Item extends BaseItem = BaseItem, FeatureDefinition extends GenericObject = GenericObject> = (ctx: Context<CmdTypes, Item>) => FeatureDefinition;
    export type Context<CmdTypes extends string = string, Item extends BaseItem = BaseItem> = {
        convert: (props: ItemProps<BaseItem>) => Item | BaseItem;
        commander: Commander<CmdTypes>;
    };
    export type ItemConstructor<Item extends BaseItem, CmdTypes extends string, CreateProps> = CreateProps extends ItemProps<Item> ? new (context: Context<CmdTypes, BaseItem>, props: CreateProps) => Item : never;
    export type ItemCreator<Item extends BaseItem, CmdTypes extends string, CreateProps> = {
        constructor: ItemConstructor<Item, CmdTypes, ItemProps<Item>>;
        create: (context: Context<CmdTypes, BaseItem>, props: CreateProps) => Promise<Item>;
    };
    export type ItemDeclaration<Item extends BaseItem, CmdTypes extends string = string, CreateProps = Item> = ItemConstructor<Item, CmdTypes, CreateProps> | ItemCreator<Item, CmdTypes, CreateProps>;
    export type SdkClientBuilder<CmdTypes extends string, Item extends BaseItem, Definition extends GenericObject> = {
        widget: <NewItem extends BaseItem, NewCreateProps = NewItem>(key: NewItem['type'], declaration: ItemDeclaration<NewItem, CmdTypes, NewCreateProps>) => SdkClientBuilder<CmdTypes, Exclude<Item, {
            type: NewItem['type'];
        }> | NewItem, Identity<{
            [K in NewItem as `create${CamelCase<K['type']>}`]: undefined extends NewCreateProps ? (props?: NewCreateProps) => Promise<K> : (props: NewCreateProps) => Promise<K>;
        } & Definition>>;
        use<NewDefinition extends GenericObject>(feature: SdkClientFeature<CmdTypes, Item, NewDefinition>): SdkClientBuilder<CmdTypes, Item, NewDefinition & Omit<Definition, keyof NewDefinition>>;
        getRegisteredFeatures(): SdkClientFeature<CmdTypes, Item>[];
        getRegisteredWidgets(): Map<string, unknown>;
        build: (commander: Commander<string>) => Readonly<SdkClient<Item, Definition>>;
    };
    export type InferItemFromContext<T> = T extends Context<infer _CmdTypes, infer Item> ? Item : never;
    export type InferItemFromClient<T> = T extends SdkClient<infer Item, infer _CmdType> ? Item | Unsupported : never;
    export type InferClientFromBuilderState<T> = T extends SdkClientBuilder<infer _CmdType, infer _Item, infer _Definition> ? ReturnType<T['build']> : never;
}
declare module "@mirohq/websdk-types/core/api/common" {
    import type { BaseItem, ItemProps, MethodKeys } from "@mirohq/websdk-types/core/builder/types";
    import type { BaseItem as BaseItemClass } from "@mirohq/websdk-types/core/features/widgets/base";
    export type DeepPartial<T> = {
        [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : DeepPartial<T[P]>;
    };
    export type SupportedLanguages = 'en' | 'fr' | 'de' | 'ja_JP' | 'es' | 'pt_BR';
    export type Json = string | number | boolean | null | Json[] | {
        [key: string]: Json;
    };
    export type OneOrMany<T> = T | T[];
    export type RelativeTo = 'canvas_center' | 'parent_top_left' | 'parent_center';
    export type Origin = 'center';
    export type IconShape = 'round' | 'square';
    export type TextAlign = 'left' | 'center' | 'right';
    export type TextAlignVertical = 'top' | 'middle' | 'bottom';
    export type TextOrientation = 'horizontal' | 'aligned';
    export type FontFamily = 'arial' | 'cursive' | 'abril_fatface' | 'bangers' | 'eb_garamond' | 'georgia' | 'graduate' | 'gravitas_one' | 'fredoka_one' | 'nixie_one' | 'open_sans' | 'permanent_marker' | 'pt_sans' | 'pt_sans_narrow' | 'pt_serif' | 'rammetto_one' | 'roboto' | 'roboto_condensed' | 'roboto_slab' | 'caveat' | 'times_new_roman' | 'titan_one' | 'lemon_tuesday' | 'roboto_mono' | 'noto_sans' | 'plex_sans' | 'plex_serif' | 'plex_mono' | 'spoof' | 'tiempos_text' | 'noto_serif' | 'noto_serif_jp' | 'noto_sans_jp' | 'noto_sans_hebrew' | 'noto_serif_sc' | 'noto_serif_kr' | 'noto_sans_sc' | 'noto_sans_kr' | 'serif' | 'sans_serif' | 'monospace';
    export type StrokeCapShape = 'none' | 'stealth' | 'rounded_stealth' | 'arrow' | 'filled_triangle' | 'triangle' | 'filled_diamond' | 'diamond' | 'filled_oval' | 'oval' | 'erd_one' | 'erd_many' | 'erd_one_or_many' | 'erd_only_one' | 'erd_zero_or_many' | 'erd_zero_or_one';
    export type StrokeStyle = 'normal' | 'dotted' | 'dashed';
    export type GetFilter = {
        id: string[] | string;
    } | {
        type?: string[] | string;
        tags?: string[] | string;
    };
    export type CustomEventType = `custom:${string}`;
    export type UserId = string;
    export type Rect = {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    export type Offset = {
        top: number;
        left: number;
        bottom: number;
        right: number;
    };
    export type PositionMixin = {
        x: number;
        y: number;
    };
    export type SizeMixin = {
        width: number;
        height: number;
    };
    export type SizeWithoutHeight = Omit<SizeMixin, 'height'>;
    export type RotationMixin = {
        rotation: number;
    };
    export type ContainerMixin<TItem = BaseItem> = {
        childrenIds: string[];
        add<T extends TItem>(item: T): Promise<T>;
        remove<T extends TItem>(item: T): Promise<void>;
        getChildren(): Promise<TItem[]>;
    };
    export type ModifiableMixin = {
        readonly createdAt: string;
        readonly createdBy: string;
        readonly modifiedAt: string;
        readonly modifiedBy: string;
    };
    export type WidgetMixin = BaseItemClass;
    export type Base = WidgetMixin;
    export type WidgetPropsOnly<T extends {
        readonly type: string;
    }> = Omit<T, MethodKeys<T>>;
    export type WidgetProps<T extends {
        readonly type: string;
    }> = ItemProps<T>;
}
declare module "@mirohq/websdk-types/core/features/eventManager" {
    import { Commander, RemoteCommandHandler } from "@mirohq/websdk-types/core/commander";
    export const isCustomEvent: (event: string) => event is `custom:${string}`;
    export type Listener = (...args: any[]) => void;
    export type AsyncListener = (...args: Parameters<Listener>) => Promise<ReturnType<Listener>>;
    export class EventManager<EventType extends string = string> {
        protected commander: Commander<string>;
        private subscriptionsMap;
        constructor(commander: Commander<string>);
        subscribe<External extends Listener>(event: EventType, externalHandler: External, internalHandler: RemoteCommandHandler): Promise<void>;
        unsubscribe<External extends Listener>(event: EventType, externalHandler: External): Promise<void>;
        unsubscribeAll(): Promise<unknown[]>;
        private addInternalHandler;
    }
}
declare module "@mirohq/websdk-types/stable/features/widgets/card" {
    import { Context, ItemProps } from "@mirohq/websdk-types/core/builder/types";
    import { IconShape } from "@mirohq/websdk-types/core/api/common";
    import { BaseItem } from "@mirohq/websdk-types/core/features/widgets/base";
    export type CardStyle = {
        cardTheme?: string;
        fillBackground?: boolean;
    };
    export type CardTaskStatus = 'to-do' | 'in-progress' | 'done' | 'none';
    export type CardField = {
        value?: string;
        fillColor?: string;
        textColor?: string;
        iconUrl?: string;
        iconShape?: IconShape;
        tooltip?: string;
    };
    export type CardAssignee = {
        userId: string;
    };
    export class Card extends BaseItem {
        readonly type: "card";
        width: number;
        readonly height: number;
        rotation: number;
        title: string;
        description: string;
        style: CardStyle;
        dueDate?: string;
        startDate?: string;
        assignee?: CardAssignee;
        taskStatus: CardTaskStatus;
        tagIds: string[];
        fields?: CardField[];
        constructor(ctx: Context, props?: ItemProps<Card>);
    }
}
declare module "@mirohq/websdk-types/stable/features/widgets/appCard" {
    import { Context, ItemProps } from "@mirohq/websdk-types/core/builder/types";
    import { BaseItem } from "@mirohq/websdk-types/core/features/widgets/base";
    import { CardField, CardStyle } from "@mirohq/websdk-types/stable/features/widgets/card";
    export type AppCardStatus = 'disabled' | 'disconnected' | 'connected';
    export class AppCard extends BaseItem {
        readonly type: "app_card";
        width: number;
        readonly height: number;
        readonly owned: boolean;
        rotation: number;
        title: string;
        description: string;
        style: CardStyle;
        tagIds: string[];
        status: AppCardStatus;
        fields?: CardField[];
        constructor(ctx: Context, props?: ItemProps<AppCard>);
    }
}
declare module "@mirohq/websdk-types/stable/api/widgets/appCard" {
    import type { ItemProps } from "@mirohq/websdk-types/core/builder/types";
    import type { AppCard } from "@mirohq/websdk-types/stable/features/widgets/appCard";
    export type { AppCardStatus } from "@mirohq/websdk-types/stable/features/widgets/appCard";
    export { AppCard } from "@mirohq/websdk-types/stable/features/widgets/appCard";
    export type AppCardProps = ItemProps<AppCard>;
}
declare module "@mirohq/websdk-types/stable/api/board" {
    import { SupportedLanguages } from "@mirohq/websdk-types/core/api/common";
    import { Identity } from "@mirohq/websdk-types/core/builder/types";
    export type BoardFeature = 'timer' | 'voting';
    export type BoardInfo = {
        readonly id: string;
        readonly locale: SupportedLanguages;
        readonly createdAt: string;
        readonly updatedAt: string;
    };
    export type UserInfo = {
        id: string;
        name: string;
    };
    export type UserInfoWithEmail = Identity<UserInfo & {
        email: string;
    }>;
    export type OnlineUserInfo = {
        id: string;
        name: string;
    };
}
declare module "@mirohq/websdk-types/stable/features/widgets/tag" {
    import { ContextSymbol } from "@mirohq/websdk-types/core/builder/symbols";
    import { Context, ItemProps } from "@mirohq/websdk-types/core/builder/types";
    export enum TagColor {
        Red = "red",
        Magenta = "magenta",
        Violet = "violet",
        LightGreen = "light_green",
        Green = "green",
        DarkGreen = "dark_green",
        Cyan = "cyan",
        Blue = "blue",
        DarkBlue = "dark_blue",
        Yellow = "yellow",
        Gray = "gray",
        Black = "black"
    }
    export class Tag {
        readonly type = "tag";
        readonly id: string;
        title: string;
        color: `${TagColor}`;
        protected [ContextSymbol]: Context;
        constructor(ctx: Context, props?: ItemProps<Tag>);
        sync(): Promise<void>;
    }
}
declare module "@mirohq/websdk-types/stable/api/widgets/tag" {
    import type { ItemProps } from "@mirohq/websdk-types/core/builder/types";
    import { TagColor, Tag } from "@mirohq/websdk-types/stable/features/widgets/tag";
    export type TagProps = ItemProps<Tag>;
    export { TagColor, Tag };
}
declare module "@mirohq/websdk-types/stable/features/widgets/embed" {
    import { Context, ItemProps } from "@mirohq/websdk-types/core/builder/types";
    import { BaseItem } from "@mirohq/websdk-types/core/features/widgets/base";
    export type EmbedMode = 'inline' | 'modal';
    export class Embed extends BaseItem {
        readonly type: "embed";
        readonly width?: number;
        readonly height?: number;
        readonly url: string;
        previewUrl: string;
        mode: EmbedMode;
        constructor(ctx: Context<string>, props: ItemProps<Embed>);
    }
}
declare module "@mirohq/websdk-types/stable/features/widgets/image" {
    import { Context, ItemProps } from "@mirohq/websdk-types/core/builder/types";
    import { BaseItem } from "@mirohq/websdk-types/core/features/widgets/base";
    export type ImageFormat = 'preview' | 'original';
    export type ImageProps = ItemProps<Image> & {
        url: string;
    };
    export class Image extends BaseItem {
        readonly type = "image";
        x: number;
        y: number;
        rotation: number;
        width: number;
        height: number;
        url: string;
        title: string;
        alt?: string | undefined;
        constructor(context: Context, props: ImageProps);
        getFile(format?: ImageFormat): Promise<File>;
        getDataUrl(format?: ImageFormat): Promise<string>;
    }
}
declare module "@mirohq/websdk-types/stable/features/widgets/preview" {
    import { Context, ItemProps } from "@mirohq/websdk-types/core/builder/types";
    import { BaseItem } from "@mirohq/websdk-types/core/features/widgets/base";
    export type PreviewProps = ItemProps<Preview> & {
        url: string;
    };
    export class Preview extends BaseItem {
        readonly type: "preview";
        width: number;
        height: number;
        readonly url: string;
        constructor(ctx: Context, props: PreviewProps);
    }
}
declare module "@mirohq/websdk-types/stable/features/widgets/shape" {
    import { Context, ItemProps } from "@mirohq/websdk-types/core/builder/types";
    import { BaseItem } from "@mirohq/websdk-types/core/features/widgets/base";
    import { FontFamily, StrokeStyle, TextAlign, TextAlignVertical } from "@mirohq/websdk-types/core/api/common";
    export type ShapeStyle = {
        color: string;
        fillColor: string;
        fillOpacity: number;
        fontFamily: FontFamily;
        fontSize: number;
        textAlign: TextAlign;
        textAlignVertical: TextAlignVertical;
        borderStyle: StrokeStyle;
        borderOpacity: number;
        borderColor: string;
        borderWidth: number;
    };
    export enum ShapeType {
        Rectangle = "rectangle",
        Circle = "circle",
        Triangle = "triangle",
        WedgeRoundRectangleCallout = "wedge_round_rectangle_callout",
        RoundRectangle = "round_rectangle",
        Rhombus = "rhombus",
        Parallelogram = "parallelogram",
        Star = "star",
        RightArrow = "right_arrow",
        LeftArrow = "left_arrow",
        Pentagon = "pentagon",
        Hexagon = "hexagon",
        Octagon = "octagon",
        Trapezoid = "trapezoid",
        FlowChartPredefinedProcess = "flow_chart_predefined_process",
        LeftRightArrow = "left_right_arrow",
        Cloud = "cloud",
        LeftBrace = "left_brace",
        RightBrace = "right_brace",
        Cross = "cross",
        Can = "can"
    }
    export class Shape extends BaseItem {
        readonly type: "shape";
        readonly width: number;
        readonly height: number;
        rotation: number;
        content: string;
        shape: ShapeType | `${ShapeType}`;
        style: ShapeStyle;
        constructor(ctx: Context, props?: ItemProps<Shape>);
    }
}
declare module "@mirohq/websdk-types/stable/features/widgets/stickyNote" {
    import { Context, ItemProps } from "@mirohq/websdk-types/core/builder/types";
    import { BaseItem } from "@mirohq/websdk-types/core/features/widgets/base";
    import { TextAlign, TextAlignVertical } from "@mirohq/websdk-types/core/api/common";
    export enum StickyNoteColor {
        Gray = "gray",
        LightYellow = "light_yellow",
        Yellow = "yellow",
        Orange = "orange",
        LightGreen = "light_green",
        Green = "green",
        DarkGreen = "dark_green",
        Cyan = "cyan",
        LightPink = "light_pink",
        Pink = "pink",
        Violet = "violet",
        Red = "red",
        LightBlue = "light_blue",
        Blue = "blue",
        DarkBlue = "dark_blue",
        Black = "black"
    }
    export type StickyNoteShape = 'square' | 'rectangle';
    export type StickyNoteColorType = StickyNoteColor | `${StickyNoteColor}`;
    export type StickyNoteStyle = {
        fillColor: StickyNoteColor | `${StickyNoteColor}`;
        textAlign: TextAlign;
        textAlignVertical: TextAlignVertical;
    };
    export class StickyNote extends BaseItem {
        readonly type: "sticky_note";
        width: number;
        height: number;
        shape: StickyNoteShape;
        content: string;
        style: StickyNoteStyle;
        tagIds: string[];
        constructor(ctx: Context, props?: ItemProps<StickyNote>);
    }
}
declare module "@mirohq/websdk-types/stable/features/widgets/text" {
    import { Context, ItemProps } from "@mirohq/websdk-types/core/builder/types";
    import { BaseItem } from "@mirohq/websdk-types/core/features/widgets/base";
    import { FontFamily, TextAlign } from "@mirohq/websdk-types/core/api/common";
    export type TextStyle = {
        color: string;
        fillColor: string;
        fillOpacity: number;
        fontFamily: FontFamily;
        fontSize: number;
        textAlign: TextAlign;
    };
    export class Text extends BaseItem {
        readonly type: "text";
        rotation: number;
        width: number;
        readonly height: number;
        content: string;
        style: TextStyle;
        constructor(ctx: Context, props?: ItemProps<Text>);
    }
}
declare module "@mirohq/websdk-types/stable/features/widgets/frame" {
    import { Unsupported } from "@mirohq/websdk-types/core/features/widgets/unsupported";
    import { Connector } from "@mirohq/websdk-types/core/features/widgets/connector";
    import { Context, Identity, ItemProps, BaseItem as BaseItemType } from "@mirohq/websdk-types/core/builder/types";
    import { BaseItem } from "@mirohq/websdk-types/core/features/widgets/base";
    import type { AppCard } from "@mirohq/websdk-types/stable/features/widgets/appCard";
    import type { Card } from "@mirohq/websdk-types/stable/features/widgets/card";
    import type { Embed } from "@mirohq/websdk-types/stable/features/widgets/embed";
    import type { Image } from "@mirohq/websdk-types/stable/features/widgets/image";
    import type { Preview } from "@mirohq/websdk-types/stable/features/widgets/preview";
    import type { Shape } from "@mirohq/websdk-types/stable/features/widgets/shape";
    import type { StickyNote } from "@mirohq/websdk-types/stable/features/widgets/stickyNote";
    import type { Text } from "@mirohq/websdk-types/stable/features/widgets/text";
    import type { Group } from "@mirohq/websdk-types/stable/features/widgets/group";
    export type ContainableItem = Unsupported | Connector | AppCard | Card | Embed | Image | Preview | Shape | StickyNote | Text | Frame | Group;
    export type FrameStyle = {
        fillColor: string;
    };
    export class BaseFrame<Item extends BaseItemType = ContainableItem> extends BaseItem {
        readonly type = "frame";
        x: number;
        y: number;
        width: number;
        height: number;
        title: string;
        showContent: boolean;
        childrenIds: string[];
        style: Identity<FrameStyle>;
        constructor(ctx: Context<string>, props?: ItemProps<BaseFrame>);
        add<T extends Item>(item: T): Promise<T>;
        remove<T extends Item>(item: T): Promise<void>;
        getChildren(): Promise<Item[]>;
    }
    export class Frame extends BaseFrame<ContainableItem> {
    }
}
declare module "@mirohq/websdk-types/stable/features/widgets/group" {
    import { Unsupported } from "@mirohq/websdk-types/core/features/widgets/unsupported";
    import { Connector } from "@mirohq/websdk-types/core/features/widgets/connector";
    import { ContextSymbol } from "@mirohq/websdk-types/core/builder/symbols";
    import { Context, ItemProps, BaseItem as BaseItemType } from "@mirohq/websdk-types/core/builder/types";
    import type { AppCard } from "@mirohq/websdk-types/stable/features/widgets/appCard";
    import type { Card } from "@mirohq/websdk-types/stable/features/widgets/card";
    import type { Embed } from "@mirohq/websdk-types/stable/features/widgets/embed";
    import type { Frame } from "@mirohq/websdk-types/stable/features/widgets/frame";
    import type { Image } from "@mirohq/websdk-types/stable/features/widgets/image";
    import type { Preview } from "@mirohq/websdk-types/stable/features/widgets/preview";
    import type { Shape } from "@mirohq/websdk-types/stable/features/widgets/shape";
    import type { StickyNote } from "@mirohq/websdk-types/stable/features/widgets/stickyNote";
    import type { Text } from "@mirohq/websdk-types/stable/features/widgets/text";
    export type GroupData = {
        readonly id?: string;
        readonly type: 'group';
        readonly itemsIds: string[];
    };
    export type GroupableItem = Unsupported | Connector | AppCard | Card | Embed | Frame | Image | Preview | Shape | StickyNote | Text;
    export type CreateGroupProps = {
        items: GroupableItem[];
    };
    export class BaseGroup<T extends BaseItemType = GroupableItem> implements GroupData {
        readonly type = "group";
        readonly id: string;
        readonly itemsIds: string[];
        protected [ContextSymbol]: Context;
        constructor(ctx: Context, props: ItemProps<BaseGroup<T>>);
        sync(): Promise<void>;
        getItems(): Promise<T[]>;
        ungroup(): Promise<T[]>;
    }
    export class Group extends BaseGroup<GroupableItem> {
    }
}
declare module "@mirohq/websdk-types/stable/api/widgets/group" {
    import type { ItemProps } from "@mirohq/websdk-types/core/builder/types";
    import type { Group } from "@mirohq/websdk-types/stable/features/widgets/group";
    export type { GroupData, CreateGroupProps, GroupableItem } from "@mirohq/websdk-types/stable/features/widgets/group";
    export { Group } from "@mirohq/websdk-types/stable/features/widgets/group";
    export type GroupProps = ItemProps<Group>;
}
declare module "@mirohq/websdk-types/stable/api/client" {
    import { Identity, InferItemFromClient, ItemsProps } from "@mirohq/websdk-types/core/builder/types";
    import { BaseItem as CoreBaseItem } from "@mirohq/websdk-types/core/features/widgets/base";
    import type { createStableSdk } from "@mirohq/websdk-types/stable/client/index";
    import type { Tag } from "@mirohq/websdk-types/stable/api/widgets/tag";
    import type { Group } from "@mirohq/websdk-types/stable/api/widgets/group";
    export type StableClient = Identity<ReturnType<typeof createStableSdk>>;
    export type StableClientItem = InferItemFromClient<ReturnType<typeof createStableSdk>>;
    export type Board = StableClient;
    export type Item = StableClientItem;
    export type ItemProps = ItemsProps<Item>;
    export type SelectableItems = Item;
    export type BoardNode = Item;
    export type BaseItem = Identity<CoreBaseItem>;
    export type ItemType = Item['type'];
    export type Entity = Tag | Group;
    export type BoardEntity = Tag | Group;
    export type Miro = {
        readonly board: StableClient;
        readonly clientVersion: string;
    };
}
declare module "@mirohq/websdk-types/stable/api/attention" {
    import { OnlineUserInfo } from "@mirohq/websdk-types/stable/api/board";
    export type FollowUserSessionsOptions = {
        followers?: OnlineUserInfo[];
    };
    export type UnfollowUserSessionsOptions = {
        followee: OnlineUserInfo;
        followers: OnlineUserInfo[];
    };
    export type Attention = {
        follow(followee: OnlineUserInfo, options?: FollowUserSessionsOptions): Promise<void>;
        isFollowing(): Promise<boolean>;
        getFollowedUser(): Promise<OnlineUserInfo>;
        unfollow(options?: UnfollowUserSessionsOptions): Promise<void>;
    };
}
declare module "@mirohq/websdk-types/stable/api/collaboration" {
    import { OneOrMany, UserId } from "@mirohq/websdk-types/core/api/common";
    import { Attention } from "@mirohq/websdk-types/stable/api/attention";
    import { OnlineUserInfo } from "@mirohq/websdk-types/stable/api/board";
    import { BaseItem } from "@mirohq/websdk-types/stable/api/client";
    export type CollaborationEventType = 'sessions:started' | 'sessions:ended';
    export type SessionEventType = 'sessions:invitation-responded' | 'sessions:user-joined' | 'sessions:user-left';
    export type UserSessionEvent = {
        id: string;
        userId: UserId;
        sessionId: string;
    };
    export type InvitationResponseEvent = {
        response: {
            user: UserId;
            status: 'accepted' | 'rejected';
            reason: 'clicked-button' | 'timed-out' | 'clicked-outside';
        };
    };
    export type Session = {
        readonly id: string;
        readonly name: string;
        readonly description: string;
        readonly color: string;
        readonly starterId: UserId;
        readonly starterName: string;
        invite(...users: OnlineUserInfo[] | OnlineUserInfo[][]): Promise<void>;
        join(): Promise<void>;
        leave(): Promise<void>;
        getUsers(): Promise<UserId[]>;
        hasJoined(user: UserId): Promise<boolean>;
        on(name: 'user-joined', handler: (event: UserSessionEvent) => Promise<void>): Promise<void>;
        on(name: 'user-left', handler: (event: UserSessionEvent) => Promise<void>): Promise<void>;
        on(name: 'invitation-responded', handler: (event: InvitationResponseEvent) => Promise<void>): Promise<void>;
        off(name: 'user-joined', handler: (event: UserSessionEvent) => Promise<void>): Promise<void>;
        off(name: 'user-left', handler: (event: UserSessionEvent) => void): Promise<void>;
        off(name: 'invitation-responded', handler: (event: InvitationResponseEvent) => Promise<void>): Promise<void>;
        end(): Promise<void>;
    };
    export type SessionStartProps = {
        name: string;
        color?: string;
        description?: string;
    };
    export type SessionsLifecycleEvent = {
        session: Session;
    };
    export type Collaboration = {
        readonly attention: Attention;
        startSession(props: SessionStartProps): Promise<Session>;
        getSessions(): Promise<Session[]>;
        on(name: 'sessions:started' | 'sessions:ended', handler: (event: SessionsLifecycleEvent) => void): Promise<void>;
        off(name: 'sessions:started' | 'sessions:ended', handler: (event: SessionsLifecycleEvent) => void): Promise<void>;
        zoomTo(user: OnlineUserInfo, items: OneOrMany<BaseItem>): Promise<void>;
    };
}
declare module "@mirohq/websdk-types/stable/api/realtimeEvents" {
    import { Json } from "@mirohq/websdk-types/core/api/common";
    export type RealtimeEventTypeUnprefixed = `realtime_event:${string}`;
    export type RealtimeEventType = `experimental:${RealtimeEventTypeUnprefixed}`;
    export type RealtimeEvents = {
        broadcast(event: string, payload?: Json): Promise<void>;
        on<T extends Json | undefined>(event: string, handler: (payload: T) => void): Promise<void>;
        off<T extends Json | undefined>(event: string, handler: (payload: T) => void): Promise<void>;
    };
}
declare module "@mirohq/websdk-types/stable/api/storage" {
    import { Json } from "@mirohq/websdk-types/core/api/common";
    export type StorageEventType = `storage:change:${string}:${string}`;
    export type StorageValue<T extends Json = Json> = {
        value: T | undefined;
        version: string;
    };
    export type Collection = {
        set(key: string, value: Json): Promise<void>;
        get<T extends Json>(key: string): Promise<T | undefined>;
        remove(key: string): Promise<void>;
        onValue<T extends Json = Json>(key: string, handler: (value: T | undefined, version: string) => void): Promise<void>;
        offValue<T extends Json = Json>(key: string, handler: (value: T | undefined, version: string) => void): Promise<void>;
    };
    export type Storage = {
        collection(name: string): Collection;
    };
}
declare module "@mirohq/websdk-types/stable/api/ui" {
    import { Identity } from "@mirohq/websdk-types/core/builder/types";
    import { CustomEventType } from "@mirohq/websdk-types/core/api/common";
    import { AppCard } from "@mirohq/websdk-types/stable/api/widgets/appCard";
    import { OnlineUserInfo } from "@mirohq/websdk-types/stable/api/board";
    import { Item } from "@mirohq/websdk-types/stable/api/client";
    import { CollaborationEventType, SessionEventType } from "@mirohq/websdk-types/stable/api/collaboration";
    import { RealtimeEventTypeUnprefixed } from "@mirohq/websdk-types/stable/api/realtimeEvents";
    import { StorageEventType } from "@mirohq/websdk-types/stable/api/storage";
    export type ItemsEventType = 'items:create' | 'experimental:items:update' | 'items:delete';
    export type UIEventType = 'drop' | 'icon:click' | 'app_card:open' | 'app_card:connect' | 'selection:update' | 'online_users:update' | CustomEventType | ItemsEventType;
    export type EventTypeUnprefixed = 'drop' | 'icon:click' | 'app_card:open' | 'app_card:connect' | 'selection:update' | 'online_users:update' | RealtimeEventTypeUnprefixed | CustomEventType | ItemsEventType | StorageEventType | CollaborationEventType | SessionEventType;
    export type DropEvent = {
        x: number;
        y: number;
        target: HTMLElement;
    };
    export type AppCardOpenEvent = {
        appCard: AppCard;
    };
    export type AppCardConnectEvent = {
        appCard: AppCard;
    };
    export type SelectionUpdateEvent = {
        items: Item[];
    };
    export type OnlineUsersUpdateEvent = {
        users: OnlineUserInfo[];
    };
    export type CustomEvent = {
        items: Item[];
    };
    export type ItemsCreateEvent = {
        items: Item[];
    };
    export type ItemsDeleteEvent = {
        items: Item[];
    };
    export type ItemsUpdateEvent = {
        items: Item[];
    };
    export type OpenPanelOptions<Data = undefined> = Identity<{
        url: string;
        height?: number;
    } & (Data extends undefined ? {} : {
        data: Data;
    })>;
    export type OpenModalOptions<Data = undefined> = Identity<{
        url: string;
        height?: number;
        width?: number;
        fullscreen?: boolean;
    } & (Data extends undefined ? {} : {
        data: Data;
    })>;
    export type BoardUI = {
        openPanel<Data = undefined, Result = undefined>(options: OpenPanelOptions<Data>): Promise<{
            waitForClose: () => Promise<Result | undefined>;
        }>;
        canOpenPanel(): Promise<boolean>;
        getPanelData<Data = unknown>(): Promise<Data | undefined>;
        closePanel<Result = undefined>(result?: Result): Promise<void>;
        openModal<Data = undefined, Result = undefined>(options: OpenModalOptions<Data>): Promise<{
            waitForClose: () => Promise<Result | undefined>;
        }>;
        getModalData<Data = unknown>(): Promise<Data | undefined>;
        closeModal<Result = undefined>(result?: Result): Promise<void>;
        canOpenModal(): Promise<boolean>;
        on(event: 'drop', handler: (event: DropEvent) => void): void;
        on(event: 'icon:click', handler: () => void): void;
        on(event: 'app_card:open', handler: (event: AppCardOpenEvent) => void): void;
        on(event: 'app_card:connect', handler: (event: AppCardConnectEvent) => void): void;
        on(event: 'selection:update', handler: (event: SelectionUpdateEvent) => void): void;
        on(event: 'online_users:update', handler: (event: OnlineUsersUpdateEvent) => void): void;
        on(event: 'items:create', handler: (event: ItemsCreateEvent) => void): void;
        on(event: 'experimental:items:update', handler: (event: ItemsUpdateEvent) => void): void;
        on(event: 'items:delete', handler: (event: ItemsDeleteEvent) => void): void;
        on(event: `custom:${string}`, handler: (event: CustomEvent) => void): void;
        off(event: 'drop', handler: (event: DropEvent) => void): void;
        off(event: 'icon:click', handler: () => void): void;
        off(event: 'app_card:open', handler: (event: AppCardOpenEvent) => void): void;
        off(event: 'app_card:connect', handler: (event: AppCardConnectEvent) => void): void;
        off(event: 'selection:update', handler: (event: SelectionUpdateEvent) => void): void;
        off(event: 'online_users:update', handler: (event: OnlineUsersUpdateEvent) => void): void;
        off(event: 'items:create', handler: (event: ItemsCreateEvent) => void): void;
        off(event: 'experimental:items:update', handler: (event: ItemsUpdateEvent) => void): void;
        off(event: 'items:delete', handler: (event: ItemsDeleteEvent) => void): void;
        off(event: `custom:${string}`, handler: (event: CustomEvent) => void): void;
    };
}
declare module "@mirohq/websdk-types/stable/features/ui" {
    import { EventManagerSymbol } from "@mirohq/websdk-types/core/symbols";
    import { ContextSymbol } from "@mirohq/websdk-types/core/builder/symbols";
    import { EventManager, Listener } from "@mirohq/websdk-types/core/features/eventManager";
    import { Context } from "@mirohq/websdk-types/core/builder/types";
    import type { UIEventType, BoardUI as IBoardUI, OpenPanelOptions, OpenModalOptions } from "@mirohq/websdk-types/stable/api/ui";
    export class BoardUI implements IBoardUI {
        protected [ContextSymbol]: Context;
        protected [EventManagerSymbol]: EventManager<UIEventType>;
        constructor(context: Context);
        openPanel<Data = undefined, Result = undefined>(options: OpenPanelOptions<Data>): Promise<{
            waitForClose: () => Promise<Result | undefined>;
        }>;
        getPanelData<Data = unknown>(): Promise<Data | undefined>;
        canOpenPanel(): Promise<boolean>;
        closePanel<Result>(result?: Result): Promise<void>;
        openModal<Data = undefined, Result = undefined>(options: OpenModalOptions<Data>): Promise<{
            waitForClose: () => Promise<Result | undefined>;
        }>;
        getModalData<Data = unknown>(): Promise<Data | undefined>;