@genispace/geniapp 0.3.0 → 0.5.0

package/dist/components/renderers/workflow/SimpleSchemaForm.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { JSONSchema } from '../../shared/platform-types/index.ts';
+
+interface SimpleSchemaFormProps {
+    schema: JSONSchema | null;
+    values: Record<string, any>;
+    onChange: (values: Record<string, any>) => void;
+    errors?: Record<string, string | Record<number, Record<string, string>>>;
+    className?: string;
+}
+export declare const SimpleSchemaForm: React.FC<SimpleSchemaFormProps>;
+export {};

package/dist/components/renderers/workflow/WorkflowComponent.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+import { WorkflowComponentProps } from './types';
+
+export declare const WorkflowComponent: React.FC<WorkflowComponentProps>;
+export default WorkflowComponent;

package/dist/components/renderers/workflow/index.d.ts

@@ -0,0 +1 @@
+export { default as WorkflowRenderer } from './WorkflowComponent';

package/dist/components/renderers/workflow/renderers/ProposalRendererFactory.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { ProposalRendererConfig } from '../types';
+
+interface ProposalRendererFactoryProps {
+    config: ProposalRendererConfig;
+    data: any;
+    formData?: Record<string, any>;
+    onFormDataChange?: (data: Record<string, any>) => void;
+    formErrors?: Record<string, string>;
+    customRenderers?: {
+        [rendererId: string]: React.ComponentType<any>;
+    };
+}
+export declare const ProposalRendererFactory: React.FC<ProposalRendererFactoryProps>;
+export {};

package/dist/components/renderers/workflow/runtime-index.d.ts

@@ -0,0 +1,9 @@
+export { WorkflowComponent } from './WorkflowComponent';
+export { default as WorkflowComponentDefault } from './WorkflowComponent';
+export type { WorkflowStep, StepConfig, UploadStepConfig, ProposalStepConfig, ProposalRendererConfig, ResultStepConfig, ActionButton, MetadataField, AlertConfig, DataTransformConfig, WorkflowComponentProps, WorkflowState } from './types';
+export type { JSONSchema, JSONSchemaProperty } from '../../shared/platform-types/index.ts';
+export { UploadStep } from './steps/UploadStep';
+export { ProposalStep } from './steps/ProposalStep';
+export { ResultStep } from './steps/ResultStep';
+export { ProposalRendererFactory } from './renderers/ProposalRendererFactory';
+export { SimpleSchemaForm } from './SimpleSchemaForm';

package/dist/components/renderers/workflow/steps/ProposalStep.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { ProposalStepConfig } from '../types';
+
+interface ProposalStepProps {
+    config: ProposalStepConfig;
+    proposal: any | null;
+    formData: Record<string, any>;
+    onFormDataChange: (data: Record<string, any>) => void;
+    onAction: (actionId: string, data: any) => void | Promise<void>;
+    isEditing: boolean;
+    onEditModeChange: (editing: boolean) => void;
+    icon?: string;
+    title: string;
+    description: string;
+    customRenderers?: {
+        [rendererId: string]: React.ComponentType<any>;
+    };
+    actionStatus?: Record<string, 'idle' | 'loading' | 'success' | 'error'>;
+}
+export declare const ProposalStep: React.FC<ProposalStepProps>;
+export {};

package/dist/components/renderers/workflow/steps/ResultStep.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { ResultStepConfig } from '../types';
+
+interface ResultStepProps {
+    config: ResultStepConfig;
+    data: any | null;
+    status?: 'idle' | 'success' | 'error';
+    icon?: string;
+    title: string;
+    description: string;
+}
+export declare const ResultStep: React.FC<ResultStepProps>;
+export {};

package/dist/components/renderers/workflow/steps/UploadStep.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { UploadStepConfig } from '../types';
+
+interface UploadStepProps {
+    config: UploadStepConfig;
+    onFileSelect: (file: File) => void;
+    onRemove: () => void;
+    uploadedFile: File | null;
+    isProcessing?: boolean;
+    icon?: string;
+    title: string;
+    description: string;
+}
+export declare const UploadStep: React.FC<UploadStepProps>;
+export {};

package/dist/components/renderers/workflow/types.d.ts

