@superblocksteam/library 2.0.3-next.71

package/dist-types/lib/internal-details/lib/evaluator/to-executables-or-values.d.ts

@@ -0,0 +1,32 @@
+import { SbEventFlow } from "../../../user-facing/sb-event-flow.js";
+import type { EntityDerivedProp, EntityOutputProp, SingleInputProp, InputProp, EntityFunction } from "./base-entity-manager.js";
+import type { LazyFunction } from "./lazy-function.js";
+import type { DataTypeString } from "@superblocksteam/library-shared/props";
+type ExecutableType = "normal" | "mustache-bindings" | "external-function" | "event" | "lazy-function";
+export type ExecutableOrValue = {
+    type: ExecutableType;
+} & ({
+    type: "normal";
+    value: EntityDerivedProp | EntityOutputProp;
+} | {
+    type: "mustache-bindings";
+    value: EntityDerivedProp | EntityOutputProp;
+} | {
+    type: "external-function";
+    value: EntityFunction;
+} | {
+    type: "lazy-function";
+    value: LazyFunction;
+} | {
+    type: "event";
+    value: SbEventFlow;
+});
+type PathSchema = {
+    path: string;
+};
+type EntitySchema = PathSchema & {
+    dataType: DataTypeString;
+};
+export declare const toExecutablesOrValues: <T>(props: InputProp<T>, propsSchema?: EntitySchema[]) => [string, ExecutableOrValue][];
+export declare const toExecutableOrValue: <T>(path: string, value: SingleInputProp<T>, isAnExternalFunction?: boolean) => ExecutableOrValue;
+export {};

package/dist-types/lib/internal-details/lib/evaluator/use-shallow-mobx-observer.d.ts

@@ -0,0 +1 @@
+export declare const useShallowMobxObserver: <T extends Record<string, unknown>>(obj: T) => T;

package/dist-types/lib/internal-details/lib/evaluator/use-shallow-mobx-observer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-types/lib/internal-details/lib/features/api-store.d.ts

@@ -0,0 +1,31 @@
+import { type DeleteMeLibraryApi } from "@superblocksteam/library-shared/types";
+import type { RootStore } from "../root-store.js";
+declare class ApiManager {
+    readonly rootStore: RootStore;
+    baseUrl: string | undefined;
+    private token;
+    private accessToken;
+    private apisByName;
+    private apiNameToDepCandidates;
+    private apiNameToApiReferences;
+    constructor(rootStore: RootStore);
+    setTokens(token: string, accessToken: string): void;
+    isInitialized(): boolean;
+    setAllApis(apis: Record<string, {
+        api: DeleteMeLibraryApi;
+        scopeId: string;
+    }>): void;
+    setApiDepCandidates(apiName: string, deps: string[]): void;
+    setApiReferences(apiName: string, deps: string[]): void;
+    updateApi(api: DeleteMeLibraryApi, scopeId: string): void;
+    deleteApi(apiName: string, scopeId: string): void;
+    renameApi({ api, oldName, scopeId, }: {
+        api: DeleteMeLibraryApi;
+        oldName: string;
+        scopeId: string;
+    }): void;
+    runApi(apiName: string, { scopeId }: {
+        scopeId: string;
+    }): Promise<import("../types.js").ApiV2ExecutionResponse | undefined>;
+}
+export default ApiManager;

package/dist-types/lib/internal-details/lib/features/api-utils.d.ts

