@superblocksteam/library 2.0.34 → 2.0.35-next.0

package/dist/index.d.ts

@@ -0,0 +1,1388 @@
+import * as _superblocksteam_library_shared_types7 from "@superblocksteam/library-shared/types";
+import { AiContextMode, AiGenerationState, AppToEditorMessage, BindingIdentifier, Catalog, CreateChild, CreateChild as CreateChild$1, DeleteMeLibraryApi, EditOperationPayload, EditOperationType, EditorConfig as EditorConfig$1, Entity, EntityOutputProp, GeneratedTheme, IEventFlow, NotificationPosition, NotificationType, PayloadAction, PerSideBorder, PropertyInfo, RuntimeErrorData, SbElement, SbEvent as SbEvent$1, SbInstance, ScopeOptions, ScopedState, SourceLocation, StateVarPersistence, StepDef, Theme as Theme$1, TransactionInfo, TriggerStepType, UrlState, UserAccessibleTheme, ValueInputProp, WithBindingIdentifier, sbEntitySymbol } from "@superblocksteam/library-shared/types";
+import * as react0 from "react";
+import React$1, { CSSProperties, ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as _superblocksteam_library_shared0 from "@superblocksteam/library-shared";
+import { ComputedProperty, Dim, Dim as Dim$1, DimModes, DimModes as DimModes$1, EditorConfig, EvaluateOrValueComputedArgs, INSTANCE_ID_ATTRIBUTE, NO_CONTENT_ATTRIBUTE, Property, SB } from "@superblocksteam/library-shared";
+import { Link, Outlet, generatePath } from "react-router";
+import * as _superblocksteam_library_shared_props1 from "@superblocksteam/library-shared/props";
+import { Callback, ControlType, DataType, DataTypeString, HeaderType, PropertiesPanelDefinition, PropertiesPanelDisplay, PropertyForData, PropsPanelCategory, Relation, WidgetPropertyDefinition } from "@superblocksteam/library-shared/props";
+import { OrchestratorViewMode, PlaceholderInfo, Profile, RouteDef } from "@superblocksteam/shared";
+import { XYCoord } from "react-dnd";
+
+//#region src/lib/user-facing/component-base/constants.d.ts
+type ContainerLayout = "vertical" | "horizontal";
+type ContainerVariant = "none" | "card";
+//#endregion
+//#region src/lib/user-facing/component-base/use-passthrough-props.d.ts
+type ElementPassthroughProps = Record<string, any>;
+//#endregion
+//#region src/lib/internal-details/lib/types.d.ts
+type ExecutionError = {
+  name?: string;
+  message: string;
+  formPath: string;
+  blockPath: string;
+  handled?: boolean;
+};
+type ExecutionEventRequest = {
+  summary: string;
+  metadata: {
+    placeHoldersInfo?: Record<string, PlaceholderInfo>;
+  };
+};
+type Resolutions = Record<string,
+// name of the field: eg: "range", for the range field let's say the code is {{[1,2,3]}}
+{
+  value: any;
+  bindings: any[];
+}>;
+type ExecutionEvent = {
+  name: string;
+  type: string;
+  timestamp: string;
+  start?: Record<string, unknown>;
+  end?: {
+    performance?: {
+      start: string | number;
+      finish: string | number;
+      total: string | number;
+      execution: string | number;
+      overhead: string | number;
+    };
+    error?: ExecutionError;
+    output?: {
+      result?: any;
+      request?: string;
+      requestV2?: ExecutionEventRequest;
+      stdout?: Array<string>;
+      stderr?: Array<string>;
+    };
+    resolved?: Resolutions;
+  };
+  parent: string;
+};
+interface StreamEvent {
+  result: {
+    event: ExecutionEvent;
+    execution: string;
+  };
+}
+type RouteChangePayload = Omit<UrlState, "host" | "hostname" | "href" | "pathname" | "port" | "protocol">;
+type AiUpdatesPayload = {
+  parentToChild: {
+    type: "start-editing";
+    components?: SbElement[];
+  } | {
+    type: "finish-editing";
+  } | {
+    type: "update-editing-entities";
+    components: SbElement[];
+  } | {
+    type: "set-ai-context-mode";
+    mode: AiContextMode;
+    components?: SbElement[];
+  } | {
+    type: "set-tagging-enabled";
+    isTaggingEnabled: boolean;
+  };
+  childToParent: {
+    type: "add-component-to-context";
+    component: SbElement;
+  } | {
+    type: "toggle-component-in-context";
+    component: SbElement;
+  } | {
+    type: "set-ai-context-mode";
+    mode: AiContextMode;
+  } | {
+    type: "ai-generate";
+    prompt: string;
+  };
+};
+type FromParentToChildMessageTypesMap = {
+  "sb-init": {
+    peerId: string;
+    userId?: string;
+    appId: string;
+    sessionRecordingKey?: string;
+    aiState?: {
+      generationState: AiGenerationState;
+      editingComponents: SbElement[];
+    };
+  };
+  "sb-bootstrap-response": {
+    userId?: string;
+    appId: string;
+    token: string;
+    accessToken: string;
+    /** @deprecated Use agentUrls instead */
+    agentUrl?: string;
+    agentUrls: string[];
+    logContext: Record<string, unknown>;
+    featureFlags?: Record<string, unknown>;
+    sessionRecordingKey?: string;
+  };
+  "sb-editor-request-bootstrap": void;
+  "sb-update-active-agents": {
+    agentUrls: string[];
+  };
+  "sb-update-property-with-effects": {
+    sourceId: string;
+    callbackId: string;
+    updates: Record<string, PropertyInfo<unknown>>;
+    transaction: TransactionInfo;
+  };
+  "sb-edit-operation-acknowledge": EditOperationPayload<EditOperationType>;
+  "sb-retrieve-property-panel-props": {
+    sourceId: string;
+  };
+  "sb-global-sync": {
+    global: Record<string, unknown>;
+  };
+  "parent-action-batch": PayloadAction<unknown>[];
+  click: void;
+  "register-keypress": {
+    keys: string;
+    options?: any;
+  };
+  "canvas-scale-update": {
+    canvasScaleFactor: number;
+  };
+  "resolve-promise": unknown;
+  "reject-promise": unknown;
+  "flash-element": {
+    elementId: string;
+  };
+  "set-theme": {
+    theme: unknown;
+    updateRedux?: boolean;
+    storedTypographies?: unknown;
+  };
+  getDropTarget: {
+    parentId: string;
+  };
+  keypress: {
+    keys: string;
+    eventInfo: {
+      code: string;
+      key: string;
+      altKey: boolean;
+      ctrlKey: boolean;
+      shiftKey: boolean;
+    };
+  };
+  dragstart: Record<string, unknown> & {
+    type: string;
+  };
+  "sb-create-component": {
+    componentType: string;
+    parent: SourceLocation;
+    scopeName: string;
+    baseProperties?: Record<string, PropertyInfo>;
+    skipSecondaryComponentsCreation?: boolean;
+    otherComponentsUpdates?: Record<SbElement, Record<string, PropertyInfo>>;
+  };
+  "sb-toggle-live-preview": {
+    isLivePreview: boolean;
+  };
+  /**
+   * Request a route change in the child
+   */
+  "route-change": RouteChangePayload;
+  "ai-updates": AiUpdatesPayload["parentToChild"];
+};
+type FromParentToChildMessageTypes = keyof FromParentToChildMessageTypesMap;
+type FromChildToParentMessageTypesMap = {
+  "sb-ready": void;
+  "iframe-action-batch": PayloadAction<unknown>[];
+  /**
+   * Navigate the parent window to a new URL
+   */
+  "navigate-to": {
+    url: string;
+    newWindow?: boolean;
+  };
+  "sb-iframe-track-changes": Record<string, unknown>;
+  "resolve-promise": unknown;
+  "reject-promise": unknown;
+  "sb-editor-request-bootstrap": void;
+  "reload-configs": void;
+  "sb-edit-operation-request": EditOperationPayload<EditOperationType>;
+  "client:selectWidgets": {
+    sourceIds: SbElement[];
+  };
+  getDropTargetResult: {
+    offset: XYCoord;
+    size: {
+      height: number;
+      width: number;
+    };
+  };
+  keypress: {
+    keys: string;
+    eventInfo: {
+      code: string;
+      key: string;
+      altKey: boolean;
+      ctrlKey: boolean;
+      shiftKey: boolean;
+    };
+  };
+  "register-click": {
+    type: string;
+    context: {
+      clientX: number;
+      clientY: number;
+      sourceId: string;
+      insertionIndexes?: {
+        sectionInsertionPosition?: number;
+        columnInsertionPosition?: number;
+        stackInsertionPosition?: number;
+      };
+    };
+  };
+  "api/started-execution": {
+    apiName: string;
+  };
+  "api/set-api-response": {
+    apiName: string;
+    response: unknown;
+  };
+  "api/stream-event": {
+    event: StreamEvent;
+    apiName: string;
+  };
+  "api/stream-message": {
+    message: any;
+    apiName: string;
+  };
+  "authenticate-api-request": {
+    apiId: string;
+    callbackId: string;
+  };
+  "set-apis-deployed-mode": {
+    apis: Array<DeleteMeLibraryApi & {
+      scopeId: string;
+    }>;
+    callbackId: string;
+  };
+  /**
+   * Notify the parent of a route change
+   */
+  "route-change": RouteChangePayload;
+  "ai-updates": AiUpdatesPayload["childToParent"];
+  undo: void;
+  redo: void;
+  "socket/error": {
+    message: string;
+  };
+  "runtime-error": RuntimeErrorData;
+  "clear-runtime-error": {
+    id: string;
+  };
+  "logout-integration": {
+    callbackId: string;
+  };
+} & AppToEditorMessage<PropertiesPanelDefinition>;
+type FromChildToParentMessageTypes = keyof FromChildToParentMessageTypesMap;
+//#endregion
+//#region src/lib/internal-details/lib/evaluator/names.d.ts
+type Name = {
+  value: string;
+  isAnonymous: boolean;
+};
+//#endregion
+//#region src/lib/user-facing/event-flow.d.ts
+declare class EventFlow implements IEventFlow<StepDef, ScopedState, ValueInputProp> {
+  steps: StepDef[];
+  private constructor();
+  private addStep;
+  static start(): EventFlow;
+  static runJS(handler: (s: ScopedState | any, additionalProps?: Record<string, any>) => void): EventFlow;
+  runJS(handler: (s: ScopedState | any, additionalProps?: Record<string, any>) => void): this;
+  static navigateTo(url: ValueInputProp<string>, opts?: {
+    newWindow?: boolean;
+    replaceHistory?: boolean;
+    arguments?: string;
+  }): EventFlow;
+  navigateTo(url: ValueInputProp<string>, opts?: {
+    newWindow?: boolean;
+    replaceHistory?: boolean;
+    arguments?: string;
+  }): this;
+  static navigateToApp(appId: string): EventFlow;
+  navigateToApp(appId: string): this;
+  static navigateToRoute(route: string): EventFlow;
+  navigateToRoute(route: string): this;
+  static setQueryParams(params: Record<string, ValueInputProp<string>>, opts?: {
+    keep?: boolean;
+  }): EventFlow;
+  setQueryParams(params: Record<string, ValueInputProp<string>>, opts?: {
+    keep?: boolean;
+  }): this;
+  static controlSlideout(slideout: WithBindingIdentifier, opts: {
+    action: "open" | "close";
+  }): EventFlow;
+  controlSlideout(slideout: WithBindingIdentifier, opts: {
+    action: "open" | "close";
+  }): this;
+  static controlModal(modal: WithBindingIdentifier, opts: {
+    action: "open" | "close";
+  }): EventFlow;
+  controlModal(modal: WithBindingIdentifier, opts: {
+    action: "open" | "close";
+  }): this;
+  static controlTimer(stateTimer: WithBindingIdentifier, opts: {
+    action: "start" | "stop" | "toggle";
+  }): EventFlow;
+  controlTimer(stateTimer: WithBindingIdentifier, opts: {
+    action: "start" | "stop" | "toggle";
+  }): this;
+  static runApis(apis: any[], opts?: {
+    onSuccess?: EventFlow;
+    onError?: EventFlow;
+  }): EventFlow;
+  runApis(apis: any[], opts?: {
+    onSuccess?: EventFlow;
+    onError?: EventFlow;
+  }): this;
+  static cancelApis(apis: any[], onCancel?: EventFlow): EventFlow;
+  cancelApis(apis: any[], onCancel?: EventFlow): this;
+  static resetComponent(component: WithBindingIdentifier, opts?: {
+    property: string;
+  }): EventFlow;
+  resetComponent(component: WithBindingIdentifier, opts?: {
+    property: string;
+  }): this;
+  static resetStateVar(state: WithBindingIdentifier): EventFlow;
+  resetStateVar(state: WithBindingIdentifier): this;
+  static setStateVar(stateVarName: WithBindingIdentifier, opts: {
+    value: ValueInputProp;
+  }): EventFlow;
+  setStateVar(stateVar: WithBindingIdentifier, opts: {
+    value: ValueInputProp;
+  }): this;
+  callFunction(component: () => unknown): this;
+  static callFunction(component: () => unknown): EventFlow;
+  static setComponentProperty(component: WithBindingIdentifier, opts: {
+    property: string;
+    value: ValueInputProp;
+  }): EventFlow;
+  setComponentProperty(component: WithBindingIdentifier, opts: {
+    property: string;
+    value: ValueInputProp;
+  }): this;
+  static showAlert(message: ValueInputProp<string>, opts?: {
+    type?: NotificationType;
+    durationMs?: number;
+    position?: NotificationPosition;
+  }): EventFlow;
+  showAlert(_message: ValueInputProp<string>, _opts?: {
+    type?: NotificationType;
+    durationMs?: number;
+    position?: NotificationPosition;
+  }): this;
+  static setProfile(profileId: string, opts: {
+    action: "set" | "unset";
+  }): EventFlow;
+  setProfile(profileId: string, opts: {
+    action: "set" | "unset";
+  }): this;
+  static triggerEvent(eventName: string, opts?: {
+    data: Record<string, string>;
+  }): EventFlow;
+  triggerEvent(eventName: string, opts?: {
+    data: Record<string, string>;
+  }): this;
+  static sequence(eventFlows: EventFlow[]): EventFlow;
+  sequence(eventFlows: EventFlow[]): this;
+  build(): StepDef[];
+}
+//#endregion
+//#region src/lib/user-facing/properties-panel/validators.d.ts
+type ValidationResult<T = any> = {
+  valid: false;
+  message: string;
+  invalidValue: any;
+} | {
+  valid: true;
+  result: T;
+};
+type ValidateFn<T> = (value: any, entity: Entity) => ValidationResult<T>;
+//#endregion
+//#region src/lib/internal-details/lib/evaluator/base-entity-manager.d.ts
+type SingleInputProp<T = EntityOutputProp, ARGS extends any[] = any[]> = [T] extends [EntityOutputProp] ? T extends EventFlow ? EventFlow | Callback : ValueInputProp<T, ARGS> : never;
+type NestedInputProp<T, ARGS extends any[] = any[]> = T extends object ? { [K in keyof T]: SingleInputProp<T[K], ARGS> | NestedInputProp<T[K], ARGS> } : never;
+type InputProp<T = EntityOutputProp, ARGS extends any[] = any[]> = SingleInputProp<T, ARGS> | NestedInputProp<T, ARGS>;
+type EntityFunction<ARGS extends any[] = any[], R = EntityOutputProp> = (this: Entity, state: ScopedState, ...ARGS: ARGS) => R;
+//#endregion
+//#region src/edit-mode/features/runtime-widgets-manager.d.ts
+type ChildFunction = React$1.FunctionComponent;
+type ChildElement = {
+  isSupportedElement: true;
+  isSbComponent: boolean;
+  value: SbInstance;
+} | {
+  isSupportedElement: true;
+  isSbComponent: false;
+  value?: SbInstance;
+} | {
+  isSupportedElement: false;
+  isSbComponent: false;
+  value: ChildFunction;
+};
+type RuntimeWidgetMeta = {
+  instanceId: SbInstance;
+  sourceId: SbElement;
+  isRoot: boolean;
+  isInsideRoot: boolean;
+  rootInstanceId?: SbInstance;
+  isSbComponent: boolean;
+  isOptimistic: boolean;
+  scopeId?: string;
+  type?: string;
+  name?: Name;
+  props?: Record<string, unknown>;
+  children?: ChildElement[];
+  parentInstanceId?: SbInstance;
+  directParentInstanceId?: SbInstance;
+  isUnmounted?: boolean;
+};
+//#endregion
+//#region src/lib/internal-details/lib/features/component-registry.d.ts
+type DefaultTagNames = {
+  container: string;
+  button: string;
+  text: string;
+};
+/**
+ * TODO: The component registry could be split into two a thin layer always on, and move some stuff to the EditStore.
+ * Some of the actions (rename, delete) and some of the data (isDroppable) are editor-only.
+ */
+//#endregion
+//#region src/lib/internal-details/sb-wrapper.d.ts
+type InjectedProps = {
+  dropTargetRef?: React$1.Ref<HTMLElement>;
+  editorProps?: ElementPassthroughProps;
+};
+type ParentInfo = {
+  type?: string;
+};
+interface CreationContext {
+  generateUniqueName: (baseName: string) => string;
+  parentInfo: ParentInfo;
+  defaultTagNames: DefaultTagNames;
+  selfTagName: string;
+}
+type PropertyValues<Def extends PropertiesDefinition> = { [K in keyof GetAllPropsFromDefinition<Def>]?: PropertyInfo | PropertyValues<Def> };
+type GetAllPropsFromDefinition<Def extends PropertiesDefinition> = { [SectionKey in keyof Def]: Def[SectionKey] extends {
+  props: infer Props;
+} ? Props extends Record<string, any> ? Props : never : never }[keyof Def];
+interface EditorTemplate<Def extends PropertiesDefinition> {
+  catalog?: Catalog;
+  /***
+   * Config for the newly created component when added to the canvas from the Editor.
+   * @returns a single CreateRequest or an array of CreateRequests.
+   *
+   * When returning Array<CreateRequests>:
+   *  - The 1st CreateRequest's type must match the componentType passed to createComponent.
+   *  - The last CreateRequest's will be the selected component after drag & drop.
+   *
+   *  Example: [Modal, Button]
+   *  A modal that when drag & dropped on the page will add a trigger button.
+   *  The modal is closed by default, so the selected component after drop will be the trigger button.
+   */
+  create?: (context: CreationContext) => CreateRequest<Def> | Array<CreateRequest<Def>>;
+}
+interface CreateRequest<Def extends PropertiesDefinition> {
+  type: string;
+  /**
+   * Should it automatically generate a binding?
+   * e.g: <Input bind={Input1}>
+   *
+   * Default is false (no binding)
+   *
+   * `generateBinding` can also receive a string. e.g: "Input1".
+   *  This is useful if you need to create children components that rely on the parent's binding (e.g: a button inside a modal to close the modal).
+   *  To generate these unique names, you can use `context.generateUniqueName` and pass the component type (e.g: "Modal")
+   *
+   * A good rule of thumb:
+   * - Components that expose a user's input should have an automatically generated binding (e.g: Input, Checkbox, Table, etc)
+   * - Components that don't expose a user's input should not have an automatically generated binding (e.g: Button, Text, etc)
+   *
+   * Note:
+   * Apps builders can always manually set a binding on the editor or source code.
+   */
+  generateBinding?: boolean | string;
+  properties?: PropertyValues<Def>;
+  createAt?: "root" | "dropLocation";
+  children?: CreateChild$1[];
+}
+interface ChainableComponent<PD extends PropertiesDefinition, EP extends ExternalProps<PD>> extends React$1.FC<EP> {
+  addEditorTemplate: (config: EditorTemplate<PD>) => ChainableComponent<PD, EP>;
+  editorConfig: (config: EditorConfig$1) => ChainableComponent<PD, EP>;
+  isSb: symbol;
+  sbType: string;
+  displayName: string;
+  isCustomComponent: boolean;
+  isDroppable: boolean;
+  propertiesDefinition: PropertiesDefinition;
+}
+/**
+ * Register a component to be used with the framework.
+ *
+ * Returns a chainable component that can be used as a React component and also provides
+ * additional methods for editor integration.
+ *
+ * // TODO: All these params should be migrated to editor template or editorConfig
+ * @param type - The string identifier for the component type. This should be unique, is used internally to reference the component, and is also the tag name on source code.
+ * @param config - An object containing configuration options for the component:
+ *   - customComponent (optional): If true, marks this as a custom user-defined component.
+ *   - propertiesDefinition: The definition of the component's properties, used for property panel generation and validation.
+ * @param Component - The React functional component implementation. Receives internal props (including drop target props) as its argument.
+ *
+ * @returns A chainable component that can be used as a React component and also provides methods for editor integration (such as addEditorTemplate and editorConfig).
+ */
+//#endregion
+//#region src/lib/user-facing/component-base/sb-component.d.ts
+type SbComponentProps<El = HTMLElement> = {
+  name?: string;
+  bind?: WithBindingIdentifier;
+  width?: Dim$1;
+  height?: Dim$1;
+  minWidth?: Dim$1;
+  minHeight?: Dim$1;
+  maxWidth?: Dim$1;
+  maxHeight?: Dim$1;
+  sourceId?: SbElement;
+  /**
+   * undefined means auto, true means always loading, false means never loading
+   */
+  loading?: boolean;
+} & Omit<React.HTMLAttributes<El>, "height" | "width">;
+//#endregion
+//#region src/lib/user-facing/properties-panel/props-builder.d.ts
+type SideEffectCallback = (params: {
+  sourceId: SbElement;
+  updates: Record<string, PropertyInfo<unknown>>;
+  widgetMeta: RuntimeWidgetMeta;
+  widgetState: Entity | ScopedState | undefined;
+  propertiesDefinition: PropertiesDefinition;
+}) => Record<SbElement, {
+  meta?: Record<string, unknown>;
+  props?: Record<string, PropertyInfo<unknown>>;
+}>;
+type ManagedProp<T extends DataType = DataType> = PropertyForData<T> & {
+  validate?: ValidateFn<any>;
+  default?: SingleInputProp<T>;
+  defaultOnAdd?: SingleInputProp<T>;
+  onEditProperty?: SideEffectCallback;
+  onEvaluateProperty?: SideEffectCallback;
+  /**
+   * Controls binding nesting behavior:
+   * - true: Allows bindings to be nested at any depth within this property
+   * - false: Only allows bindings at the top level (unless the property is composite)
+   */
+  nestedBindings?: boolean;
+  /**
+   * Indicates this property should be evaluated per-context (e.g., per-row in tables)
+   * When true, the property value will be evaluated for each context with access to context variables
+   */
+  contextual?: boolean;
+  computedArgs?: EvaluateOrValueComputedArgs;
+  /**
+   * Custom type hint for documentation generation
+   * When set, this will override the auto-generated type in generated docs
+   */
+  typeHint?: string;
+  isMetaProp?: boolean;
+  isFunctionProp?: boolean;
+  hasActionPanel?: boolean;
+};
+/**
+ * Merges shared and variant properties for union types without creating intersections
+ * Variant properties override shared properties with the same key
+ */
+type MergeUnionVariant<SHARED extends Record<string, Prop<any, any>>, VARIANT extends Record<string, Prop<any, any>>> = Omit<SHARED, keyof VARIANT> & VARIANT;
+/**
+ * Converts a union type to an intersection type
+ * Used to merge multiple section props into a single props type
+ */
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends ((x: infer I extends U) => void) ? I : never;
+/**
+ * Controls how default values affect property optionality
+ * - RequiredIfDefault: Properties with default values become required
+ * - AlwaysOptional: All properties become optional regardless of defaults
+ */
+type DefaultValueBehavior = "RequiredIfDefault" | "AlwaysOptional";
+/**
+ * Extracts the concrete type from a property definition
+ *
+ * For evaluated props: returns the actual value type
+ *
+ * For non-evaluated props: returns InputProp<ValueType>
+ */
+/**
+ * Extracts the concrete type from a property definition
+ * Enhanced to handle contextual properties
+ */
+type ExtractPropType<T, DefaultsBehavior extends DefaultValueBehavior, IsEvaluated extends boolean> = T extends Record<string, Prop<any, any, any>> ? ExtractProps<T, DefaultsBehavior, IsEvaluated> : T extends RecordProp<infer U> ? Record<string, ExtractProps<U, DefaultsBehavior, IsEvaluated>> : T extends CompositeProp<infer U> ? IsEvaluated extends true ? ExtractProps<U, DefaultsBehavior, IsEvaluated> : InputProp<ExtractProps<U, DefaultsBehavior, true>> : T extends UnionProp<infer SHARED, infer VARIANTS> ? VARIANTS extends readonly any[] ? { [I in keyof VARIANTS]: ExtractProps<MergeUnionVariant<SHARED, VARIANTS[I]>, DefaultsBehavior, IsEvaluated> }[number] : never : T extends Prop<infer V, infer _HasDefault, infer ContextualProps> ? IsEvaluated extends true ? ContextualProps extends undefined ? V extends EventFlow ? (...args: any[]) => Promise<void> : V : ContextualProps extends any[] ? (...args: ContextualProps) => V : InputProp<V> : InputProp<V> : never;
+/**
+ * Extracts a flat props object from a properties definition
+ * Handles optionality based on DefaultValueBehavior
+ */
+type ExtractProps<T, DefaultsBehavior extends DefaultValueBehavior, IsEvaluated extends boolean> = T extends Record<string, Section> ? ExtractProps<MergeSections<T>, DefaultsBehavior, IsEvaluated> : T extends Record<string, Prop<any, any, any>> ? DefaultsBehavior extends "AlwaysOptional" ? { [K in keyof T]?: ExtractPropType<T[K], DefaultsBehavior, IsEvaluated> } : { [K in keyof T as T[K] extends Prop<any, infer HasDefault, any> ? HasDefault extends true ? K : never : never]: ExtractPropType<T[K], DefaultsBehavior, IsEvaluated> } & { [K in keyof T as T[K] extends Prop<any, infer HasDefault, any> ? HasDefault extends false ? K : never : never]?: ExtractPropType<T[K], DefaultsBehavior, IsEvaluated> } : never;
+/**
+ * Handles non Prop types, aka our default types and CSS props
+ */
+type RawPropsToExternal<T = Record<string, unknown>> = { [K in keyof T as undefined extends T[K] ? never : K]: SingleInputProp<T[K]> } & { [K in keyof T as undefined extends T[K] ? K : never]?: SingleInputProp<Exclude<T[K], undefined>> };
+type SectionPropertiesPanelConfig = {
+  showHeader?: boolean;
+  isDefaultOpen?: boolean;
+  headerType?: HeaderType;
+  subHeader?: string;
+};
+/**
+ * Merges all sections in a properties definition into a single props type
+ */
+type MergeSections<T extends Record<string, Section>, Merged = UnionToIntersection<T[keyof T]>> = Merged extends Section<infer U> ? U : never;
+/**
+ * Identical to InternalProps but without the base props
+ */
+type EntityProps<Definition extends PropertiesDefinition, MergedSections = MergeSections<Definition>> = ExtractProps<MergedSections, "RequiredIfDefault", true>;
+/**
+ * Internal props used by the component implementation
+ * - Properties with defaults are required
+ * - Properties are fully evaluated to their final types
+ */
+type InternalProps<Definition extends PropertiesDefinition, FlattenedProps = EntityProps<Definition>, BaseProps = Omit<SbComponentProps, keyof FlattenedProps>> = FlattenedProps & BaseProps & InjectedProps;
+type MakeOptional<T, K extends string> = Omit<T, K & keyof T> & Partial<Pick<T, K & keyof T>>;
+type CleanProps<T> = { [K in keyof T as string extends K ? never : K]: T[K] };
+type InternalPropsWithOptional<Definition extends PropertiesDefinition, OptionalProps extends string, InternalPropsWithDefinition = InternalProps<Definition>> = InternalPropsWithDefinition extends infer U ? U extends any ? MakeOptional<CleanProps<U>, OptionalProps> & {
+  [key: string]: any;
+} : never : never;
+/**
+ * External props exposed to component consumers
+ * - All properties are optional regardless of defaults
+ * - Properties accept InputProp values (bindings/functions)
+ */
+type ExternalProps<Definition extends PropertiesDefinition, MergedSections = MergeSections<Definition>, FlattenedProps = ExtractProps<MergedSections, "AlwaysOptional", false>, BaseProps = Omit<SbComponentProps, keyof FlattenedProps>> = FlattenedProps & RawPropsToExternal<BaseProps>;
+type PropertiesDefinition = Record<string, Section>;
+type SectionDefinition<T extends Record<string, Prop<any, any>>> = {
+  props: T;
+  showHeader?: boolean;
+  isDefaultOpen?: boolean;
+  headerType?: HeaderType;
+  subHeader?: string;
+};
+declare class Section<T extends Record<string, Prop<any, any>> = Record<string, Prop<any, any>>> {
+  readonly category: PropsPanelCategory;
+  props: T;
+  propertiesPanelConfig: SectionPropertiesPanelConfig;
+  constructor(category: PropsPanelCategory);
+  static category(category: PropsPanelCategory): Section<Record<string, Prop<any, any, undefined>>>;
+  children<INP extends Record<string, Prop<any, any>> | CompositeProp<any> | UnionProp<any, any>, OUT extends (INP extends CompositeProp<infer CU> ? CU : INP extends UnionProp<infer SHARED, infer VARIANTS> ? VARIANTS extends readonly any[] ? { [I in keyof VARIANTS]: MergeUnionVariant<SHARED, VARIANTS[I]> }[number] : never : INP)>(props: INP): Section<T & OUT>;
+  add: <INP extends Record<string, Prop<any, any>> | CompositeProp<any> | UnionProp<any, any>, OUT extends (INP extends CompositeProp<infer CU> ? CU : INP extends UnionProp<infer SHARED, infer VARIANTS> ? VARIANTS extends readonly any[] ? { [I in keyof VARIANTS]: MergeUnionVariant<SHARED, VARIANTS[I]> }[number] : never : INP)>(props: INP) => Section<T & OUT>;
+  propertiesPanel(config: Omit<SectionDefinition<any>, "props">): this;
+  get name(): "Content" | "Routing" | "Interaction" | "Layout" | "Appearance" | "Permissions" | "Uncategorized" | "Event handlers" | "Custom styles";
+}
+declare class Prop<Type extends DataType, _HasDefault extends boolean = false, _ContextualArgs extends any[] | undefined | ((entity: Entity) => any[] | undefined) = undefined> {
+  protected prop: ManagedProp<Type>;
+  /**
+   * Relations are an array of arrays
+   * each sub-array is AND requirements, and each element is an OR requirement
+   */
+  protected relations: Relation[][];
+  protected constructor(typeString: DataTypeString, defaultValidator?: ValidateFn<Type | undefined>);
+  static unset(): Prop<undefined>;
+  static string<T extends string>(): Prop<T>;
+  static number<T extends number>(): Prop<T>;
+  static boolean<T extends boolean>(): Prop<T>;
+  static array<T = Array<any>>(): Prop<T[]>;
+  static any<T = any>(): Prop<T>;
+  static jsx<T extends ReactNode>(): Prop<T>;
+  static dimension<T extends Dim$1<DimModes$1>>(): Prop<T>;
+  static literal<T extends Readonly<string | number | boolean>>(value: T): Prop<T, true>;
+  static event(): Prop<EventFlow>;
+  static children(): Prop<any>;
+  static function<ARGS extends any[] = any[], RETURN = any>(implementation: EntityFunction<ARGS, RETURN>): FunctionProp<ARGS, RETURN>;
+  /**
+   * Creates an internal property that is not exposed in the entity's public interface,
+   * not tracked for reactivity/syncing, and not serialized. This is useful for
+   * storing implementation details like SuspensibleAPI instances that other
+   * properties can reference via `this._propertyName`.
+   */
+  static internal<T = any>(factory: () => T): Prop<T, true>;
+  /**
+   * Creates a composite property, which is a property that contains nested properties. For example,
+   * the following composite property:
+   *
+   * ```ts
+   * const prop = Prop.composite({
+   *   name: Prop.string(),
+   *   age: Prop.number(),
+   * });
+   * ```
+   *
+   * is equivalent to the following type:
+   *
+   * ```ts
+   * type Prop = {
+   *   name: string;
+   *   age: number;
+   * };
+   * ```
+   */
+  static composite<T extends CompositeInputs>(props: T): CompositeProp<T>;
+  /**
+   * Creates a record property, which is a record that maps string keys to the nestedproperties. For example,
+   * the following record property:
+   *
+   * ```ts
+   * const prop = Prop.record({
+   *   name: Prop.string(),
+   *   age: Prop.number(),
+   * });
+   * ```
+   *
+   * is equivalent to the following type:
+   *
+   * ```ts
+   * type Prop = Record<string, {
+   *   name: string;
+   *   age: number;
+   * }>;
+   * ```
+   */
+  static record<T extends CompositeInputs>(props: T): RecordProp<T>;
+  static union<SHARED extends Record<string, Prop<unknown, boolean>>, VARIANTS extends UnionVariant<SHARED>[] = UnionVariant<SHARED>[]>(props: {
+    shared: SHARED;
+    variants: VARIANTS;
+  }): UnionProp<SHARED, VARIANTS, VARIANTS extends readonly any[] ? { [I in keyof VARIANTS]: SHARED & VARIANTS[I] }[number] : never>;
+  readable(): this;
+  writable(): this;
+  readAndWrite(): this;
+  default(de: SingleInputProp<DataType>): Prop<Type, true>;
+  computed(computeFn: SingleInputProp<DataType>): Prop<Type, true>;
+  allowNestedBindings(): Prop<Type, true>;
+  contextual<TContext extends any[] | undefined = any[]>(computedArgs?: EvaluateOrValueComputedArgs): Prop<Type, _HasDefault, TContext>;
+  validate(validateFn: ((value: any) => ValidationResult<Type>) | ValidateFn<any>): this;
+  setName(name: string): this;
+  onEdit(callback: SideEffectCallback): this;
+  onEvaluate(callback: SideEffectCallback): this;
+  propertiesPanel<CT extends ControlType>(schema: Omit<Partial<PropertiesPanelDisplay<Type, CT>>, "isTriggerProperty">): this;
+  setDisplayProperty<K extends keyof PropertiesPanelDisplay<Type>>(property: K, value: PropertiesPanelDisplay<Type>[K]): this;
+  docs(docs: Exclude<PropertyForData<DataType>["docs"], undefined>): this;
+  /**
+   * Sets a custom type hint for documentation generation.
+   * This will override the auto-generated type in generated docs.
+   *
+   * @param typeHint The TypeScript type string to display in documentation
+   * @example .typeHint("CSSProperties")
+   * @example .typeHint("Record<string, { color: string; backgroundColor?: string }>")
+   */
+  typeHint(typeHint: string): this;
+  build(): ManagedProp<Type>;
+  toDefinition(entity?: Entity, scopedState?: ScopedState): WidgetPropertyDefinition<DataType> | undefined;
+  getRelations(): Relation[][];
+  dependsOn(relations: Relation[][]): this;
+  hasPropertiesPanelDisplay(): boolean;
+  get type(): DataTypeString;
+  get path(): string;
+  get onEditProperty(): SideEffectCallback | undefined;
+  get onEvaluateProperty(): SideEffectCallback | undefined;
+}
+type CompositeInputs = Record<string, Section> | Section | Record<string, Prop<unknown, boolean>>;
+/**
+ * See {@link Prop.composite}
+ */
+declare class CompositeProp<T extends CompositeInputs> extends Prop<unknown, boolean> {
+  typeString: "composite";
+  nestedProps: T;
+  constructor(props: T);
+  getProps(): T;
+  toDefinition(entity: Entity, scopedState: ScopedState): WidgetPropertyDefinition<DataType> | undefined;
+  propertiesPanelChildrenDisplayMode(): ({
+    type: "inline";
+  } | {
+    type: "popover";
+    title?: string;
+    panelIdPropertyName?: string;
+    titlePropertyName?: string;
+    addButton?: boolean;
+  }) | ((this: any, state: any, path: string) => ({
+    type: "inline";
+  } | {
+    type: "popover";
+    title?: string;
+    panelIdPropertyName?: string;
+    titlePropertyName?: string;
+    addButton?: boolean;
+  }) | undefined) | undefined;
+  typeHint(typeHint: string): this;
+}
+/**
+ * See {@link Prop.record}
+ */
+declare class RecordProp<T extends CompositeInputs> extends Prop<unknown, boolean> {
+  typeString: "recordOf";
+  nestedProps: T;
+  constructor(props: T);
+  getProps(): T;
+  toDefinition(entity: Entity, scopedState: ScopedState): WidgetPropertyDefinition<DataType> | undefined;
+  typeHint(typeHint: string): this;
+}
+interface ActionPanel {
+  arguments?: Record<string, Prop<any>>;
+}
+declare class FunctionProp<ARGS extends any[] = any[], RETURN = any> extends Prop<EntityFunction<ARGS, RETURN>, true> {
+  typeString: "function";
+  private _actionPanel;
+  constructor(implementation: EntityFunction<ARGS, RETURN>);
+  actionPanel(panel?: ActionPanel): this;
+  getActionPanel(): ActionPanel | undefined;
+  hasActionPanel(): boolean;
+}
+type UnionVariant<SHARED extends Record<string, Prop<any>>> = { [K in keyof SHARED]: Prop<any> };
+declare class UnionProp<SHARED extends Record<string, Prop<unknown, boolean>>, VARIANTS extends UnionVariant<SHARED>[] = UnionVariant<SHARED>[], _OUTPUT = (VARIANTS extends readonly any[] ? { [I in keyof VARIANTS]: SHARED & VARIANTS[I] }[number] : never)> extends Prop<any> {
+  typeString: "union";
+  shared: SHARED;
+  variants: VARIANTS;
+  constructor(shared: SHARED, variants: VARIANTS);
+  getProps(): SHARED & Record<string, Prop<any, false, undefined>>;
+}
+//#endregion
+//#region src/lib/user-facing/components/container/props.d.ts
+/**
+ * TODO:
+ * - make default and options dynamic for distribution and alignment
+ * - enable tooltip for radio group options
+ * - should not need default min/max width/height, probably just minHeight
+ * - the alignments props only show when explicitly set layout in code because of using Union
+ * - use default func once supported for composite props, apply it to padding, border, borderRadius, and backgroundColor. Otherwise, prop panel control will not show the correct value
+ */
+declare const propertiesDefinition: {
+  contents: Section<Record<string, Prop<any, any, undefined>> & {
+    children: Prop<any, false, undefined>;
+  }>;
+  layout: Section<((Record<string, Prop<any, any, undefined>> & ((Omit<{
+    layout: Prop<ContainerLayout, true, undefined>;
+  }, "layout" | "verticalAlign" | "horizontalAlign"> & {
+    readonly verticalAlign: Prop<"top" | "center" | "bottom" | "space-between" | "space-around", true, undefined>;
+    readonly horizontalAlign: Prop<"center" | "stretch" | "left" | "right", true, undefined>;
+    readonly layout: Prop<"vertical", true, undefined>;
+  }) | (Omit<{
+    layout: Prop<ContainerLayout, true, undefined>;
+  }, "layout" | "verticalAlign" | "horizontalAlign"> & {
+    readonly verticalAlign: Prop<"top" | "center" | "bottom" | "stretch", true, undefined>;
+    readonly horizontalAlign: Prop<"center" | "space-between" | "space-around" | "left" | "right", true, undefined>;
+    readonly layout: Prop<"horizontal", true, undefined>;
+  }))) & {
+    shouldScrollContents: Prop<boolean, true, undefined>;
+  }) & {
+    isVisible: Prop<boolean, true, undefined>;
+  }>;
+  appearance: Section<Record<string, Prop<any, any, undefined>> & {
+    variant: Prop<ContainerVariant, true, undefined>;
+    backgroundColor: Prop<string, true, undefined>;
+    border: Prop<_superblocksteam_library_shared_types7.PerSideBorder, true, undefined>;
+    borderRadius: Prop<_superblocksteam_library_shared_types7.PerCornerBorderRadius, true, undefined>;
+    loading: Prop<boolean, true, undefined>;
+  }>;
+};
+//#endregion
+//#region src/lib/user-facing/components/container/index.d.ts
+type OptionalProps$1 = "backgroundColor" | "border" | "borderRadius" | "loading";
+type ContainerProps<T> = Omit<InternalPropsWithOptional<typeof propertiesDefinition, OptionalProps$1>, "layout"> & {
+  layout: T;
+};
+type UnstyledContainerProps = {
+  layout: ContainerLayout;
+  style?: CSSProperties;
+  className?: string;
+  children?: ReactNode;
+  isVisible?: boolean;
+  spacing?: Dim$1<"px">;
+  columns?: number;
+  rowHeight?: Dim$1<"px">;
+  border?: PerSideBorder;
+};
+declare const UnstyledInternalContainer: (props: UnstyledContainerProps) => react_jsx_runtime0.JSX.Element;
+/**
+ * TODO:
+ * - interaciton rect of children will show outside of container if overflow
+ * - move card style related defaultprops to props file and update dynamically when supported
+ * - the spacing prop is not same type between stack and grid, enable when we clean it up
+ * - consider border and padding for grid layout
+ * - border style are showing some control default value even actually undefined. styles are coming from container classes but ideally we should set them as default props?
+ * - move more props to inner layout component
+ */
+declare const InternalContainer: <T extends ContainerLayout>(props: ContainerProps<T>) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/lib/user-facing/components/page/index.d.ts
+declare const Page: ChainableComponent<{
+  contents: Section<Record<string, Prop<any, any, undefined>> & {
+    children: Prop<any, false, undefined>;
+  }>;
+  layout: Section<Record<string, Prop<any, any, undefined>> & {
+    maxHeight?: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined> | undefined;
+    minHeight?: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined> | undefined;
+    maxWidth?: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined> | undefined;
+    minWidth?: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined> | undefined;
+    width: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined>;
+    height: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined>;
+  }>;
+  appearance: Section<Record<string, Prop<any, any, undefined>> & {
+    loading: Prop<boolean, true, undefined>;
+  }>;
+  events: Section<Record<string, Prop<any, any, undefined>> & {
+    onLoad: Prop<EventFlow, false, undefined>;
+  }>;
+}, ExternalProps<{
+  contents: Section<Record<string, Prop<any, any, undefined>> & {
+    children: Prop<any, false, undefined>;
+  }>;
+  layout: Section<Record<string, Prop<any, any, undefined>> & {
+    maxHeight?: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined> | undefined;
+    minHeight?: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined> | undefined;
+    maxWidth?: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined> | undefined;
+    minWidth?: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined> | undefined;
+    width: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined>;
+    height: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined>;
+  }>;
+  appearance: Section<Record<string, Prop<any, any, undefined>> & {
+    loading: Prop<boolean, true, undefined>;
+  }>;
+  events: Section<Record<string, Prop<any, any, undefined>> & {
+    onLoad: Prop<EventFlow, false, undefined>;
+  }>;
+}>>;
+//#endregion
+//#region src/lib/user-facing/components/app/index.d.ts
+declare const App: ChainableComponent<{
+  contents: Section<Record<string, Prop<any, any, undefined>> & {
+    children: Prop<any, false, undefined>;
+  }>;
+  events: Section<Record<string, Prop<any, any, undefined>> & {
+    onLoad: Prop<EventFlow, false, undefined>;
+  }>;
+}, ExternalProps<{
+  contents: Section<Record<string, Prop<any, any, undefined>> & {
+    children: Prop<any, false, undefined>;
+  }>;
+  events: Section<Record<string, Prop<any, any, undefined>> & {
+    onLoad: Prop<EventFlow, false, undefined>;
+  }>;
+}>>;
+//#endregion
+//#region src/lib/user-facing/components/custom/register-custom-component.d.ts
+declare const defaultSectionsTemplate: () => {
+  appearance: Section<Record<string, Prop<any, any, undefined>> & {
+    loading: Prop<boolean, true, undefined>;
+    className: Prop<string, false, undefined>;
+  }>;
+  layout: Section<Record<string, Prop<any, any, undefined>> & {
+    maxHeight?: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined> | undefined;
+    minHeight?: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined> | undefined;
+    maxWidth?: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined> | undefined;
+    minWidth?: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined> | undefined;
+    width: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined>;
+    height: Prop<_superblocksteam_library_shared0.Dim<_superblocksteam_library_shared0.DimModes>, false, undefined>;
+  } & {
+    isVisible: Prop<boolean, true, undefined>;
+  }>;
+};
+type CustomComponentPropertiesDefinition = {
+  [key: string]: Prop<any>;
+} | {
+  [key: string]: Section<any>;
+};
+type StrictExtractProps<T, DefaultsBehavior extends "AlwaysOptional" | "RequiredIfDefault", IsEvaluated extends boolean> = { [K in keyof ExtractProps<T, DefaultsBehavior, IsEvaluated> as string extends K ? never : K]: ExtractProps<T, DefaultsBehavior, IsEvaluated>[K] };
+type WrappedEventProps<IP extends InternalProps<any>> = { [K in keyof IP]: IP[K] extends EventFlow | undefined ? () => Promise<void> : IP[K] };
+type SectionProps<PD extends Record<string, Prop<any>> | Record<string, Section<any>>> = PD extends Record<string, Prop<any>> ? Record<string, Section<any>> & ReturnType<typeof defaultSectionsTemplate> : PD;
+type CustomComponentProps<PD extends Record<string, Prop<any>> | Record<string, Section<any>>, SP extends SectionProps<PD> = SectionProps<PD>, IP extends InternalProps<SP> = InternalProps<SP>> = WrappedEventProps<IP>;
+type CustomComponentOutputProps<PD extends CustomComponentPropertiesDefinition> = StrictExtractProps<PD, "AlwaysOptional", false> & {
+  bind?: WithBindingIdentifier;
+} & StrictExtractProps<ReturnType<typeof defaultSectionsTemplate>, "AlwaysOptional", false>;
+declare function registerComponent<PD extends CustomComponentPropertiesDefinition>(name: string, propertiesDefinition: PD, component: React$1.FC<CustomComponentProps<PD>>): ChainableComponent<any, CustomComponentOutputProps<PD>>;
+//#endregion
+//#region src/lib/user-facing/components/types.d.ts
+type UnknownOption = string | Record<string, unknown> | {
+  label: string;
+  value: string;
+};
+//#endregion
+//#region src/lib/user-facing/entities/variable/index.d.ts
+type Props$3<T = any> = {
+  defaultValue: T;
+  persistence?: StateVarPersistence;
+};
+declare const StateVar: (args: RawPropsToExternal<Props$3<any>>) => {
+  [sbEntitySymbol]: true;
+  type: "StateVar";
+  defaultValue: any;
+  value: any;
+  persistence: _superblocksteam_library_shared_types7.ValueInputProp<StateVarPersistence, any[]> | undefined;
+} & _superblocksteam_library_shared_types7.AnonymousSbEntity;
+//#endregion
+//#region src/lib/user-facing/entities/timer/index.d.ts
+type Props$2 = {
+  intervalMs?: number;
+  startOnPageLoad?: boolean;
+  onFire?: EventFlow;
+};
+declare const Timer: (args: RawPropsToExternal<Props$2>) => {
+  [sbEntitySymbol]: true;
+  type: "Timer";
+  intervalMs: _superblocksteam_library_shared_types7.ValueInputProp<number, any[]> | undefined;
+  startOnPageLoad: _superblocksteam_library_shared_types7.ValueInputProp<boolean, any[]> | undefined;
+  onFire: _superblocksteam_library_shared_props1.Callback | EventFlow | undefined;
+} & _superblocksteam_library_shared_types7.AnonymousSbEntity;
+//#endregion
+//#region src/lib/user-facing/entities/api/index.d.ts
+type Props$1 = {
+  onSuccess?: EventFlow;
+  onError?: EventFlow;
+};
+declare const SbApi: (args: RawPropsToExternal<Props$1>) => {
+  [sbEntitySymbol]: true;
+  type: "SbApi";
+  onSuccess: _superblocksteam_library_shared_props1.Callback | EventFlow | undefined;
+  onError: _superblocksteam_library_shared_props1.Callback | EventFlow | undefined;
+} & _superblocksteam_library_shared_types7.AnonymousSbEntity;
+//#endregion
+//#region src/lib/user-facing/sb-provider.d.ts
+declare const SbProvider: ({
+  name,
+  settings,
+  children
+}: {
+  name: string;
+  settings?: Record<string, any> & {
+    theme?: Theme$1;
+    themeOverrides?: Partial<GeneratedTheme>;
+  };
+  children?: React$1.ReactNode;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/lib/user-facing/global-functions.d.ts
+declare function copyToClipboard(text: string, options?: {
+  debug?: boolean;
+  format?: string;
+}): void;
+declare function navigateTo(urlOrRoute: string, queryParams?: Record<string, any>, target?: string): boolean;
+declare function setQueryParams(queryParams?: Record<string, any>, preserveExistingQueryParams?: boolean): boolean;
+declare function download(data: any, fileName?: string, fileType?: string): void;
+declare function logoutIntegrations(): Promise<void>;
+//#endregion
+//#region src/lib/user-facing/properties-panel/mixins/loading.d.ts
+declare const loading: () => Prop<boolean, true, undefined>;
+//#endregion
+//#region src/lib/user-facing/properties-panel/mixins/layout-section.d.ts
+/**
+ * Sets width default to `fill` if no default width config provided.
+ * Sets height default to `fit` if no default height config provided.
+ */
+declare const size: ({
+  defaults,
+  defaultsOnAdd,
+  hasMinWidth,
+  hasMaxWidth,
+  hasMinHeight,
+  hasMaxHeight,
+  showMinWidth,
+  showMinHeight,
+  showMaxWidth,
+  showMaxHeight,
+  showWidth,
+  showHeight
+}?: {
+  defaults?: {
+    minWidth?: Dim$1<DimModes$1>;
+    maxWidth?: Dim$1<DimModes$1>;
+    minHeight?: Dim$1<DimModes$1>;
+    maxHeight?: Dim$1<DimModes$1>;
+    width?: Dim$1<DimModes$1>;
+    height?: Dim$1<DimModes$1>;
+  };
+  defaultsOnAdd?: {
+    minWidth?: Dim$1<DimModes$1>;
+    maxWidth?: Dim$1<DimModes$1>;
+    minHeight?: Dim$1<DimModes$1>;
+    maxHeight?: Dim$1<DimModes$1>;
+    width?: Dim$1<DimModes$1>;
+    height?: Dim$1<DimModes$1>;
+  };
+  hasMinWidth?: boolean;
+  hasMaxWidth?: boolean;
+  hasMinHeight?: boolean;
+  hasMaxHeight?: boolean;
+  showMinWidth?: (this: any, s: ScopedState) => boolean;
+  showMinHeight?: (this: any, s: ScopedState) => boolean;
+  showMaxWidth?: (this: any, s: ScopedState) => boolean;
+  showMaxHeight?: (this: any, s: ScopedState) => boolean;
+  showWidth?: (this: any, s: ScopedState) => boolean;
+  showHeight?: (this: any, s: ScopedState) => boolean;
+}) => {
+  maxHeight?: Prop<Dim$1<DimModes$1>, false, undefined> | undefined;
+  minHeight?: Prop<Dim$1<DimModes$1>, false, undefined> | undefined;
+  maxWidth?: Prop<Dim$1<DimModes$1>, false, undefined> | undefined;
+  minWidth?: Prop<Dim$1<DimModes$1>, false, undefined> | undefined;
+  width: Prop<Dim$1<DimModes$1>, false, undefined>;
+  height: Prop<Dim$1<DimModes$1>, false, undefined>;
+};
+/** @deprecated Using it will override the defaults values defined in size() for width */
+declare const widthWithoutFit: () => {
+  width: Prop<Dim$1<"px" | "columns" | "rows" | "fill" | "%">, false, undefined>;
+};
+declare const shouldScrollContents: (defaultValue?: boolean) => {
+  shouldScrollContents: Prop<boolean, true, undefined>;
+};
+declare const visible: () => {
+  isVisible: Prop<boolean, true, undefined>;
+};
+declare const margin: () => {
+  margin: Prop<{
+    top: Dim$1<"px">;
+    bottom: Dim$1<"px">;
+    left: Dim$1<"px">;
+    right: Dim$1<"px">;
+  } | undefined, true, undefined>;
+};
+declare const containerLayout: (sizeProps?: Record<string, Prop<any, any>>) => UnionProp<{
+  layout: Prop<ContainerLayout, true, undefined>;
+}, [{
+  readonly verticalAlign: Prop<"top" | "center" | "bottom" | "space-between" | "space-around", true, undefined>;
+  readonly horizontalAlign: Prop<"center" | "stretch" | "left" | "right", true, undefined>;
+  readonly layout: Prop<"vertical", true, undefined>;
+}, {
+  readonly verticalAlign: Prop<"top" | "center" | "bottom" | "stretch", true, undefined>;
+  readonly horizontalAlign: Prop<"center" | "space-between" | "space-around" | "left" | "right", true, undefined>;
+  readonly layout: Prop<"horizontal", true, undefined>;
+}], ({
+  layout: Prop<ContainerLayout, true, undefined>;
+} & {
+  readonly verticalAlign: Prop<"top" | "center" | "bottom" | "space-between" | "space-around", true, undefined>;
+  readonly horizontalAlign: Prop<"center" | "stretch" | "left" | "right", true, undefined>;
+  readonly layout: Prop<"vertical", true, undefined>;
+}) | ({
+  layout: Prop<ContainerLayout, true, undefined>;
+} & {
+  readonly verticalAlign: Prop<"top" | "center" | "bottom" | "stretch", true, undefined>;
+  readonly horizontalAlign: Prop<"center" | "space-between" | "space-around" | "left" | "right", true, undefined>;
+  readonly layout: Prop<"horizontal", true, undefined>;
+})>;
+//#endregion
+//#region src/lib/user-facing/hooks/use-editor.d.ts
+type EditorFeatures = {
+  /**
+   * Whether drag and drop functionality is enabled
+   */
+  dragAndDrop: boolean;
+  /**
+   * Whether nudging elements with arrow keys is enabled
+   */
+  nudging: boolean;
+  /**
+   * The currently selected widget
+   */
+  selectWidget: SbInstance | null;
+};
+type FeatureState<T> = {
+  value: T;
+  set: (value: T) => void;
+};
+type RecordFeatureState<T> = { [K in keyof T]: FeatureState<T[K]> };
+type HookResult = {
+  features: RecordFeatureState<EditorFeatures>;
+  isEditing: boolean;
+};
+/**
+ * Hook that provides access to editor-specific features.
+ *
+ * This hook allows you to control editor-only functionality on a per-widget basis.
+ * Note: These features only work in editor mode and have no effect in deployed apps.
+ *
+ * @example
+ * // Disable drag and drop for a widget
+ * const { features } = useEditor();
+ * features.dragAndDrop.set(false);
+ *
+ * // Disable nudging with arrow keys
+ * features.nudging.set(false);
+ */
+declare const useEditor: () => HookResult;
+//#endregion
+//#region src/lib/user-facing/hooks/use-popover-roots.d.ts
+declare const usePopoverRootElement: () => react0.MutableRefObject<HTMLElement | null>;
+//#endregion
+//#region src/lib/user-facing/state/types.d.ts
+type ScopeInstance<_Bindables extends Record<string, any>> = {
+  entities: Record<string, WithBindingIdentifier>;
+  initialEntities: Record<string, any>;
+  scopeInfo: {
+    scopeId: string;
+    name: string;
+    parentScopeId?: string;
+  };
+};
+//#endregion
+//#region src/lib/internal-details/entities.d.ts
+declare function SbEvent({
+  payload
+}: {
+  payload: string;
+}): Omit<SbEvent$1, "name" | "id">;
+//#endregion
+//#region src/lib/internal-details/scope/scope.d.ts
+declare function registerScope<T>(Component: React$1.FC<T>, scopeDef: ScopeInstance<any>, options?: ScopeOptions): React$1.FC<React$1.JSX.IntrinsicAttributes & T>;
+//#endregion
+//#region src/lib/user-facing/components/page/register-page.d.ts
+declare function registerPage<T>(Component: React.FC<T>, scope: ScopeInstance<any>): react0.FC<react0.JSX.IntrinsicAttributes & T>;
+//#endregion
+//#region src/lib/user-facing/components/app/register-app.d.ts
+declare function registerApp<T, Bindables extends Record<string, any>>(Component: React$1.FC<T>, scope: ScopeInstance<Bindables>): React$1.FC<React$1.JSX.IntrinsicAttributes & T>;
+//#endregion
+//#region src/lib/user-facing/state/create-scope.d.ts
+type ScopeOptions$1 = {
+  parentScopeId?: string;
+  name: string;
+};
+declare function createScope<_Bindables extends Record<string, any>, SO extends ScopeOptions$1 = ScopeOptions$1>(getInitialEntities: ({
+  entities
+}: {
+  entities: Record<string, any>;
+}) => Record<string, any>,
+// TODO later, like variables, apis
+options: SO): ScopeInstance<_Bindables>;
+//#endregion
+//#region src/lib/internal-details/scope/types.d.ts
+declare const AppMode: {
+  readonly EDIT: "EDIT";
+  readonly PUBLISHED: "PUBLISHED";
+  readonly PREVIEW: "PREVIEW";
+};
+type AppMode = (typeof AppMode)[keyof typeof AppMode];
+interface Global$1 {
+  mode?: AppMode;
+  user?: User;
+  URL?: UrlState;
+  groups?: Group[];
+  deployedAt?: string;
+  createdAt?: string;
+  selectedProfileId?: string;
+  profiles?: Profiles;
+  routes?: {
+    [id: string]: RouteDef;
+  };
+  currentRoute?: {
+    routeDef: RouteDef;
+    params: Record<string, string>;
+  };
+  app?: {
+    id: string;
+    name: string;
+  };
+}
+type User = {
+  name: string;
+  email: string;
+  id: string;
+  groups: Group[];
+  username: string;
+  metadata: Record<string, unknown>;
+};
+type Group = {
+  id: string;
+  name: string;
+  size: number;
+};
+type Profiles = {
+  available: Profile[];
+  selected?: Profile;
+  default: Profile;
+};
+//#endregion
+//#region src/lib/internal-details/scope/global.d.ts
+type AppTheme = Theme$1;
+declare const Theme: UserAccessibleTheme;
+declare const Global: Global$1;
+declare const Embed: any;
+declare const Env: any;
+//#endregion
+//#region src/lib/user-facing/hooks/use-update-properties.d.ts
+declare function useUpdateProperties(): (props: Record<string, any>) => void;
+//#endregion
+//#region src/lib/user-facing/hooks/use-theme.d.ts
+declare const useTheme: () => {
+  theme: _superblocksteam_library_shared_types7.UserAccessibleTheme;
+};
+//#endregion
+//#region src/lib/user-facing/state/computed.d.ts
+declare function computed<T = any>(fn: (...args: any[]) => T): ComputedProperty<T>;
+//#endregion
+//#region src/lib/user-facing/hooks/use-dialog-editing.d.ts
+/**
+ * A hook to enable editing dialogs.
+ *
+ * Dialog: A window overlaid on either the primary window or another dialog window, rendering the content underneath inert.
+ * E.g: Modal, Slideout, etc
+ *
+ * The hook expects an `isOpen` property on the component, but can be customized by passing a `isOpenPropertyName`.
+ */
+/**
+ * Hook that makes dialogs interact with the editor.
+ * - enable/disable the dialog's interaction layer depending on the open state.
+ * - select the dialog when it is open or any of the nested components are selected through the navigation side bar.
+ *
+ * Note: This hook only works in editor mode and has no effect in deployed apps.
+ *
+ * @example
+ * useDialogEditing({
+ *   isOpen,
+ * });
+ */
+declare function useDialogEditing(props: {
+  isOpen: boolean;
+  isOpenPropertyName?: string;
+}): void;
+//#endregion
+//#region src/edit-mode/interaction-layer/interaction-layer.d.ts
+type RootType = "App" | "Page" | string;
+declare const InteractionLayer: ((props: {
+  rootType: RootType;
+  rootInstanceId: SbInstance;
+  rootName?: string;
+}) => react_jsx_runtime0.JSX.Element | null) & {
+  displayName: string;
+};
+//#endregion
+//#region src/lib/user-facing/component-base/droppable-container.d.ts
+declare function DroppableContainer({
+  name,
+  componentType,
+  isOpen,
+  children,
+  layout,
+  className,
+  dropTargetRef
+}: {
+  name: string;
+  componentType: string;
+  isOpen: boolean;
+  children: React.ReactNode;
+  layout: ContainerLayout;
+  className: string;
+  dropTargetRef?: React.Ref<HTMLElement>;
+}): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/lib/user-facing/constants.d.ts
+/**
+ * The ID of the element used to target detached components (e.g: modals, slideouts) when they are opened in the app.
+ */
+declare const PORTAL_ROOT_ID = "portal-root";
+//#endregion
+export { App, type AppTheme, type BindingIdentifier, type CreateChild, type CreationContext, type CustomComponentPropertiesDefinition, type CustomComponentProps, Dim, type DimModes, DroppableContainer, type EditorConfig, type EditorTemplate, type ElementPassthroughProps, Embed, Env, EventFlow, type FromChildToParentMessageTypes, type FromChildToParentMessageTypesMap, type FromParentToChildMessageTypes, type FromParentToChildMessageTypesMap, Global, INSTANCE_ID_ATTRIBUTE, InteractionLayer, InternalContainer, Link, SbProvider as MakeEditableWithSuperblocks, NO_CONTENT_ATTRIBUTE, Outlet, PORTAL_ROOT_ID, Page, Prop, Property, Section as PropertyPanelSection, PropsPanelCategory, SB, SbApi, SbEvent, SbProvider, StateVar, StateVarPersistence, Theme, Timer, TriggerStepType, type UnknownOption, UnstyledInternalContainer, computed, containerLayout as containerLayoutProps, copyToClipboard, createScope, download, generatePath, loading as loadingProp, logoutIntegrations, margin as marginProp, navigateTo, registerApp, registerComponent, registerPage, registerScope, setQueryParams, shouldScrollContents as shouldScrollContentsProps, size as sizeProp, useDialogEditing, useEditor, usePopoverRootElement, useTheme, useUpdateProperties, visible as visibleProp, widthWithoutFit as widthWithoutFitProp };
+//# sourceMappingURL=index.d.ts.map