@@ -0,0 +1,185 @@
+import { JSONSchema } from '../../shared/platform-types/index.ts';
+
+export type StepComponentType = 'upload' | 'proposal' | 'result' | 'custom';
+export type ProposalRendererType = 'table' | 'form' | 'card' | 'custom';
+export type ActionType = 'approve' | 'edit' | 'reject' | 'submit' | 'cancel' | 'custom';
+export type DisplayFormat = 'json' | 'table' | 'card' | 'custom';
+export type AlertType = 'warning' | 'info' | 'success' | 'error';
+export interface WorkflowStep {
+    id: string;
+    title: string;
+    description: string;
+    icon?: string;
+    component: StepComponentType;
+    config: StepConfig;
+    order?: number;
+}
+export interface StepConfig {
+    upload?: UploadStepConfig;
+    proposal?: ProposalStepConfig;
+    result?: ResultStepConfig;
+    custom?: CustomStepConfig;
+}
+export interface UploadStepConfig {
+    accept?: string;
+    maxSize?: number;
+    multiple?: boolean;
+    preview?: boolean;
+    buttonText?: string;
+    placeholder?: string;
+    onUpload?: (file: File) => Promise<any>;
+}
+export interface ProposalStepConfig {
+    renderer: ProposalRendererType;
+    rendererConfig: ProposalRendererConfig;
+    actions: ActionButton[];
+    metadata?: MetadataField[];
+    alerts?: AlertConfig[];
+    editable?: boolean;
+    editMode?: 'inline' | 'form';
+}
+export interface ProposalRendererConfig {
+    type: ProposalRendererType;
+    table?: {
+        columns: TableColumn[];
+        dataPath?: string;
+        showHeader?: boolean;
+        striped?: boolean;
+    };
+    form?: {
+        schema: JSONSchema;
+        layout?: 'vertical' | 'horizontal' | 'grid';
+        showOptionalFields?: boolean;
+    };
+    card?: {
+        fields: CardField[];
+        layout?: 'grid' | 'list';
+    };
+    custom?: {
+        rendererId: string;
+        props?: Record<string, any>;
+    };
+}
+export interface TableColumn {
+    key: string;
+    label: string;
+    type?: 'text' | 'number' | 'currency' | 'date' | 'boolean';
+    format?: string;
+    align?: 'left' | 'center' | 'right';
+    width?: string | number;
+    render?: (value: any, record: any) => React.ReactNode;
+}
+export interface CardField {
+    key: string;
+    label: string;
+    type: 'text' | 'badge' | 'progress' | 'link' | 'custom';
+    valuePath?: string;
+    format?: string;
+    icon?: string;
+    color?: string;
+}
+export interface ActionButton {
+    id: string;
+    label: string;
+    variant: 'primary' | 'secondary' | 'destructive' | 'outline';
+    icon?: string;
+    action: ActionType;
+    handler?: string;
+    confirmMessage?: string;
+    disabled?: boolean | ((data: any) => boolean);
+    loading?: boolean;
+}
+export interface MetadataField {
+    key: string;
+    label: string;
+    valuePath: string;
+    icon?: string;
+    format?: 'date' | 'currency' | 'percentage' | 'text' | 'number';
+    color?: string;
+}
+export interface AlertConfig {
+    type: AlertType;
+    message: string;
+    icon?: string;
+    dismissible?: boolean;
+}
+export interface ResultStepConfig {
+    displayFormat: DisplayFormat;
+    showCopy?: boolean;
+    successMessage?: string;
+    errorMessage?: string;
+    customRenderer?: string;
+}
+export interface CustomStepConfig {
+    componentId: string;
+    props?: Record<string, any>;
+}
+export interface DataTransformConfig {
+    transformStepData?: (stepId: string, data: any, context?: any) => any;
+    prepareStepOutput?: (stepId: string, data: any, context?: any) => any;
+    validateStepData?: (stepId: string, data: any) => {
+        valid: boolean;
+        errors?: string[];
+    };
+    apiHandlers?: {
+        [stepId: string]: (data: any, config: any) => Promise<any>;
+    };
+}
+export interface WorkflowComponentProps {
+    agentId?: string;
+    /**
+     * Parse task id (resolved from `parseTaskIdentifier` at install). Step 1 runs the
+     * uploaded file through this task (document-reader → agent) to produce a
+     * structured record for review — it does NOT save. Preferred over `agentId`.
+     */
+    parseTaskId?: string;
+    /**
+     * Save task id (resolved from `saveTaskIdentifier`). Runs on confirm to write the
+     * reviewed record into the dataset (vector store). Two-phase: parse → review → save.
+     */
+    saveTaskId?: string;
+    /**
+     * Maps the uploaded file into the parse task's workflow input ports:
+     * `{urlNode}.{urlPort}` receives `{ url, filename }` (fed to document-reader),
+     * `{metaNode}.{metaPort}` receives `{ id, name, folderId }` (source provenance).
+     */
+    fileInput?: {
+        urlNode: string;
+        urlPort: string;
+        metaNode?: string;
+        metaPort?: string;
+    };
+    /**
+     * Maps the reviewed record into the save task's workflow input port:
+     * `{recordNode}.{recordPort}` receives the confirmed record object.
+     */
+    saveInput?: {
+        recordNode: string;
+        recordPort: string;
+    };
+    className?: string;
+    steps: WorkflowStep[];
+    transforms?: DataTransformConfig;
+    onStepComplete?: (stepId: string, data: any) => void;
+    onWorkflowComplete?: (finalData: any) => void;
+    onError?: (error: Error, stepId?: string) => void;
+    onAction?: (actionId: string, data: any) => void | Promise<void>;
+    useMockData?: boolean;
+    mockData?: Record<string, any>;
+    customRenderers?: {
+        [rendererId: string]: React.ComponentType<any>;
+    };
+    layout?: {
+        columns?: number;
+        gap?: string;
+    };
+}
+export interface WorkflowState {
+    currentStep: number;
+    stepData: Record<string, any>;
+    uploadedFile: File | null;
+    isProcessing: boolean;
+    error: Error | null;
+    isEditing?: boolean;
+    actionStatus: Record<string, 'idle' | 'loading' | 'success' | 'error'>;
+}