@@ -0,0 +1,77 @@
+import { ViewMode } from "@superblocksteam/shared";
+import type { ApiV2ExecutionRequest, ApiV2ExecutionResponse, ExecutionResponse, StreamEvent } from "../types.js";
+import type { DeleteMeLibraryApi } from "@superblocksteam/library-shared/types";
+import type { Agent, ApiResponseType } from "@superblocksteam/shared";
+export declare function runApi(api: DeleteMeLibraryApi, inputs: Record<string, unknown>, orchestratorUrl: string, token: string, accessToken: string): Promise<unknown>;
+export type ExecuteV2ApiParams = {
+    body: ApiV2ExecutionRequest;
+    api: DeleteMeLibraryApi;
+    environment: string;
+    eventType: string;
+    notifyOnSystemError: boolean;
+    responseType: ApiResponseType;
+    onMessage?: (message: any) => void;
+    processStreamEvents?: (event: StreamEvent) => void;
+    controlFlowOnlyFiles?: FileRequestParam[];
+    abortController?: AbortController;
+    baseUrl: string;
+    agents: Array<Agent>;
+    viewMode: ViewMode;
+    accessToken: string;
+    token: string;
+};
+export declare function executeV2Api(params: ExecuteV2ApiParams): Promise<ExecutionResponse | undefined | void>;
+export declare const HttpMethod: {
+    readonly Get: "GET";
+    readonly Post: "POST";
+    readonly Put: "PUT";
+    readonly Patch: "PATCH";
+    readonly Delete: "DELETE";
+};
+type HttpMethodName = (typeof HttpMethod)[keyof typeof HttpMethod];
+type FileRequestParam = {
+    originalName: string;
+    buffer: string;
+    encoding: "base64";
+    mimetype: "text/plain";
+};
+export interface HttpCallOptions extends BaseCallOptions {
+    baseUrl?: string;
+    controlFlowOnlyFiles?: FileRequestParam[];
+    bodyIsFormData?: boolean;
+}
+interface BaseCallOptions {
+    method: HttpMethodName;
+    url: string;
+    body?: Record<string, any>;
+    query?: Record<string, string | string[]>;
+    params?: Record<string, unknown>;
+    timeout?: number;
+    abortController?: AbortController;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    priority?: RequestPriority;
+}
+export declare const stream: ({ url, headers, body, onMessage, onComplete, onError, defaultError, method, baseUrl, signal, init: overrideInit, }: {
+    url: string;
+    init?: RequestInit;
+    headers?: Record<string, string>;
+    body?: Record<string, any>;
+    onMessage: (message: any) => void;
+    onComplete: () => void;
+    onError: (error: string, statusCode?: number) => void;
+    defaultError?: string;
+    method?: HttpMethodName;
+    baseUrl?: string;
+    signal?: AbortSignal;
+}) => Promise<void>;
+export declare class HttpError extends Error {
+    code: number;
+    critical: boolean;
+    constructor(code: number, critical?: boolean, m?: string);
+}
+export declare const parseStreamResult: (streamResult: Array<StreamEvent>, options?: {
+    includeFinalOutput?: boolean;
+}) => undefined | ApiV2ExecutionResponse;
+export declare const decodeBytestringsInV2ExecutionResponse: (response: ApiV2ExecutionResponse) => void;
+export {};

package/dist-types/lib/internal-details/lib/features/component-registry.d.ts

@@ -0,0 +1,29 @@
+import type { ManagedPropsList } from "../../../user-facing/properties-panel/props-builder.js";
+import type { RootStore } from "../root-store.js";
+import type { ComponentRegistryShareState } from "@superblocksteam/library-shared/types";
+import type * as React from "react";
+export type Type = {
+    isSb: symbol;
+    sbType: string;
+    hideInRightClickMenu?: boolean;
+} & React.ComponentType<any>;
+export declare class ComponentRegistry implements ComponentRegistryShareState {
+    readonly rootStore: RootStore;
+    private _typeRegistry;
+    private _customComponentRegistry;
+    private _managedPropsRegistry;
+    constructor(rootStore: RootStore);
+    addType(type: string, component: Type): void;
+    addCustomComponent(type: string, component: Type): void;
+    deleteCustomComponent(type: string): void;
+    renameCustomComponent(oldName: string, newName: string): void;
+    addManagedProps(type: string, props: ManagedPropsList): void;
+    deleteManagedProps(type: string): void;
+    get widgetList(): string[];
+    get addByUiWidgetList(): string[];
+    get libraryComponentList(): string[];
+    get customComponentList(): string[];
+    get managedPropsRegistry(): Map<string, ManagedPropsList>;
+    getManagedProps(type: string): ManagedPropsList;
+    getComponent(type: string): Type | undefined;
+}

package/dist-types/lib/internal-details/lib/features/injected-features.d.ts

@@ -0,0 +1,8 @@
+export declare function useGetCurrentUserQuery(): {
+    isLoading: boolean;
+    data: {
+        user: {
+            name: string;
+        };
+    };
+};

package/dist-types/lib/internal-details/lib/features/name-manager.d.ts

