@superblocksteam/library 2.0.55 → 2.0.56-next.1

package/dist/lib/index.d.ts

@@ -0,0 +1,786 @@
+import { EditorConfig, EvaluateOrValueComputedArgs, Property, TailwindPropertyKey } from "@superblocksteam/library-shared";
+import React$1, { LegacyRef, ReactNode } from "react";
+import { OrchestratorViewMode, PlaceholderInfo, Profile } from "@superblocksteam/shared";
+import { AiContextMode, AiGenerationState, AppToEditorMessage, Catalog, CreateChild, CreateChild as CreateChild$1, DeleteMeLibraryApi, EditOperationPayload, EditOperationType, EditorConfig as EditorConfig$1, Entity, EntityOutputProp, InteractionMode, PayloadAction, PropertyInfo, RuntimeErrorData, SbElement, SourceLocation, TransactionInfo, UrlState, WithBindingIdentifier } from "@superblocksteam/library-shared/types";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { Callback, ControlType, DataType, DataTypeString, HeaderType, PropertiesPanelDefinition as PropertiesPanelDefinition$1, PropertiesPanelDisplay, PropertyForData, PropsCategory, Relation, WidgetPropertyDefinition } from "@superblocksteam/library-shared/props";
+import { XYCoord } from "react-dnd";
+
+//#region src/lib/internal-details/superblocks-context.d.ts
+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;
+};
+declare class SuperblocksAppContext {
+  private context?;
+  constructor();
+  get user(): User | undefined;
+  get groups(): Group[] | undefined;
+  get selectedProfile(): Profile | undefined;
+  get profiles(): Profiles | undefined;
+  setProfile(profileName: string): void;
+  updateContext(context: Partial<SuperblocksAppContext>): void;
+}
+declare function useSuperblocksUser(): User | undefined;
+declare function useSuperblocksGroups(): Group[] | undefined;
+declare function useSuperblocksProfiles(): {
+  profiles: Profiles | undefined;
+  setProfile: (profileName: string) => void;
+};
+//#endregion
+//#region src/lib/user-facing/sb-provider.d.ts
+declare const SbProvider: ({
+  name,
+  children,
+  className,
+  context
+}: {
+  name?: string;
+  children?: React$1.ReactNode;
+  className?: string;
+  context?: SuperblocksAppContext;
+}) => react_jsx_runtime0.JSX.Element;
+//#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;
+    label?: string;
+  } | {
+    type: "set-ai-context-mode";
+    mode: AiContextMode;
+  } | {
+    type: "ai-generate";
+    prompt: string;
+  } | {
+    type: "loader-state";
+    shouldShowLoader: boolean;
+  };
+};
+type FromParentToChildMessageTypesMap = {
+  "sb-init": {
+    peerId: string;
+    userId?: string;
+    appId: string;
+    sessionRecordingKey?: string;
+    interactionMode?: InteractionMode;
+    /** The value of the authorization header on requests to the dev server. */
+    devServerAuthorization: string | undefined;
+    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>>;
+  };
+  "set-interaction-mode": {
+    interactionMode: InteractionMode;
+  };
+  /**
+   * Request a route change in the child
+   */
+  "route-change": RouteChangePayload;
+  "ai-updates": AiUpdatesPayload["parentToChild"];
+  /**
+   * Runtime sync: subscribe and unsubscribe to component updates
+   */
+  "runtime/subscribe-component": {
+    sourceId: SbElement;
+  };
+  "runtime/unsubscribe-component": {
+    sourceId: SbElement;
+  };
+  "sb-reload-app": void;
+};
+type FromParentToChildMessageTypes = keyof FromParentToChildMessageTypesMap;
+type FromChildToParentMessageTypesMap = {
+  "sb-ready": void;
+  "sb-load-error": {
+    error: string;
+  };
+  "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[];
+  };
+  "set-interaction-mode": {
+    interactionMode: InteractionMode;
+  };
+  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$1>;
+type FromChildToParentMessageTypes = keyof FromChildToParentMessageTypesMap;
+//#endregion
+//#region src/lib/internal-details/lib/features/component-registry.d.ts
+type DefaultTagNames = {
+  container: string;
+  button: string;
+  text: string;
+};
+//#endregion
+//#region src/lib/internal-details/sb-wrapper.d.ts
+type InjectedProps = {
+  dropTargetRef?: React$1.Ref<HTMLElement> | LegacyRef<HTMLElement>;
+};
+type ParentInfo = {
+  type?: string;
+};
+interface CreationContext {
+  parentInfo: ParentInfo;
+  defaultTagNames: DefaultTagNames;
+  selfTagName: string;
+  generateUniqueName: (prefix: string) => string;
+}
+type PropertyValues<P extends React$1.ComponentProps<any>> = { [K in keyof P]?: PropertyInfo | PropertyValues<P[K]> };
+interface EditorTemplate<P extends React$1.ComponentProps<any> = React$1.ComponentProps<any>> {
+  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<P> | Array<CreateRequest<P>>;
+}
+interface CreateRequest<P extends React$1.ComponentProps<any> = React$1.ComponentProps<any>> {
+  type: string;
+  properties?: PropertyValues<P>;
+  createAt?: "root" | "dropLocation";
+  children?: CreateChild$1[];
+}
+interface Chainable<PROPS extends React$1.ComponentProps<any> = React$1.ComponentProps<any>> {
+  addEditorTemplate: (config: EditorTemplate<PROPS>) => Chainable<PROPS>;
+  editorConfig: (config: EditorConfig$1) => Chainable<PROPS>;
+}
+/**
+ * Register a component to be used with the framework.
+ *
+ * @param Component - The React component or HTML element name (e.g., "div") to register. Can be a React functional component, class component, or intrinsic element string.
+ * @param propertiesDefinition - The definition of the component's properties, used for property panel generation and validation.
+ *
+ * @returns A chainable object that provides methods for editor integration (addEditorTemplate and editorConfig).
+ */
+declare const registerComponentInternal: <T extends React$1.ElementType>(Component: T, propertiesDefinition: PropertiesDefinition) => Chainable<React$1.ComponentProps<T>>;
+//#endregion
+//#region src/lib/user-facing/component-base/sb-component.d.ts
+type SbComponentProps<El = HTMLElement> = {
+  name?: string;
+  bind?: WithBindingIdentifier;
+  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/internal-details/lib/evaluator/entity-types.d.ts
+type SingleInputProp<T = EntityOutputProp, ARGS extends any[] = any[]> = T extends Callback ? Callback<ARGS> : T;
+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, ...ARGS: ARGS) => R;
+//#endregion
+//#region src/lib/user-facing/properties-panel/props-builder.d.ts
+type Exact<T, Shape> = T extends Shape ? Exclude<keyof T, keyof Shape> extends never ? T : never : never;
+type ManagedProp<T extends DataType = DataType> = PropertyForData<T> & {
+  default?: SingleInputProp<T>;
+  defaultOnAdd?: SingleInputProp<T>;
+  /**
+   * 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;
+};
+/**
+ * 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 Callback ? (...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 SectionPropRecord ? DefaultsBehavior extends "AlwaysOptional" ? { [K in keyof T as T[K] extends Prop<any, any, any> ? K : never]?: 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 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<any, 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 PropertiesDefinition = Record<string, Section>;
+type SectionDefinition<T extends Record<string, Prop<any, any>>> = {
+  props: T;
+  showHeader?: boolean;
+  isDefaultOpen?: boolean;
+  headerType?: HeaderType;
+  subHeader?: string;
+};
+type SectionPropRecord<Props = Record<string, any>> = Partial<{ [K in keyof Props]: Prop<Props[K], any> }>;
+declare class Section<TProps = any,
+// Component props type for validation
+T extends SectionPropRecord<TProps> = SectionPropRecord<TProps>> {
+  readonly category: PropsCategory;
+  props: T;
+  propertiesPanelConfig: SectionPropertiesPanelConfig;
+  constructor(category: PropsCategory);
+  static category<Props = any>(category: PropsCategory): Section<Props, Partial<{ [K in keyof Props]: Prop<Props[K], any, undefined> }>>;
+  children<INP extends SectionPropRecord<TProps> | 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 extends CompositeProp<any> | UnionProp<any, any> ? INP : Exact<INP, SectionPropRecord<TProps>>): Section<TProps, T & OUT>;
+  add: <INP extends SectionPropRecord<TProps> | 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 extends CompositeProp<any> | UnionProp<any, any> ? INP : Exact<INP, SectionPropRecord<TProps>>) => Section<TProps, T & OUT>;
+  propertiesPanel(config: Omit<SectionDefinition<any>, "props">): this;
+  get name(): "Content" | "Routing" | "Interaction" | "Styles" | "Layout" | "Appearance" | "Permissions" | "Uncategorized" | "Actions";
+}
+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);
+  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>(): Prop<Array<T>>;
+  static any<T = any>(): Prop<T>;
+  static jsx<T extends ReactNode>(): Prop<T>;
+  static literal<T extends Readonly<string | number | boolean>>(value: T): Prop<T, true>;
+  static eventHandler(): Prop<any>;
+  static function<ARGS extends any[] = any[], RETURN = any>(implementation: EntityFunction<ARGS, RETURN>): FunctionProp<ARGS, RETURN>;
+  /**
+   * 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>;
+  default(de: SingleInputProp<DataType>): Prop<Type, true>;
+  contextual<TContext extends any[] | undefined = any[]>(computedArgs?: EvaluateOrValueComputedArgs): Prop<Type, _HasDefault, TContext>;
+  setName(name: string): 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;
+  build(): ManagedProp<Type>;
+  toDefinition(props: Record<string, unknown>): WidgetPropertyDefinition<DataType> | undefined;
+  getRelations(): Relation[][];
+  dependsOn(relations: Relation[][]): this;
+  hasPropertiesPanelDisplay(): boolean;
+  get type(): DataTypeString;
+  get path(): string;
+}
+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(props: Record<string, unknown>): 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;
+}
+/**
+ * See {@link Prop.record}
+ */
+declare class RecordProp<T extends CompositeInputs> extends Prop<Record<string, any>, boolean> {
+  typeString: "recordOf";
+  nestedProps: T;
+  constructor(props: T);
+  getProps(): T;
+  toDefinition(props: Record<string, unknown>): WidgetPropertyDefinition<DataType> | undefined;
+}
+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;
+}
+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/app/props.d.ts
+declare const propertiesDefinition: {
+  contents: Section<any, Partial<{
+    [x: string]: Prop<any, any, undefined>;
+  }> & {
+    children: Prop<any, false, undefined>;
+  }>;
+  appearance: Section<{
+    className: string;
+  }, Partial<{
+    className: Prop<string, any, undefined>;
+  }>>;
+};
+//#endregion
+//#region src/lib/user-facing/components/app/index.d.ts
+declare const App: (({
+  children,
+  className,
+  context
+}: InternalProps<typeof propertiesDefinition> & {
+  context?: SuperblocksAppContext;
+}) => react_jsx_runtime0.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/lib/user-facing/components/custom/register-custom-component.d.ts
+type PropertiesPanelDefinition<Props extends React$1.ComponentProps<any>> = SectionPropRecord<Props> | { [K in string]: Section<Props, SectionPropRecord<Props>> };
+/**
+ * Registers a custom React component or HTML element with Superblocks.
+ *
+ * @param component - The React component or HTML element name (e.g., "div") to register
+ * @param propertiesDefinition - Optional properties panel definition, either as flat props or organized into sections
+ * @returns The registered component
+ *
+ * @example
+ * ```tsx
+ * // Register HTML element with just defaults
+ * registerComponent("div");
+ *
+ * // Register HTML element with custom props
+ * registerComponent("div", {
+ *   children: Prop.node(),
+ *   onClick: Prop.eventHandler(),
+ * });
+ *
+ * // Flat props (auto-categorized into Content and Event sections)
+ * registerComponent(MyComponent, {
+ *   label: Prop.string().default("Click me"),
+ *   onClick: Prop.eventHandler(),
+ * });
+ *
+ * // Organized into sections
+ * registerComponent(MyComponent, {
+ *   content: Section.category(PropsCategory.Content).children({
+ *     label: Prop.string().default("Click me"),
+ *   }),
+ *   events: Section.category(PropsCategory.EventHandlers).children({
+ *     onClick: Prop.eventHandler(),
+ *   }),
+ * });
+ * ```
+ */
+declare function registerComponent<T extends React$1.ElementType>(component: T, propertiesDefinition?: PropertiesPanelDefinition<React$1.ComponentProps<T>>): ReturnType<typeof registerComponentInternal>;
+//#endregion
+//#region src/lib/user-facing/error-pages/page-not-found.d.ts
+declare const PageNotFound: ({
+  title,
+  errorMessage,
+  buttonPath,
+  buttonText,
+  onButtonClick,
+  hideActions
+}: {
+  title?: string;
+  errorMessage?: string | React$1.ReactElement;
+  buttonPath?: string;
+  buttonText?: string;
+  onButtonClick?: () => void;
+  hideActions?: boolean;
+}) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/lib/internal-details/internal-components/route-load-error.d.ts
+declare function RouteLoadError(): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/lib/internal-details/use-api.d.ts
+declare global {
+  interface SuperblocksAPIRegistry {}
+}
+type RegisteredAPINames = keyof SuperblocksAPIRegistry;
+type ApiInterfaces<Name extends string> = Name extends keyof SuperblocksAPIRegistry ? SuperblocksAPIRegistry[Name] extends {
+  input: infer I;
+  output: infer O;
+} ? {
+  input: I;
+  output: O;
+} : {
+  input: Record<string, unknown>;
+  output: any;
+} : {
+  input: never;
+  output: never;
+};
+declare function useApiStateful<Name extends RegisteredAPINames, Inputs = ApiInterfaces<Name>["input"], Response = ApiInterfaces<Name>["output"]>(name: Name): {
+  run: (inputs?: Inputs) => Promise<Response | undefined>;
+  cancel: () => Promise<void>;
+};
+//#endregion
+//#region src/lib/user-facing/properties-panel/mixins/styles-category.d.ts
+/**
+ * Creates a standardized styles section for use in properties panels.
+ * This provides a consistent interface for applying Tailwind CSS classes across components.
+ *
+ * @example
+ * // Basic usage with defaults
+ * styles: tailwindStylesCategory()
+ *
+ * // Override with prioritizedTailwindProperties. These properties will always be shown in the properties panel, event when not set.
+ * styles: tailwindStylesCategory({prioritizedTailwindProperties: ["rounded", "text-color"]})
+ *
+ * @param options - Configuration options to override defaults
+ * @returns A Section with PropsCategory.Styles containing a className prop
+ */
+declare const tailwindStylesCategory: (props?: {
+  prioritizedTailwindProperties?: TailwindPropertyKey[];
+}) => Section<{
+  className: string;
+}>;
+//#endregion
+export { App, type CreateChild, type CreationContext, type EditorConfig, type EditorTemplate, type FromChildToParentMessageTypes, type FromChildToParentMessageTypesMap, type FromParentToChildMessageTypes, type FromParentToChildMessageTypesMap, PageNotFound, Prop, type PropertiesPanelDefinition, Property, PropsCategory, RouteLoadError, Section, SbProvider as SuperblocksProvider, registerComponent, tailwindStylesCategory, useApiStateful as useApi, useSuperblocksGroups, useSuperblocksProfiles, useSuperblocksUser };
+//# sourceMappingURL=index.d.ts.map