package/dist/components/renderers/workflow.js

@@ -0,0 +1,5 @@
+import { be as o } from "./runtime-DX1LfmqO.js";
+export {
+  o as WorkflowRenderer
+};
+//# sourceMappingURL=workflow.js.map

package/dist/components/renderers/workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/components/renderers.js

@@ -0,0 +1,41 @@
+import { aA as a, aB as s, aC as n, aD as d, aE as t, aF as R, aG as i, aH as l, aI as b, aJ as o, aK as p, aL as C, aM as T, aN as h, aO as u, aP as y, aQ as P, aR as c, aS as g, aT as A, aU as S, aV as D, aW as E, aX as G, aY as I, aZ as L, a_ as m, a$ as v, b0 as H, b1 as M, b2 as k, b3 as x, b4 as B, b5 as F, b6 as N, b7 as f, b8 as w } from "./renderers/runtime-DX1LfmqO.js";
+export {
+  a as AnalyticsTableRenderer,
+  s as AppIdentityListRenderer,
+  n as CardRenderer,
+  d as ChartRenderer,
+  t as CollapsePanelRenderer,
+  R as ContainerRenderer,
+  i as CustomContentRenderer,
+  l as DataGridCard,
+  b as EChartsChartRenderer,
+  o as EditableTableRenderer,
+  p as FilterPanelRenderer,
+  C as HeroCardRenderer,
+  T as IdentityAttributeAssignRenderer,
+  h as ListRenderer,
+  u as LoadingRenderer,
+  y as MapChartRenderer,
+  P as MetricCarouselRenderer,
+  c as NavTileRenderer,
+  g as ParagraphRenderer,
+  A as ProductDetailRenderer,
+  S as ProductReportRenderer,
+  D as PublishHistoryRenderer,
+  E as PublishPreviewEntryRenderer,
+  G as RadarChartRenderer,
+  I as RingStatRenderer,
+  L as ServiceDeskReporterRenderer,
+  m as SimpleTreeRenderer,
+  v as StatisticGroup,
+  H as TableRenderer,
+  M as TabsRenderer,
+  k as TaskInputRenderer,
+  x as TextRenderer,
+  B as TileGridRenderer,
+  F as TitleRenderer,
+  N as TypographyRenderer,
+  f as renderByType,
+  w as renderers
+};
+//# sourceMappingURL=renderers.js.map

package/dist/components/renderers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderers.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/components/runtime/ComponentRenderer.d.ts