@@ -0,0 +1,36 @@
+import type { IEntityManager } from "../evaluator/base-entity-manager.js";
+import type { Name } from "../evaluator/names.js";
+import type { SbElement, SbInstance } from "@superblocksteam/library-shared/types";
+export type IdentifierInfo = {
+    sourceId: SbElement;
+    name: Name;
+    instanceId: SbInstance;
+    scopeId: string;
+};
+export declare class NameManager {
+    readonly entityManager: IEntityManager;
+    private _identifiers;
+    private _scopeToNameToIdentifiers;
+    private _allNamesToIdentifiers;
+    private _prefixOrderByKey;
+    constructor(entityManager: IEntityManager);
+    get scopeToNameToIds(): Record<string, Record<string, Record<SbInstance, IdentifierInfo>>>;
+    getWidgetName(instanceId: SbInstance): undefined | Name;
+    hasEntityWithName(name: string): boolean;
+    hasDuplicateNames(scopeId: string, name: string): boolean;
+    private nextNameAndIdForCombination;
+    private trackIdentifier;
+    private untrackIdentifier;
+    unregisterIdentifier(instanceId: SbInstance): void;
+    getExistingIdentifier(instanceId: SbInstance): IdentifierInfo | undefined;
+    registerAndGetIdentifiers(params: {
+        sourceId: SbElement | undefined;
+        name: string | undefined;
+        scopeId: string;
+        rootId?: SbInstance;
+        existingInstanceId?: SbInstance;
+    }): IdentifierInfo;
+    private getSharedNameCount;
+    changeWidgetName(instanceId: SbInstance, newName?: string): IdentifierInfo | null;
+    resetRootOrders(rootId: SbInstance): void;
+}

package/dist-types/lib/internal-details/lib/iframe.d.ts

@@ -0,0 +1,44 @@
+import type { FromChildToParentMessageTypes, FromChildToParentMessageTypesMap, FromParentToChildMessageTypes, FromParentToChildMessageTypesMap } from "./types.js";
+import type { PayloadAction } from "@superblocksteam/library-shared/types";
+export declare function isEmbeddedBySuperblocksFirstParty(): boolean;
+/** @deprecated Use editorBridge instead */
+export declare function sendMessageImmediately<MT extends FromChildToParentMessageTypes>(message: {
+    type: MT;
+    payload?: FromChildToParentMessageTypesMap[MT];
+    [key: string]: any;
+}, options?: {
+    overrideStartTime: number;
+}): void;
+/** @deprecated Use editorBridge instead */
+export declare function queueMessage(message: PayloadAction<unknown>): void;
+declare class SbIframeEventInternal<T = Record<string, any>> extends Event {
+    data: {
+        payload: T;
+        startTime: number;
+        [key: string]: any;
+    };
+    constructor(type: FromParentToChildMessageTypes, data: {
+        payload: T;
+        startTime: number;
+        [key: string]: any;
+    });
+}
+interface MessageHandler extends EventTarget {
+    addEventListener<MT extends FromParentToChildMessageTypes>(type: MT, callback: IframeEventHandler<MT>): void;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null): void;
+    removeEventListener<MT extends FromParentToChildMessageTypes>(type: MT, callback: IframeEventHandler<MT>): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null): void;
+}
+declare const SbMessageHandler_base: {
+    new (): MessageHandler;
+    prototype: MessageHandler;
+};
+declare class SbMessageHandler extends SbMessageHandler_base {
+}
+export type IframeEventHandler<MT extends FromParentToChildMessageTypes> = (event: SbIframeEventInternal<FromParentToChildMessageTypesMap[MT]>) => void;
+export declare const iframeMessageHandler: SbMessageHandler;
+export type IframeEvent<T> = T extends FromParentToChildMessageTypes ? MessageEvent<{
+    type: T;
+    payload: FromParentToChildMessageTypesMap[T];
+}> : never;
+export {};

package/dist-types/lib/internal-details/lib/mobx-cached-getter.d.ts

@@ -0,0 +1 @@
+export declare const makeMobxCachedGetter: <T, K extends string>(getter: (id: K) => T) => ((id: K) => T);

package/dist-types/lib/internal-details/lib/resolve-id-singleton.d.ts

@@ -0,0 +1,4 @@
+export declare function addNewPromise(resolver: (...args: any[]) => any, isMultiUse?: boolean, rejecter?: (...args: any[]) => any): string;
+export declare function resolveById(id: string, payload: any): void;
+export declare function rejectById(id: string, payload: any): void;
+export declare function clearMultiCallback(id: string): void;

package/dist-types/lib/internal-details/lib/root-store.d.ts

@@ -0,0 +1,30 @@
+import ApiManager from "./features/api-store.js";
+import { ComponentRegistry } from "./features/component-registry.js";
+import { NameManager } from "./features/name-manager.js";
+import type { IEntityManager } from "./evaluator/base-entity-manager.js";
+import type { EditStore } from "../../../edit-mode/edit-store.js";
+declare class RootStore {
+    apis: ApiManager;
+    nameManager: NameManager;
+    entityManager: IEntityManager;
+    componentRegistry: ComponentRegistry;
+    editStore?: EditStore;
+    private editorRegisteredCallbacks;
+    private apisLoaded;
+    private pageScopeLoaded;
+    private pageLoadedCallback?;
+    constructor();
+    setEditStore(editStore: EditStore): void;
+    onEditorRegistered(fn: () => void): void;
+    /**
+     * There is a timing problem here between when the APIs are registered and when the scope entities are registered.
+     * Regardless of which one is done first, we need to wait for both before firing page load actions
+     */
+    setApisLoaded(): void;
+    setPageScopeLoaded(): void;
+    private firePageLoadedCallbacks;
+    onPageLoaded(fn: () => void): void;
+}
+export type { RootStore };
+declare const _default: RootStore;
+export default _default;

