@ensera/plugin-frontend 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,752 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+
+declare function createPluginRuntime(ctx: PluginCtx): {
+    ctx: PluginCtx;
+    fetch: <T = unknown>(path: string, options?: PluginFetchOptions) => Promise<PluginFetchResponse<T>>;
+    get: <T = unknown>(path: string, options?: PluginFetchOptions) => Promise<PluginFetchResponse<T>>;
+    post: <T = unknown>(path: string, options?: PluginFetchOptions) => Promise<PluginFetchResponse<T>>;
+    put: <T = unknown>(path: string, options?: PluginFetchOptions) => Promise<PluginFetchResponse<T>>;
+    patch: <T = unknown>(path: string, options?: PluginFetchOptions) => Promise<PluginFetchResponse<T>>;
+    delete: <T = unknown>(path: string, options?: PluginFetchOptions) => Promise<PluginFetchResponse<T>>;
+    storage: {
+        getItem(key: string): string | null;
+        setItem(key: string, value: string): void;
+        removeItem(key: string): void;
+        clear(): void;
+        keys(): string[];
+        getJSON<T = unknown>(key: string): T | null;
+        setJSON(key: string, value: JsonValue): void;
+        info(): {
+            namespace: string;
+            backend: PluginStorageBackend;
+            approxBytesUsed?: number;
+        };
+    };
+    log: {
+        debug(message: string, meta?: JsonObject): void;
+        info(message: string, meta?: JsonObject): void;
+        warn(message: string, meta?: JsonObject): void;
+        error(message: string, meta?: JsonObject): void;
+    };
+    notify: {
+        send: (notification: PluginNotification, options?: PluginNotificationOptions) => Promise<PluginNotificationResponse>;
+        sendBulk: (notifications: PluginNotification[], options?: PluginNotificationOptions) => Promise<PluginNotificationBulkResponse>;
+        sendToSelf: (notification: Omit<PluginNotification, "userId">, options?: PluginNotificationOptions) => Promise<PluginNotificationResponse>;
+        requestPermission: () => Promise<NotificationPermission>;
+    };
+};
+type PluginRuntime = ReturnType<typeof createPluginRuntime>;
+/** ---- dispatcher attach ---- */
+type PluginDispatchFn = (req: Omit<PluginDispatchRequest, "type">) => Promise<JsonValue | void>;
+declare function attachActionDispatcher(args: {
+    actions: PluginActionsMap;
+    runtime: PluginRuntime;
+}): PluginDispatchFn;
+
+/**
+ * Core context passed to every plugin instance
+ */
+type PluginCtx = {
+    userId: string;
+    workspaceId: string;
+    spaceId: string;
+    /**
+     * Unique per iframe instance (Core generates).
+     * For context-menu actions, Core can create hidden instance(s).
+     */
+    instanceId: string;
+    featureSlug: string;
+    apiBase: string;
+    token: string;
+    tabViewId?: string;
+    taskScopeId?: string;
+    /**
+     * Optional: Core origin for message validation in iframe host/runtime.
+     * Example: "http://localhost:3000"
+     */
+    coreOrigin?: string;
+    /**
+     * Optional: how this instance was launched.
+     * Backward compatible: older Core can omit.
+     */
+    launch?: PluginLaunch;
+};
+/**
+ * Launch modes for plugin instances
+ */
+type PluginLaunch = {
+    mode: "panel";
+} | {
+    mode: "context";
+    trigger: "contextmenu";
+    x?: number;
+    y?: number;
+    selectionText?: string;
+    targetType?: string;
+    targetId?: string;
+    pageUrl?: string;
+} | {
+    /** Plugin rendered as a floating overlay on top of a panel feature. */
+    mode: "overlay";
+    trigger: "contextmenu";
+    /** The instanceId of the panel feature this overlay is associated with. */
+    targetInstanceId: string;
+};
+/**
+ * Message sent from a context plugin to Core to request opening an overlay iframe.
+ * Core will create a new iframe with launch.mode = "overlay" for this plugin.
+ */
+type PluginOpenOverlayMessage = {
+    type: "ENSERA_OPEN_OVERLAY";
+    featureSlug: string;
+};
+/**
+ * JSON-serializable value types
+ */
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type JsonObject = Record<string, JsonValue>;
+/**
+ * Fetch API - Expected response types
+ */
+type PluginFetchExpect = "json" | "text" | "blob" | "none";
+/**
+ * Fetch API - Retry configuration
+ */
+type PluginFetchRetry = {
+    count: number;
+    backoffMs?: number;
+};
+/**
+ * Fetch API - Request options
+ */
+type PluginFetchOptions = Omit<RequestInit, "body"> & {
+    json?: JsonValue;
+    body?: BodyInit;
+    timeoutMs?: number;
+    retry?: PluginFetchRetry;
+    expect?: PluginFetchExpect;
+    requestId?: string;
+};
+/**
+ * Fetch API - Response wrapper
+ */
+type PluginFetchResponse<T> = {
+    data: T;
+    status: number;
+    headers: Headers;
+    url: string;
+    requestId: string;
+};
+/**
+ * Storage API - Backend types
+ */
+type PluginStorageBackend = "localStorage" | "indexedDB" | "bridge";
+/**
+ * Logger API - Log levels
+ */
+type PluginLogLevel = "debug" | "info" | "warn" | "error";
+/**
+ * Action System - Action identifier
+ */
+type PluginActionId = string;
+/**
+ * Action System - Dispatch request from Core to Plugin
+ */
+type PluginDispatchRequest = {
+    type: "ENSERA_DISPATCH";
+    featureSlug?: string;
+    instanceId?: string;
+    requestId: string;
+    actionId: PluginActionId;
+    payload?: JsonObject;
+};
+/**
+ * Action System - Result sent back to Core
+ */
+type PluginDispatchResult = {
+    type: "ENSERA_RESULT";
+    instanceId?: string;
+    requestId: string;
+    ok: true;
+    data?: JsonValue;
+} | {
+    type: "ENSERA_RESULT";
+    instanceId?: string;
+    requestId: string;
+    ok: false;
+    error: {
+        message: string;
+        name?: string;
+        code?: string;
+        stack?: string;
+    };
+};
+/**
+ * Action System - Handler function arguments
+ */
+type PluginActionHandlerArgs = {
+    actionId: PluginActionId;
+    payload?: JsonObject;
+    ctx: PluginCtx;
+    runtime: PluginRuntime;
+};
+/**
+ * Action System - Handler function signature
+ */
+type PluginActionHandler = (args: PluginActionHandlerArgs) => Promise<JsonValue | void> | (JsonValue | void);
+/**
+ * Action System - Map of action IDs to handlers
+ */
+type PluginActionsMap = Record<PluginActionId, PluginActionHandler>;
+/**
+ * Notification System - Action attached to a notification
+ */
+interface NotificationAction {
+    label: string;
+    actionId: string;
+    payload?: JsonValue;
+}
+/**
+ * Notification System - Notification payload
+ */
+interface PluginNotification {
+    userId: string;
+    type: string;
+    title: string;
+    message: string;
+    metadata?: JsonValue;
+    priority?: "low" | "normal" | "high" | "urgent";
+    link?: string;
+    actions?: NotificationAction[];
+}
+/**
+ * Notification System - Send options
+ */
+interface PluginNotificationOptions {
+    /** Skip if user has disabled notifications for this feature */
+    respectPreferences?: boolean;
+    /** Only send via specific channels */
+    channels?: Array<"email" | "push" | "inApp">;
+    /** Schedule for later */
+    scheduledAt?: Date | string;
+}
+/**
+ * Response from Core after sending
+ */
+interface PluginNotificationResponse {
+    success: boolean;
+    id?: string;
+    sent?: boolean;
+    emailSent?: boolean;
+    pushSent?: boolean;
+    error?: string;
+    reason?: string;
+}
+/**
+ * Bulk send response
+ */
+interface PluginNotificationBulkResponse {
+    success: boolean;
+    count?: number;
+    errors?: Array<{
+        index: number;
+        userId: string;
+        error: string;
+    }>;
+}
+/**
+ * Notification System - Request sent to Core via postMessage
+ */
+type PluginNotificationRequest = {
+    type: "ENSERA_SEND_NOTIFICATION";
+    requestId: string;
+    payload: PluginNotification & {
+        featureSlug: string;
+        options?: PluginNotificationOptions;
+    };
+};
+/**
+ * PostMessage response from Core
+ */
+type PluginNotificationResultMessage = {
+    type: "ENSERA_NOTIFICATION_RESPONSE";
+    requestId: string;
+    ok: true;
+    id: string;
+    sent: boolean;
+    emailSent: boolean;
+    pushSent: boolean;
+} | {
+    type: "ENSERA_NOTIFICATION_RESPONSE";
+    requestId: string;
+    ok: false;
+    error: string;
+};
+/**
+ * Notification Configuration - Type definition in package.json
+ */
+interface NotificationTypeConfig {
+    id: string;
+    label: string;
+    description?: string;
+    defaultEnabled?: boolean;
+}
+/**
+ * Notification Configuration - Feature capabilities in package.json
+ */
+interface NotificationCapabilities {
+    enabled: boolean;
+    types: NotificationTypeConfig[];
+}
+
+type PluginErrorPayload = unknown;
+declare class PluginFetchError extends Error {
+    readonly status?: number;
+    readonly url: string;
+    readonly requestId: string;
+    readonly payload?: PluginErrorPayload;
+    readonly code?: string;
+    constructor(args: {
+        name?: string;
+        message: string;
+        url: string;
+        requestId: string;
+        status?: number;
+        payload?: PluginErrorPayload;
+        code?: string;
+    });
+}
+declare class PluginAuthError extends PluginFetchError {
+    constructor(args: ConstructorParameters<typeof PluginFetchError>[0]);
+}
+declare class PluginForbiddenError extends PluginFetchError {
+    constructor(args: ConstructorParameters<typeof PluginFetchError>[0]);
+}
+declare class PluginNotFoundError extends PluginFetchError {
+    constructor(args: ConstructorParameters<typeof PluginFetchError>[0]);
+}
+declare class PluginValidationError extends PluginFetchError {
+    constructor(args: ConstructorParameters<typeof PluginFetchError>[0]);
+}
+declare class PluginRateLimitError extends PluginFetchError {
+    constructor(args: ConstructorParameters<typeof PluginFetchError>[0]);
+}
+declare class PluginServerError extends PluginFetchError {
+    constructor(args: ConstructorParameters<typeof PluginFetchError>[0]);
+}
+declare class PluginNetworkError extends PluginFetchError {
+    constructor(args: ConstructorParameters<typeof PluginFetchError>[0]);
+}
+declare class PluginResponseError extends PluginFetchError {
+    constructor(args: ConstructorParameters<typeof PluginFetchError>[0]);
+}
+/**
+ * Base storage error
+ */
+declare class PluginStorageError extends Error {
+    constructor(message: string);
+}
+/**
+ * Quota error (best-effort normalization)
+ */
+declare class PluginStorageQuotaError extends PluginStorageError {
+    constructor(message?: string);
+}
+declare class PluginFetchInputError extends Error {
+    constructor(message: string);
+}
+
+declare function createPluginFetch(ctx: PluginCtx): <T = unknown>(path: string, options?: PluginFetchOptions) => Promise<PluginFetchResponse<T>>;
+
+declare function makeStorageNamespace(ctx: PluginCtx, version?: number): string;
+declare function createPluginStorage(ctx: PluginCtx): {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    clear(): void;
+    keys(): string[];
+    getJSON<T = unknown>(key: string): T | null;
+    setJSON(key: string, value: JsonValue): void;
+    info(): {
+        namespace: string;
+        backend: PluginStorageBackend;
+        approxBytesUsed?: number;
+    };
+};
+type PluginStorage = ReturnType<typeof createPluginStorage>;
+
+declare function createPluginLogger(ctx: PluginCtx): {
+    debug(message: string, meta?: JsonObject): void;
+    info(message: string, meta?: JsonObject): void;
+    warn(message: string, meta?: JsonObject): void;
+    error(message: string, meta?: JsonObject): void;
+};
+type PluginLogger = ReturnType<typeof createPluginLogger>;
+
+/**
+ * Helper to define actions with proper typing.
+ * Example:
+ *   export const actions = defineActions({
+ *     INC_5: async ({ runtime }) => {...}
+ *   })
+ */
+declare function defineActions<T extends PluginActionsMap>(actions: T): T;
+/**
+ * Helpful error to make "unknown action" explicit.
+ */
+declare class PluginUnknownActionError extends Error {
+    readonly actionId: string;
+    constructor(actionId: string);
+}
+/**
+ * Wrap action handler with safe error surface.
+ */
+declare function runActionSafe(args: {
+    actions: PluginActionsMap;
+    actionId: string;
+    payload: any;
+    call: () => ReturnType<PluginActionHandler>;
+}): Promise<void | JsonValue>;
+
+declare function ContextMenuShell({ children }: {
+    children: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+declare function createPluginStorageIndexedDB(ctx: PluginCtx): {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+    getJSON<T = unknown>(key: string): Promise<T | null>;
+    setJSON(key: string, value: JsonValue): Promise<void>;
+    info(): Promise<{
+        namespace: string;
+        backend: PluginStorageBackend;
+    }>;
+};
+type PluginStorageIndexedDB = ReturnType<typeof createPluginStorageIndexedDB>;
+
+/**
+ * Create notification API for feature frontend
+ * Uses postMessage to communicate with Core (since feature is in iframe)
+ */
+declare function createPluginNotify(ctx: PluginCtx): {
+    send: (notification: PluginNotification, options?: PluginNotificationOptions) => Promise<PluginNotificationResponse>;
+    sendBulk: (notifications: PluginNotification[], options?: PluginNotificationOptions) => Promise<PluginNotificationBulkResponse>;
+    sendToSelf: (notification: Omit<PluginNotification, "userId">, options?: PluginNotificationOptions) => Promise<PluginNotificationResponse>;
+    requestPermission: () => Promise<NotificationPermission>;
+};
+type PluginNotify = ReturnType<typeof createPluginNotify>;
+
+type SyncEventType = "sync:task_created" | "sync:task_updated" | "sync:task_deleted" | "sync:tasks_reordered" | "sync:column_created" | "sync:column_updated" | "sync:column_deleted" | "sync:columns_reordered";
+type SyncPayload = {
+    id?: string;
+    action?: "create" | "update" | "delete" | "reorder";
+    [key: string]: unknown;
+};
+/**
+ * Call once during plugin init (PluginRuntime.init) to set context.
+ * This is needed so broadcast() knows what instanceId to tag messages with
+ * and what origin to target.
+ */
+declare function initBroadcast(opts: {
+    instanceId: string;
+    coreOrigin?: string;
+}): void;
+/**
+ * Emit a sync event to sibling plugins in the same Tab View.
+ *
+ * @example
+ * ```ts
+ * import { broadcast } from '@ensera/plugin-frontend';
+ *
+ * // After a successful task mutation:
+ * broadcast('sync:task_updated', { id: taskId, action: 'update' });
+ * ```
+ *
+ * Under the hood this sends a postMessage to the parent window (Core).
+ * Core's TabViewRenderer then relays it to all sibling iframes.
+ * If the plugin is running standalone (no Tab View), this is a no-op.
+ */
+declare function broadcast(event: SyncEventType, payload?: SyncPayload): void;
+type BroadcastCallback = (payload: SyncPayload) => void;
+/**
+ * React hook that listens for a specific sync event relayed by Core.
+ *
+ * @example
+ * ```tsx
+ * import { useBroadcastListener } from '@ensera/plugin-frontend';
+ * import { useQueryClient } from '@tanstack/react-query';
+ *
+ * function SyncRoot() {
+ *   const queryClient = useQueryClient();
+ *
+ *   useBroadcastListener('sync:task_updated', () => {
+ *     queryClient.invalidateQueries({ queryKey: ['tasks'] });
+ *   });
+ *
+ *   useBroadcastListener('sync:columns_updated', () => {
+ *     queryClient.invalidateQueries({ queryKey: ['columns'] });
+ *     queryClient.invalidateQueries({ queryKey: ['statuses'] });
+ *   });
+ *
+ *   return <App />;
+ * }
+ * ```
+ */
+declare function useBroadcastListener(event: SyncEventType | SyncEventType[], callback: BroadcastCallback): void;
+/**
+ * Non-hook version for use outside React components.
+ * Returns an unsubscribe function.
+ *
+ * @example
+ * ```ts
+ * const unsub = onBroadcast('sync:task_updated', (payload) => {
+ *   console.log('Task updated:', payload.id);
+ * });
+ *
+ * // Later:
+ * unsub();
+ * ```
+ */
+declare function onBroadcast(event: SyncEventType | SyncEventType[], callback: BroadcastCallback): () => void;
+
+type SyncMessage<T = JsonValue> = {
+    type: "STATE_SYNC";
+    featureSlug: string;
+    instanceId: string;
+    clientId: string;
+    state: T;
+    timestamp: number;
+};
+type SyncCallback<T = JsonValue> = (state: T, source: string) => void;
+/**
+ * Creates a synchronized state manager for a plugin instance.
+ * Automatically syncs state between context menu and PiP views.
+ */
+declare function createSyncedState<T extends JsonValue>(args: {
+    featureSlug: string;
+    instanceId: string;
+    initialState: T;
+    onSync?: SyncCallback<T>;
+}): {
+    setState: (newState: T | ((prev: T) => T)) => T;
+    getState: () => T;
+    cleanup: () => void;
+};
+type SyncedState<T extends JsonValue> = ReturnType<typeof createSyncedState<T>>;
+/**
+ * React hook for synced state (optional convenience wrapper)
+ */
+declare function useSyncedState<T extends JsonValue>(args: {
+    featureSlug: string;
+    instanceId: string;
+    initialState: T;
+}): [T, (state: T | ((prev: T) => T)) => void];
+
+declare const tokens: {
+    readonly spacing: {
+        readonly xs: 4;
+        readonly sm: 8;
+        readonly md: 12;
+        readonly lg: 16;
+        readonly xl: 20;
+        readonly xxl: 24;
+    };
+    readonly rowHeight: {
+        readonly compact: 32;
+        readonly default: 44;
+        readonly comfortable: 56;
+        readonly large: 72;
+    };
+    readonly fontSize: {
+        readonly xs: 11;
+        readonly sm: 12;
+        readonly md: 14;
+        readonly lg: 16;
+        readonly xl: 18;
+    };
+    readonly fontWeight: {
+        readonly normal: 400;
+        readonly medium: 500;
+        readonly semibold: 600;
+        readonly bold: 700;
+    };
+    readonly radius: {
+        readonly sm: 4;
+        readonly md: 6;
+        readonly lg: 8;
+        readonly xl: 12;
+        readonly full: 9999;
+    };
+    readonly colors: {
+        readonly bg: {
+            readonly primary: "#FFFFFF";
+            readonly secondary: "#F9FAFB";
+            readonly hover: "#F3F4F6";
+            readonly active: "#E5E7EB";
+            readonly disabled: "#F9FAFB";
+        };
+        readonly border: {
+            readonly default: "#E5E7EB";
+            readonly hover: "#D1D5DB";
+            readonly focus: "#3B82F6";
+        };
+        readonly text: {
+            readonly primary: "#111827";
+            readonly secondary: "#6B7280";
+            readonly tertiary: "#9CA3AF";
+            readonly disabled: "#D1D5DB";
+            readonly inverse: "#FFFFFF";
+        };
+        readonly accent: {
+            readonly primary: "#3B82F6";
+            readonly primaryHover: "#2563EB";
+            readonly success: "#10B981";
+            readonly warning: "#F59E0B";
+            readonly danger: "#EF4444";
+        };
+    };
+    readonly shadow: {
+        readonly sm: "0 1px 2px 0 rgba(0, 0, 0, 0.05)";
+        readonly md: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06)";
+        readonly lg: "0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05)";
+        readonly xl: "0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04)";
+    };
+    readonly transition: {
+        readonly fast: "150ms cubic-bezier(0.4, 0, 0.2, 1)";
+        readonly base: "200ms cubic-bezier(0.4, 0, 0.2, 1)";
+        readonly slow: "300ms cubic-bezier(0.4, 0, 0.2, 1)";
+    };
+};
+type Tokens = typeof tokens;
+
+type ButtonVariant = "primary" | "secondary" | "ghost" | "danger";
+type ButtonSize = "sm" | "md" | "lg";
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    fullWidth?: boolean;
+    icon?: React.ReactNode;
+    iconPosition?: "left" | "right";
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+type InputSize = "sm" | "md" | "lg";
+type InputVariant = "default" | "filled";
+interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size"> {
+    size?: InputSize;
+    variant?: InputVariant;
+    error?: boolean;
+    fullWidth?: boolean;
+    leftIcon?: React.ReactNode;
+    rightIcon?: React.ReactNode;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+
+type IconButtonSize = "sm" | "md" | "lg";
+type IconButtonVariant = "default" | "ghost" | "primary" | "danger";
+interface IconButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    size?: IconButtonSize;
+    variant?: IconButtonVariant;
+    /**
+     * Icon element to display
+     */
+    icon: React.ReactNode;
+}
+declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<HTMLButtonElement>>;
+
+type RowHeight = "compact" | "default" | "comfortable" | "large";
+type RowAlign = "start" | "center" | "end" | "stretch";
+type RowJustify = "start" | "center" | "end" | "between" | "around" | "evenly";
+interface RowProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Predefined height variants based on design tokens
+     */
+    height?: RowHeight;
+    /**
+     * Custom height (overrides height variant)
+     */
+    customHeight?: number | string;
+    /**
+     * Vertical alignment of children
+     */
+    align?: RowAlign;
+    /**
+     * Horizontal distribution of children
+     */
+    justify?: RowJustify;
+    /**
+     * Gap between children (in pixels)
+     */
+    gap?: number;
+    /**
+     * Padding (uses token spacing values)
+     */
+    padding?: number;
+    /**
+     * Whether to fill full width
+     */
+    fullWidth?: boolean;
+    /**
+     * Add divider between children
+     */
+    divider?: boolean;
+}
+declare const Row: React.ForwardRefExoticComponent<RowProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Container component for context menu plugins.
+ * Provides consistent height and spacing for all plugin rows.
+ */
+interface ContextRowProps extends Omit<RowProps, "height"> {
+    /**
+     * Allow the plugin to expand beyond default height
+     * @default false
+     */
+    expandable?: boolean;
+    /**
+     * Minimum height constraint (in pixels)
+     * @default 44
+     */
+    minHeight?: number;
+    /**
+     * Maximum height constraint (in pixels)
+     * @default 120
+     */
+    maxHeight?: number;
+}
+declare const ContextRow: React.ForwardRefExoticComponent<ContextRowProps & React.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Request Core to open this plugin as a floating overlay on top of the
+ * panel feature that was right-clicked.
+ *
+ * Call this from a context-mode plugin when the user clicks "Add Note" (or
+ * similar). Core will create a new iframe for the plugin in "overlay" mode
+ * and pass `launch.targetInstanceId` in ENSERA_INIT.
+ */
+declare function openOverlay(featureSlug: string): void;
+
+/**
+ * Sets up a right-click context menu relay from inside a panel feature iframe to Core.
+ * Core (SpaceInstanceRenderer) intercepts this message, translates coordinates to
+ * page-space, and fires a `panel-context-menu` CustomEvent with the correct instanceId.
+ *
+ * Call this once in your panel feature's mount() function and invoke the returned
+ * cleanup in unmount().
+ *
+ * @example
+ * function mount(container, ctx) {
+ *   const cleanupCtxMenu = setupContextMenuRelay(ctx);
+ *   cleanup = () => { cleanupCtxMenu(); reactRoot?.unmount(); ... };
+ * }
+ */
+declare function setupContextMenuRelay(ctx: {
+    instanceId: string;
+}): () => void;
+
+export { Button, type ButtonProps, type ButtonSize, type ButtonVariant, ContextMenuShell, ContextRow, type ContextRowProps, IconButton, type IconButtonProps, type IconButtonSize, type IconButtonVariant, Input, type InputProps, type InputSize, type InputVariant, type JsonObject, type JsonValue, type NotificationAction, type NotificationCapabilities, type NotificationTypeConfig, type PluginActionHandler, type PluginActionHandlerArgs, type PluginActionId, type PluginActionsMap, PluginAuthError, type PluginCtx, type PluginDispatchFn, type PluginDispatchRequest, type PluginDispatchResult, type PluginErrorPayload, PluginFetchError, type PluginFetchExpect, PluginFetchInputError, type PluginFetchOptions, type PluginFetchResponse, type PluginFetchRetry, PluginForbiddenError, type PluginLaunch, type PluginLogLevel, type PluginLogger, PluginNetworkError, PluginNotFoundError, type PluginNotification, type PluginNotificationBulkResponse, type PluginNotificationOptions, type PluginNotificationRequest, type PluginNotificationResponse, type PluginNotificationResultMessage, type PluginNotify, type PluginOpenOverlayMessage, PluginRateLimitError, PluginResponseError, type PluginRuntime, PluginServerError, type PluginStorage, type PluginStorageBackend, PluginStorageError, type PluginStorageIndexedDB, PluginStorageQuotaError, PluginUnknownActionError, PluginValidationError, Row, type RowAlign, type RowHeight, type RowJustify, type RowProps, type SyncCallback, type SyncEventType, type SyncMessage, type SyncPayload, type SyncedState, type Tokens, attachActionDispatcher, broadcast, createPluginFetch, createPluginLogger, createPluginNotify, createPluginRuntime, createPluginStorage, createPluginStorageIndexedDB, createSyncedState, defineActions, initBroadcast, makeStorageNamespace, onBroadcast, openOverlay, runActionSafe, setupContextMenuRelay, tokens, useBroadcastListener, useSyncedState };