@@ -0,0 +1,34 @@
+import { default as React } from 'react';
+import { ComponentConfig as BaseComponentConfig } from '../app/services/workbenchApi';
+import { ParameterConfig, TableAction } from '../types';
+import { ParameterRecord, ParameterContextValue } from '../types/parameters';
+import { CustomStylesConfig } from '../types/components';
+import { DatabaseDataSourceConfig } from '../types/databaseDataSource';
+import { EnhancedDataSource } from '../types/datasource';
+
+interface ExtendedComponentConfig extends BaseComponentConfig {
+    parameterConfig?: ParameterConfig;
+    actions?: TableAction[];
+    component?: ExtendedComponentConfig;
+    useMockData?: boolean;
+    databaseDataSourceConfig?: DatabaseDataSourceConfig;
+    enhancedDataSource?: EnhancedDataSource;
+    componentParameterConfig?: {
+        enableParameterReceiving?: boolean;
+        listenToParameters?: string[];
+    };
+    customStyles?: CustomStylesConfig;
+}
+interface PageComponentRendererProps {
+    component: ExtendedComponentConfig;
+    appConfig: Record<string, unknown>;
+    parentProps?: Record<string, unknown>;
+    pageParams?: ParameterRecord;
+    parameterContext?: ParameterContextValue;
+    pageId?: string;
+    tabId?: string;
+    /** Depth of layout containers (Container/Card/Tabs) wrapping this node; page roots use 0. */
+    nestingLevel?: number;
+}
+declare const PageComponentRenderer: React.FC<PageComponentRendererProps>;
+export default PageComponentRenderer;

package/dist/components/runtime/GeniAppComponentProvider.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+import { i18n as I18nInstance } from 'i18next';
+import { GeniAppHostAdapters } from '../types/host-adapters';
+
+export interface GeniAppComponentProviderProps {
+    children: ReactNode;
+    adapters?: GeniAppHostAdapters;
+    locale?: string;
+    i18n?: I18nInstance;
+    localeMetadata?: Record<string, unknown>;
+    applicationId?: string;
+    themeId?: string;
+    /** Override the detected Workbench viewport. Omit for automatic mobile/desktop behavior. */
+    mobile?: boolean;
+    fullscreen?: boolean;
+    /** Set false when the host already owns the document-level Workbench appearance. */
+    provideAppearance?: boolean;
+}
+/**
+ * Runtime boundary shared by Workbench view mode and standalone GeniApps.
+ * It provides the exact locale, appearance, viewport and platform adapter
+ * contexts consumed by the public renderer tree.
+ */
+export declare function GeniAppComponentProvider({ children, adapters, locale, i18n, localeMetadata, applicationId, themeId, mobile, fullscreen, provideAppearance, }: GeniAppComponentProviderProps): import("react").JSX.Element;

package/dist/components/runtime/GeniAppWorkbench.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react';
+import { WorkbenchConfig } from '../types/components';
+
+export interface GeniAppWorkbenchConfig extends WorkbenchConfig {
+    name?: string;
+    description?: string;
+    geniappRuntime?: {
+        datasourceIdentifiers?: Record<string, string>;
+    };
+}
+export interface GeniAppWorkbenchProps {
+    identifier: string;
+    config: GeniAppWorkbenchConfig;
+    name?: string;
+    allowedShellOrigins?: string[];
+    headerIcon?: ReactNode;
+    showRuntimeControls?: boolean;
+}
+/** Complete routed shell for a downloaded Workbench GeniApp. */
+export declare function GeniAppWorkbench({ identifier, config, name, allowedShellOrigins, headerIcon, showRuntimeControls, }: GeniAppWorkbenchProps): import("react").JSX.Element;

package/dist/components/runtime/Loading.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+
+interface LoadingProps {
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+    fullScreen?: boolean;
+}
+declare const Loading: React.FC<LoadingProps>;
+export default Loading;

package/dist/components/runtime/MultiPageRenderer.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { TabItem } from './TabManager';
+
+interface MultiPageRendererProps {
+    tabs: TabItem[];
+    activeTabId: string | null;
+    appConfig: any;
+    availableParameters?: Array<{
+        label: string;
+        value: string;
+        type?: string;
+    }>;
+}
+export declare const MultiPageRenderer: React.FC<MultiPageRendererProps>;
+export {};