package/dist-types/lib/internal-details/lib/throttle.d.ts

@@ -0,0 +1,2 @@
+export declare function throttle<T extends (...args: any[]) => any>(func: T, delay: number): (...args: Parameters<T>) => void;
+export declare function debounce<T extends (...args: any[]) => any>(func: T, delay: number): (...args: Parameters<T>) => void;

package/dist-types/lib/internal-details/lib/types.d.ts

@@ -0,0 +1,229 @@
+import type { PropertiesPanelDefinition } from "@superblocksteam/library-shared/props";
+import type { AppToEditorMessage, DeleteMeLibraryApi, PayloadAction, PropertyInfo, SbElement, TransactionInfo } from "@superblocksteam/library-shared/types";
+import type { OrchestratorViewMode, PlaceholderInfo } from "@superblocksteam/shared";
+import type { XYCoord } from "react-dnd";
+export type ExecutionError = {
+    name?: string;
+    message: string;
+    formPath: string;
+    blockPath: string;
+    handled?: boolean;
+};
+export type ExecutionEventRequest = {
+    summary: string;
+    metadata: {
+        placeHoldersInfo?: Record<string, PlaceholderInfo>;
+    };
+};
+export 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[];
+}>;
+export 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;
+};
+export interface StreamEvent {
+    result: {
+        event: ExecutionEvent;
+        execution: string;
+    };
+}
+export interface ApiV2ExecutionResponse {
+    execution: string;
+    output?: {
+        result: any;
+    };
+    status: "STATUS_EXECUTING" | "STATUS_COMPLETED" | "STATUS_UNSPECIFIED";
+    events?: Array<ExecutionEvent | StreamEvent>;
+    errors?: Array<{
+        message: string;
+        handled?: boolean;
+    }>;
+}
+interface BaseExecutionRequest {
+    options: {
+        includeEventOutputs: boolean;
+        includeEvents: boolean;
+        includeResolved: boolean;
+    };
+    inputs: Record<string, any>;
+}
+interface ApiDefinitionExecutionRequest extends BaseExecutionRequest {
+    definition: {
+        api: Omit<DeleteMeLibraryApi["apiPb"], "trigger">;
+    };
+}
+interface ApiFetchExecutionRequest extends BaseExecutionRequest {
+    fetchByPath: {
+        path: string;
+        applicationId: string;
+        branchName: string;
+        profile: {
+            name: string;
+        };
+        viewMode: OrchestratorViewMode;
+    };
+}
+export type ApiV2ExecutionRequest = ApiDefinitionExecutionRequest | ApiFetchExecutionRequest;
+export type ExecutionResponse = ApiV2ExecutionResponse | {
+    systemError: string;
+};
+export type FromParentToChildMessageTypesMap = {
+    "sb-init": {
+        peerId: string;
+        userId?: string;
+    };
+    "sb-bootstrap-response": {
+        appId: string;
+        token: string;
+        accessToken: string;
+        agentUrl: string;
+        logContext: Record<string, unknown>;
+    };
+    "sb-editor-request-bootstrap": void;
+    "sb-update-property": {
+        sourceId: string;
+        updates: Record<string, PropertyInfo<unknown>>;
+    };
+    "sb-update-property-with-effects": {
+        sourceId: string;
+        callbackId: string;
+        updates: Record<string, PropertyInfo<unknown>>;
+        transaction: TransactionInfo;
+    };
+    "sb-retrieve-property-panel-props": {
+        sourceId: string;
+    };
+    "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;
+    };
+};
+export type FromParentToChildMessageTypes = keyof FromParentToChildMessageTypesMap;
+export type FromChildToParentMessageTypesMap = {
+    "sb-ready": void;
+    "iframe-action-batch": PayloadAction<unknown>[];
+    "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-update-property": {
+        sourceId: string;
+        updates: Record<string, unknown>;
+    };
+    "client:selectWidgets": {
+        sourceIds: SbElement[];
+        selectingMultiple: boolean;
+    };
+    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;
+    };
+    undo: void;
+    redo: void;
+    deleteWidgets: {
+        sourceIds: string[];
+    };
+} & AppToEditorMessage<PropertiesPanelDefinition>;
+export type FromChildToParentMessageTypes = keyof FromChildToParentMessageTypesMap;
+export {};