package/dist/components/runtime/PageComingSoonOverlay.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Frosted-glass overlay shown above the page content when the page's
+ * `comingSoon.enabled` config is on. Dismissal is per-mount only: reopening
+ * or refreshing the page shows the overlay again. Hidden in edit mode so the
+ * page stays editable.
+ *
+ * Visual language follows the system empty-state pattern (EmptyStateBadge):
+ * soft icon badge + medium title + muted one-liner + small pill action —
+ * not a billboard headline.
+ */
+export declare function PageComingSoonOverlay(): import("react").JSX.Element;

package/dist/components/runtime/PageRenderer.d.ts

@@ -0,0 +1,36 @@
+import { default as React } from 'react';
+import { Grid24LayoutConfig } from '../types/components';
+import { LayoutPreset, GridArea } from '../utils/layoutSystem';
+import { ParameterRecord } from '../types/parameters';
+
+interface PageLayoutConfig {
+    type: 'default' | 'grid' | 'custom';
+    preset?: LayoutPreset | 'top1-bottom2' | 'left1-right2' | 'top1-bottom3' | 'all-vertical' | 'dashboard-layout';
+    areas?: {
+        top?: string[];
+        bottom?: string[];
+        left?: string[];
+        right?: string[];
+    };
+    gridTemplate?: {
+        rows: string;
+        columns: string;
+        areas: string;
+    };
+    componentPositions?: Record<string, {
+        area: GridArea | 'top' | 'bottom' | 'left' | 'right';
+        order: number;
+        span?: number;
+    }>;
+}
+type PageLayoutInput = PageLayoutConfig | Grid24LayoutConfig;
+interface PageLayoutRendererProps {
+    components: any[];
+    appConfig: any;
+    layoutConfig?: PageLayoutInput;
+    pageParams?: ParameterRecord;
+    pageId?: string;
+    tabId?: string;
+}
+declare const PageLayoutRenderer: React.FC<PageLayoutRendererProps>;
+export default PageLayoutRenderer;

package/dist/components/runtime/TabManager.d.ts

@@ -0,0 +1,39 @@
+import { default as React } from 'react';
+import { ParameterRecord } from '../types/parameters';
+
+export interface TabItem {
+    id: string;
+    pageId: string;
+    title: string;
+    icon?: string;
+    isActive: boolean;
+    pageConfig?: unknown;
+    isLoading: boolean;
+    hasError?: boolean;
+    errorMessage?: string;
+    urlParams?: ParameterRecord;
+    fullPath?: string;
+    navigationTitle?: string;
+    pageTitle?: string;
+}
+interface TabContextType {
+    tabs: TabItem[];
+    activeTabId: string | null;
+    openTab: (pageId: string, navigationTitle?: string, icon?: string, urlParams?: ParameterRecord, initialPageConfig?: unknown) => Promise<void>;
+    closeTab: (tabId: string) => void;
+    closeOtherTabs: (tabId: string) => void;
+    closeAllTabs: () => void;
+    switchTab: (tabId: string) => void;
+    getTabById: (tabId: string) => TabItem | undefined;
+    getActiveTab: () => TabItem | undefined;
+}
+export declare const workbenchHideTabBarRef: {
+    current: boolean;
+};
+export declare const useTabManager: () => TabContextType;
+interface TabProviderProps {
+    children: React.ReactNode;
+    workbenchId: string;
+}
+export declare const TabProvider: React.FC<TabProviderProps>;
+export {};

package/dist/components/runtime/componentTypes.d.ts

@@ -0,0 +1,70 @@
+import { Component } from '../renderers/types';
+
+type ComponentTypeName = 'Form' | 'Table' | 'EditableTable' | 'Chart' | 'StatisticGroup' | 'DataGridCard' | 'Container' | 'Tabs' | 'Typography' | 'Card' | 'List' | 'TaskInput' | 'ServiceDeskReporter' | 'Tree' | 'FilterPanel' | 'EChartsChart' | 'MapChart' | 'RadarChart' | 'HeroCard' | 'MetricCarousel' | 'CollapsePanel' | 'AnalyticsTable' | 'ProductReport' | 'ProductDetail' | 'TileGrid' | 'RingStat' | 'PublishHistory' | 'PublishPreviewEntry' | 'NavTile' | 'AppIdentityList' | 'IdentityAttributeAssign' | 'WorkflowComponent' | 'CustomContent';
+export interface BasePropertyConfig {
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    label: string;
+    description?: string;
+    required?: boolean;
+    defaultValue?: any;
+    options?: Array<{
+        label: string;
+        value: string | number;
+    }>;
+}
+export interface OptionPropertyConfig extends BasePropertyConfig {
+    type: 'string' | 'number';
+    options: Array<{
+        label: string;
+        value: string | number;
+    }>;
+}
+export interface ArrayPropertyConfig extends BasePropertyConfig {
+    type: 'array';
+    itemType: 'string' | 'number' | 'object';
+    itemConfig?: PropertyConfig;
+}
+export interface ObjectPropertyConfig extends BasePropertyConfig {
+    type: 'object';
+    properties: Record<string, PropertyConfig>;
+}
+export type PropertyConfig = BasePropertyConfig | OptionPropertyConfig | ArrayPropertyConfig | ObjectPropertyConfig;
+interface RecursivePropertyConfig extends BasePropertyConfig {
+    itemType?: 'string' | 'number' | 'object';
+    itemConfig?: RecursivePropertyConfig;
+    properties?: Record<string, RecursivePropertyConfig>;
+    additionalProperties?: boolean | RecursivePropertyConfig;
+    enum?: string[];
+    children?: {
+        [key: string]: RecursivePropertyConfig;
+    };
+}
+type PropType = RecursivePropertyConfig;
+export interface ComponentType {
+    type: ComponentTypeName;
+    title: string;
+    description: string;
+    icon: string;
+    propTypes: {
+        [key: string]: PropType;
+    };
+    dataSourceTypes?: {
+        [key: string]: {
+            label: string;
+            description?: string;
+            required?: boolean;
+            children: {
+                [key: string]: PropType;
+            };
+        };
+    };
+    mockData?: {
+        type: 'array' | 'object';
+        label: string;
+        description: string;
+        defaultValue: any;
+    };
+    createComponent: () => Component;
+}
+export declare const componentTypes: ComponentType[];
+export {};

package/dist/components/runtime/i18n.d.ts

@@ -0,0 +1,5 @@
+import { i18n as I18nInstance } from 'i18next';
+
+export type GeniAppLocale = 'en' | 'zh';
+export declare function normalizeGeniAppLocale(locale?: string): GeniAppLocale;
+export declare function createGeniAppI18n(locale?: string): I18nInstance;

package/dist/components/runtime/runtime-mode.d.ts

@@ -0,0 +1,40 @@
+import { PropsWithChildren, ReactNode } from 'react';
+
+export type ViewModePermissions = {
+    canEdit: false;
+    canManage: false;
+    canView: true;
+};
+/**
+ * Public GeniApps always execute the published/view branch of Workbench
+ * renderers. The Workbench editor continues to provide its own edit context.
+ */
+export declare const useEditMode: () => {
+    isEditMode: false;
+    permissions: ViewModePermissions;
+    permissionsLoading: boolean;
+    permissionsError: any;
+    draggedComponentType: string | null;
+    isAddingComponent: boolean;
+    previewOnly: boolean;
+    currentWorkbench: any;
+    openComponentEditor: () => any;
+    refreshComponent: () => any;
+    updatePageConfig: () => Promise<any>;
+    deletePage: () => Promise<any>;
+};
+export declare function EditModeProvider({ children }: PropsWithChildren): ReactNode;
+/**
+ * GeniApps execute the immutable published/view branch of the renderer. These
+ * compatibility surfaces let the exact Workbench renderer source compile
+ * without bundling editor state, drag-and-drop, or authoring controls.
+ */
+export declare function ComponentEditOverlay({ children, }: PropsWithChildren<Record<string, unknown>>): ReactNode;
+export declare function ContainerDropZoneOverlay(_props: Record<string, unknown>): null;
+export declare function WorkbenchEditMode({ children, }: PropsWithChildren<Record<string, unknown>>): ReactNode;
+export declare function Grid24EditableCanvas(_props: Record<string, unknown>): null;
+export declare function MobileFlowCanvas(_props: Record<string, unknown>): null;
+export declare const useGridCanvasGate: () => false;
+export declare const useStudioPreview: () => {
+    previewOnly: false;
+};

package/dist/components/shared/TitleManager.d.ts

@@ -0,0 +1,8 @@
+interface TitleManagerProps {
+    title?: string;
+    prefix?: string;
+    suffix?: string;
+}
+export default function TitleManager({ title, prefix, suffix }: TitleManagerProps): any;
+export declare function usePageTitle(title?: string, prefix?: string, suffix?: string): void;
+export {};