package/dist-types/lib/internal-details/reactive-component.d.ts

@@ -0,0 +1,10 @@
+import type { IdentifierInfo } from "./lib/features/name-manager.js";
+import type { ChildFunction } from "../../edit-mode/features/runtime-widgets-manager.js";
+declare const ReactiveComponent: import("react").FunctionComponent<{
+    children: React.ReactNode | ChildFunction;
+    Component: React.FC<any>;
+    widgetProps: Record<string, unknown>;
+    showErrors?: boolean;
+    identifier: IdentifierInfo;
+}>;
+export default ReactiveComponent;

package/dist-types/lib/internal-details/sb-wrapper-notes.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-types/lib/internal-details/sb-wrapper.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import type { ExternalProps, InternalProps, PropertiesDefinition, RawPropsToExternal } from "../user-facing/properties-panel/props-builder.js";
+import type { AnonymousSbEntity } from "@superblocksteam/library-shared/types";
+export declare const registerSbComponent: <PD extends PropertiesDefinition, EP extends ExternalProps<PD> = ExternalProps<PD>, IP extends InternalProps<PD> = InternalProps<PD>>(type: string, config: {
+    container?: boolean;
+    customComponent?: boolean;
+    propertiesDefinition: PD;
+}, Component: React.FC<IP>) => React.FC<EP>;
+export declare function registerSbEntity<PROPS, PD extends PropertiesDefinition, EP extends ExternalProps<PD> = ExternalProps<PD>>(name: string, config: {
+    propertiesDefinition: PD;
+}, Entity: (args: RawPropsToExternal<PROPS>) => EP & AnonymousSbEntity): (args: RawPropsToExternal<PROPS>) => EP & AnonymousSbEntity;

package/dist-types/lib/internal-details/scope/scope-context.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { ScopeId } from "../lib/evaluator/base-entity-manager.js";
+type State = {
+    scopeId: ScopeId;
+};
+export declare const ScopeProvider: React.FC<React.PropsWithChildren<State>>;
+export declare const useScope: () => State;
+export {};

package/dist-types/lib/internal-details/scope/scope.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import type { SbApi } from "../../user-facing/entities/api/index.js";
+import type { SbTimer } from "../../user-facing/entities/timer/index.js";
+import type { SbVariable } from "../../user-facing/entities/variable/index.js";
+import type { SbScopeInstance } from "../../user-facing/state/types.js";
+import type { SbEvent } from "../entities.js";
+import type { ScopeOptions } from "@superblocksteam/library-shared/types";
+export type ScopedEntity = ReturnType<typeof SbTimer> | ReturnType<typeof SbVariable> | ReturnType<typeof SbEvent> | ReturnType<typeof SbApi>;
+export type Scope = {
+    [key: string]: ScopedEntity;
+};
+export declare function registerScope<T>(Component: React.FC<T>, scopeDef: SbScopeInstance<any>, options?: ScopeOptions): React.FC<React.JSX.IntrinsicAttributes & T>;

package/dist-types/lib/internal-details/size.d.ts

@@ -0,0 +1 @@
+export declare const getWidthInColumns: (itemWidth: number, gridWidth: number, columns: number) => number;

package/dist-types/lib/internal-details/theme-context.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { UserAccessibleTheme } from "@superblocksteam/library-shared/types";
+export declare const ThemeProvider: React.FC<React.PropsWithChildren<{
+    theme: UserAccessibleTheme;
+}>>;
+export declare const useTheme: () => {
+    theme: UserAccessibleTheme;
+};

package/dist-types/lib/internal-details/use-track-runtime-widget.d.ts

@@ -0,0 +1,15 @@
+import type { Name } from "./lib/evaluator/names.js";
+import type { ChildFunction } from "../../edit-mode/features/runtime-widgets-manager.js";
+import type { SbElement, SbInstance } from "@superblocksteam/library-shared/types";
+import type { ReactNode } from "react";
+declare function useTrackRuntimeWidget(instanceId: SbInstance, params: {
+    name: Name;
+    type: string;
+    props: Record<string, unknown> & {
+        children?: ReactNode[] | ReactNode | ChildFunction;
+    };
+    isEditing: boolean;
+    scopeId: string;
+    sourceId: SbElement;
+}): void;
+export default useTrackRuntimeWidget;