@platforma-sdk/model 1.58.5 → 1.58.11

package/dist/render/api.d.ts

@@ -1,202 +1,201 @@
-import type { AnchoredPColumnSelector, AnyFunction, AxisId, Option, PColumn, PColumnLazy, PColumnSelector, PColumnSpec, PFrameDef, PFrameHandle, PObject, PObjectSpec, PSpecPredicate, PTableDef, PTableDefV2, PTableHandle, PTableRecordFilter, PTableSorting, PlRef, ResolveAnchorsOptions, ResultCollection, SUniversalPColumnId, ValueOrError } from "@milaboratories/pl-model-common";
-import { AnchoredIdDeriver } from "@milaboratories/pl-model-common";
-import type { Optional } from "utility-types";
-import type { PluginHandle, PluginFactoryLike, InferFactoryData, InferFactoryParams } from "../plugin_handle";
-import { TreeNodeAccessor } from "./accessor";
-import type { FutureRef } from "./future";
-import type { GlobalCfgRenderCtx } from "./internal";
-import { type AxisLabelProvider, type ColumnProvider } from "./util/column_collection";
-import type { LabelDerivationOps } from "./util/label";
-import type { APColumnSelectorWithSplit } from "./util/split_selectors";
-import type { PColumnDataUniversal } from "./internal";
-export type UniversalColumnOption = {
-    label: string;
-    value: SUniversalPColumnId;
+import { InferFactoryData, InferFactoryParams, PluginFactoryLike, PluginHandle } from "../plugin_handle.js";
+import { GlobalCfgRenderCtx, PColumnDataUniversal } from "./internal.js";
+import { FutureRef } from "./future.js";
+import { TreeNodeAccessor } from "./accessor.js";
+import { LabelDerivationOps } from "./util/label.js";
+import { APColumnSelectorWithSplit } from "./util/split_selectors.js";
+import { AxisLabelProvider, ColumnProvider } from "./util/column_collection.js";
+import { AnchoredIdDeriver, AnchoredPColumnSelector, AnyFunction, AxisId, Option, PColumn, PColumnLazy, PColumnSelector, PColumnSpec, PFrameDef, PFrameHandle, PObject, PObjectSpec, PSpecPredicate, PTableDef, PTableDefV2, PTableHandle, PTableRecordFilter, PTableSorting, PlRef, ResolveAnchorsOptions, ResultCollection, SUniversalPColumnId, ValueOrError } from "@milaboratories/pl-model-common";
+import { Optional } from "utility-types";
+
+//#region src/render/api.d.ts
+type UniversalColumnOption = {
+  label: string;
+  value: SUniversalPColumnId;
 };
 type UniversalPColumnOpts = {
-    labelOps?: LabelDerivationOps;
-    dontWaitAllData?: boolean;
-    exclude?: AnchoredPColumnSelector | AnchoredPColumnSelector[];
+  labelOps?: LabelDerivationOps;
+  dontWaitAllData?: boolean;
+  exclude?: AnchoredPColumnSelector | AnchoredPColumnSelector[];
 } & ResolveAnchorsOptions;
 type GetOptionsOpts = {
-    /**
-     * If true, references returned by the method will contain `requireEnrichments` flag set to true.
-     * If this reference is added to the block's args, it will communicate to the platform that the block
-     * expects enrichments of the referenced block to be available in the context of the current block.
-     */
-    refsWithEnrichments?: boolean;
-    /**
-     * Label derivation options.
-     * If provided, it will be used to derive labels for the options.
-     * If not provided, labels will be derived using the default logic.
-     */
-    label?: ((spec: PObjectSpec, ref: PlRef) => string) | LabelDerivationOps;
+  /**
+   * If true, references returned by the method will contain `requireEnrichments` flag set to true.
+   * If this reference is added to the block's args, it will communicate to the platform that the block
+   * expects enrichments of the referenced block to be available in the context of the current block.
+   */
+  refsWithEnrichments?: boolean;
+  /**
+   * Label derivation options.
+   * If provided, it will be used to derive labels for the options.
+   * If not provided, labels will be derived using the default logic.
+   */
+  label?: ((spec: PObjectSpec, ref: PlRef) => string) | LabelDerivationOps;
 };
-export declare class ResultPool implements ColumnProvider, AxisLabelProvider {
-    private readonly ctx;
-    /**
-     * @deprecated use getOptions()
-     */
-    calculateOptions(predicate: PSpecPredicate): Option[];
-    getOptions(predicateOrSelector: ((spec: PObjectSpec) => boolean) | PColumnSelector | PColumnSelector[], opts?: GetOptionsOpts): Option[];
-    /** @deprecated wrap label ops with { label: <...> } */
-    getOptions(predicateOrSelector: ((spec: PObjectSpec) => boolean) | PColumnSelector | PColumnSelector[], label?: ((spec: PObjectSpec, ref: PlRef) => string) | LabelDerivationOps): Option[];
-    resolveAnchorCtx(anchorsOrCtx: AnchoredIdDeriver | Record<string, PColumnSpec | PlRef>): AnchoredIdDeriver | undefined;
-    /**
-     * Returns columns that match the provided anchors and selectors. It applies axis filters and label derivation.
-     *
-     * @param anchorsOrCtx - Anchor context for column selection (same as in getCanonicalOptions)
-     * @param predicateOrSelectors - Predicate or selectors for filtering columns (same as in getCanonicalOptions)
-     * @param opts - Optional configuration for label generation and data waiting
-     * @returns A PFrameHandle for the created PFrame, or undefined if any required data is missing
-     */
-    getAnchoredPColumns(anchorsOrCtx: AnchoredIdDeriver | Record<string, PColumnSpec | PlRef>, predicateOrSelectors: ((spec: PColumnSpec) => boolean) | APColumnSelectorWithSplit | APColumnSelectorWithSplit[], opts?: UniversalPColumnOpts): PColumn<PColumnDataUniversal>[] | undefined;
-    /**
-     * Calculates anchored identifier options for columns matching a given predicate and returns their
-     * canonicalized representations.
-     *
-     * This function filters column specifications from the result pool that match the provided predicate,
-     * creates a standardized AnchorCtx from the provided anchors, and generates a list of label-value
-     * pairs for UI components (like dropdowns).
-     *
-     * @param anchorsOrCtx - Either:
-     *                     - An existing AnchorCtx instance
-     *                     - A record mapping anchor IDs to PColumnSpec objects
-     *                     - A record mapping anchor IDs to PlRef objects (which will be resolved to PColumnSpec)
-     * @param predicateOrSelectors - Either:
-     *                            - A predicate function that takes a PColumnSpec and returns a boolean.
-     *                              Only specs that return true will be included.
-     *                            - An APColumnSelector object for declarative filtering, which will be
-     *                              resolved against the provided anchors and matched using matchPColumn.
-     *                            - An array of APColumnSelector objects - columns matching ANY selector
-     *                              in the array will be included (OR operation).
-     * @param opts - Optional configuration for label generation:
-     *                 - labelOps: Optional configuration for label generation:
-     *                   - includeNativeLabel: Whether to include native column labels
-     *                   - separator: String to use between label parts (defaults to " / ")
-     *                   - addLabelAsSuffix: Whether to add labels as suffix instead of prefix
-     *                 - dontWaitAllData: Whether to skip columns that don't have all data (if not set, will return undefined,
-     *                                    if at least one column that requires splitting is missing data)
-     * @returns An array of objects with `label` (display text) and `value` (anchored ID string) properties,
-     *          or undefined if any PlRef resolution fails.
-     */
-    getCanonicalOptions(anchorsOrCtx: AnchoredIdDeriver | Record<string, PColumnSpec | PlRef>, predicateOrSelectors: ((spec: PColumnSpec) => boolean) | APColumnSelectorWithSplit | APColumnSelectorWithSplit[], opts?: UniversalPColumnOpts): {
-        label: string;
-        value: SUniversalPColumnId;
-    }[] | undefined;
-    /**
-     * @deprecated use getData()
-     */
-    getDataFromResultPool(): ResultCollection<PObject<TreeNodeAccessor>>;
-    getData(): ResultCollection<PObject<TreeNodeAccessor>>;
-    /**
-     * @deprecated use getDataWithErrors()
-     */
-    getDataWithErrorsFromResultPool(): ResultCollection<Optional<PObject<ValueOrError<TreeNodeAccessor, Error>>, "id">>;
-    getDataWithErrors(): ResultCollection<Optional<PObject<ValueOrError<TreeNodeAccessor, Error>>, "id">>;
-    /**
-     * @deprecated use getSpecs()
-     */
-    getSpecsFromResultPool(): ResultCollection<PObjectSpec>;
-    getSpecs(): ResultCollection<PObjectSpec>;
-    /**
-     * @param ref a Ref
-     * @returns data associated with the ref
-     */
-    getDataByRef(ref: PlRef): PObject<TreeNodeAccessor> | undefined;
-    /**
-     * Returns data associated with the ref ensuring that it is a p-column.
-     * @param ref a Ref
-     * @returns p-column associated with the ref
-     */
-    getPColumnByRef(ref: PlRef): PColumn<TreeNodeAccessor> | undefined;
-    /**
-     * Returns spec associated with the ref ensuring that it is a p-column spec.
-     * @param ref a Ref
-     * @returns p-column spec associated with the ref
-     */
-    getPColumnSpecByRef(ref: PlRef): PColumnSpec | undefined;
-    /**
-     * @param ref a Ref
-     * @returns object spec associated with the ref
-     */
-    getSpecByRef(ref: PlRef): PObjectSpec | undefined;
-    /**
-     * @param spec object specification
-     * @returns array of data objects with compatible specs
-     * @deprecated delete this method after Jan 1, 2025
-     */
-    findDataWithCompatibleSpec(spec: PColumnSpec): PObject<TreeNodeAccessor>[];
-    /**
-     * Find labels data for a given axis id. It will search for a label column and return its data as a map.
-     * @returns a map of axis value => label
-     */
-    findLabels(axis: AxisId): Record<string | number, string> | undefined;
-    /**
-     * Selects columns based on the provided selectors, returning PColumn objects
-     * with lazily loaded data.
-     *
-     * @param selectors - A predicate function, a single selector, or an array of selectors.
-     * @returns An array of PColumn objects matching the selectors. Data is loaded on first access.
-     */
-    selectColumns(selectors: ((spec: PColumnSpec) => boolean) | PColumnSelector | PColumnSelector[]): PColumn<TreeNodeAccessor | undefined>[];
-    /**
-     * Find labels data for a given axis id of a p-column.
-     * @returns a map of axis value => label
-     */
-    findLabelsForColumnAxis(column: PColumnSpec, axisIdx: number): Record<string | number, string> | undefined;
+declare class ResultPool implements ColumnProvider, AxisLabelProvider {
+  private readonly ctx;
+  /**
+   * @deprecated use getOptions()
+   */
+  calculateOptions(predicate: PSpecPredicate): Option[];
+  getOptions(predicateOrSelector: ((spec: PObjectSpec) => boolean) | PColumnSelector | PColumnSelector[], opts?: GetOptionsOpts): Option[];
+  /** @deprecated wrap label ops with { label: <...> } */
+  getOptions(predicateOrSelector: ((spec: PObjectSpec) => boolean) | PColumnSelector | PColumnSelector[], label?: ((spec: PObjectSpec, ref: PlRef) => string) | LabelDerivationOps): Option[];
+  resolveAnchorCtx(anchorsOrCtx: AnchoredIdDeriver | Record<string, PColumnSpec | PlRef>): AnchoredIdDeriver | undefined;
+  /**
+   * Returns columns that match the provided anchors and selectors. It applies axis filters and label derivation.
+   *
+   * @param anchorsOrCtx - Anchor context for column selection (same as in getCanonicalOptions)
+   * @param predicateOrSelectors - Predicate or selectors for filtering columns (same as in getCanonicalOptions)
+   * @param opts - Optional configuration for label generation and data waiting
+   * @returns A PFrameHandle for the created PFrame, or undefined if any required data is missing
+   */
+  getAnchoredPColumns(anchorsOrCtx: AnchoredIdDeriver | Record<string, PColumnSpec | PlRef>, predicateOrSelectors: ((spec: PColumnSpec) => boolean) | APColumnSelectorWithSplit | APColumnSelectorWithSplit[], opts?: UniversalPColumnOpts): PColumn<PColumnDataUniversal>[] | undefined;
+  /**
+   * Calculates anchored identifier options for columns matching a given predicate and returns their
+   * canonicalized representations.
+   *
+   * This function filters column specifications from the result pool that match the provided predicate,
+   * creates a standardized AnchorCtx from the provided anchors, and generates a list of label-value
+   * pairs for UI components (like dropdowns).
+   *
+   * @param anchorsOrCtx - Either:
+   *                     - An existing AnchorCtx instance
+   *                     - A record mapping anchor IDs to PColumnSpec objects
+   *                     - A record mapping anchor IDs to PlRef objects (which will be resolved to PColumnSpec)
+   * @param predicateOrSelectors - Either:
+   *                            - A predicate function that takes a PColumnSpec and returns a boolean.
+   *                              Only specs that return true will be included.
+   *                            - An APColumnSelector object for declarative filtering, which will be
+   *                              resolved against the provided anchors and matched using matchPColumn.
+   *                            - An array of APColumnSelector objects - columns matching ANY selector
+   *                              in the array will be included (OR operation).
+   * @param opts - Optional configuration for label generation:
+   *                 - labelOps: Optional configuration for label generation:
+   *                   - includeNativeLabel: Whether to include native column labels
+   *                   - separator: String to use between label parts (defaults to " / ")
+   *                   - addLabelAsSuffix: Whether to add labels as suffix instead of prefix
+   *                 - dontWaitAllData: Whether to skip columns that don't have all data (if not set, will return undefined,
+   *                                    if at least one column that requires splitting is missing data)
+   * @returns An array of objects with `label` (display text) and `value` (anchored ID string) properties,
+   *          or undefined if any PlRef resolution fails.
+   */
+  getCanonicalOptions(anchorsOrCtx: AnchoredIdDeriver | Record<string, PColumnSpec | PlRef>, predicateOrSelectors: ((spec: PColumnSpec) => boolean) | APColumnSelectorWithSplit | APColumnSelectorWithSplit[], opts?: UniversalPColumnOpts): {
+    label: string;
+    value: SUniversalPColumnId;
+  }[] | undefined;
+  /**
+   * @deprecated use getData()
+   */
+  getDataFromResultPool(): ResultCollection<PObject<TreeNodeAccessor>>;
+  getData(): ResultCollection<PObject<TreeNodeAccessor>>;
+  /**
+   * @deprecated use getDataWithErrors()
+   */
+  getDataWithErrorsFromResultPool(): ResultCollection<Optional<PObject<ValueOrError<TreeNodeAccessor, Error>>, "id">>;
+  getDataWithErrors(): ResultCollection<Optional<PObject<ValueOrError<TreeNodeAccessor, Error>>, "id">>;
+  /**
+   * @deprecated use getSpecs()
+   */
+  getSpecsFromResultPool(): ResultCollection<PObjectSpec>;
+  getSpecs(): ResultCollection<PObjectSpec>;
+  /**
+   * @param ref a Ref
+   * @returns data associated with the ref
+   */
+  getDataByRef(ref: PlRef): PObject<TreeNodeAccessor> | undefined;
+  /**
+   * Returns data associated with the ref ensuring that it is a p-column.
+   * @param ref a Ref
+   * @returns p-column associated with the ref
+   */
+  getPColumnByRef(ref: PlRef): PColumn<TreeNodeAccessor> | undefined;
+  /**
+   * Returns spec associated with the ref ensuring that it is a p-column spec.
+   * @param ref a Ref
+   * @returns p-column spec associated with the ref
+   */
+  getPColumnSpecByRef(ref: PlRef): PColumnSpec | undefined;
+  /**
+   * @param ref a Ref
+   * @returns object spec associated with the ref
+   */
+  getSpecByRef(ref: PlRef): PObjectSpec | undefined;
+  /**
+   * @param spec object specification
+   * @returns array of data objects with compatible specs
+   * @deprecated delete this method after Jan 1, 2025
+   */
+  findDataWithCompatibleSpec(spec: PColumnSpec): PObject<TreeNodeAccessor>[];
+  /**
+   * Find labels data for a given axis id. It will search for a label column and return its data as a map.
+   * @returns a map of axis value => label
+   */
+  findLabels(axis: AxisId): Record<string | number, string> | undefined;
+  /**
+   * Selects columns based on the provided selectors, returning PColumn objects
+   * with lazily loaded data.
+   *
+   * @param selectors - A predicate function, a single selector, or an array of selectors.
+   * @returns An array of PColumn objects matching the selectors. Data is loaded on first access.
+   */
+  selectColumns(selectors: ((spec: PColumnSpec) => boolean) | PColumnSelector | PColumnSelector[]): PColumn<TreeNodeAccessor | undefined>[];
+  /**
+   * Find labels data for a given axis id of a p-column.
+   * @returns a map of axis value => label
+   */
+  findLabelsForColumnAxis(column: PColumnSpec, axisIdx: number): Record<string | number, string> | undefined;
 }
 /** Main entry point to the API available within model lambdas (like outputs, sections, etc..) */
-export declare abstract class RenderCtxBase<Args = unknown, Data = unknown> {
-    protected readonly ctx: GlobalCfgRenderCtx;
-    constructor();
-    private dataCache?;
-    get data(): Data;
-    private activeArgsCache?;
-    /**
-     * Returns args snapshot the block was executed for (i.e. when "Run" button was pressed).
-     * Returns undefined, if block was never executed or stopped mid-way execution, so that the result was cleared.
-     * */
-    get activeArgs(): Args | undefined;
-    private getNamedAccessor;
-    get prerun(): TreeNodeAccessor | undefined;
-    get outputs(): TreeNodeAccessor | undefined;
-    readonly resultPool: ResultPool;
-    /**
-     * Find labels data for a given axis id. It will search for a label column and return its data as a map.
-     * @returns a map of axis value => label
-     * @deprecated Use resultPool.findLabels instead
-     */
-    findLabels(axis: AxisId): Record<string | number, string> | undefined;
-    private verifyInlineAndExplicitColumnsSupport;
-    private patchPTableDef;
-    createPFrame(def: PFrameDef<PColumn<PColumnDataUniversal> | PColumnLazy<undefined | PColumnDataUniversal>>): PFrameHandle | undefined;
-    createPTable(def: PTableDef<PColumn<PColumnDataUniversal>>): PTableHandle | undefined;
-    createPTable(def: {
-        columns: PColumn<PColumnDataUniversal>[];
-        filters?: PTableRecordFilter[];
-        /** Table sorting */
-        sorting?: PTableSorting[];
-    }): PTableHandle | undefined;
-    createPTableV2(def: PTableDefV2<PColumn<PColumnDataUniversal>>): PTableHandle | undefined;
-    /** @deprecated scheduled for removal from SDK */
-    getBlockLabel(blockId: string): string;
-    getCurrentUnstableMarker(): string | undefined;
-    logInfo(msg: string): void;
-    logWarn(msg: string): void;
-    logError(msg: string): void;
+declare abstract class RenderCtxBase<Args = unknown, Data = unknown> {
+  protected readonly ctx: GlobalCfgRenderCtx;
+  constructor();
+  private dataCache?;
+  get data(): Data;
+  private activeArgsCache?;
+  /**
+   * Returns args snapshot the block was executed for (i.e. when "Run" button was pressed).
+   * Returns undefined, if block was never executed or stopped mid-way execution, so that the result was cleared.
+   * */
+  get activeArgs(): Args | undefined;
+  private getNamedAccessor;
+  get prerun(): TreeNodeAccessor | undefined;
+  get outputs(): TreeNodeAccessor | undefined;
+  readonly resultPool: ResultPool;
+  /**
+   * Find labels data for a given axis id. It will search for a label column and return its data as a map.
+   * @returns a map of axis value => label
+   * @deprecated Use resultPool.findLabels instead
+   */
+  findLabels(axis: AxisId): Record<string | number, string> | undefined;
+  private verifyInlineAndExplicitColumnsSupport;
+  private patchPTableDef;
+  createPFrame(def: PFrameDef<PColumn<PColumnDataUniversal> | PColumnLazy<undefined | PColumnDataUniversal>>): PFrameHandle | undefined;
+  createPTable(def: PTableDef<PColumn<PColumnDataUniversal>>): PTableHandle | undefined;
+  createPTable(def: {
+    columns: PColumn<PColumnDataUniversal>[];
+    filters?: PTableRecordFilter[]; /** Table sorting */
+    sorting?: PTableSorting[];
+  }): PTableHandle | undefined;
+  createPTableV2(def: PTableDefV2<PColumn<PColumnDataUniversal>>): PTableHandle | undefined;
+  /** @deprecated scheduled for removal from SDK */
+  getBlockLabel(blockId: string): string;
+  getCurrentUnstableMarker(): string | undefined;
+  logInfo(msg: string): void;
+  logWarn(msg: string): void;
+  logError(msg: string): void;
 }
 /** Main entry point to the API available within model lambdas (like outputs, sections, etc..) for v3+ blocks */
-export declare class BlockRenderCtx<Args = unknown, Data = unknown> extends RenderCtxBase<Args, Data> {
-    private argsCache?;
-    get args(): Args | undefined;
+declare class BlockRenderCtx<Args = unknown, Data = unknown> extends RenderCtxBase<Args, Data> {
+  private argsCache?;
+  get args(): Args | undefined;
 }
 /** Render context for legacy v1/v2 blocks - provides backward compatibility */
-export declare class RenderCtxLegacy<Args = unknown, UiState = unknown> extends RenderCtxBase<Args, UiState> {
-    private argsCache?;
-    get args(): Args;
-    private uiStateCache?;
-    get uiState(): UiState;
+declare class RenderCtxLegacy<Args = unknown, UiState = unknown> extends RenderCtxBase<Args, UiState> {
+  private argsCache?;
+  get args(): Args;
+  private uiStateCache?;
+  get uiState(): UiState;
 }
 /**
  * Render context for plugin output functions.
@@ -207,27 +206,26 @@ export declare class RenderCtxLegacy<Args = unknown, UiState = unknown> extends
  *
  * @typeParam F - PluginFactoryLike phantom carrying data/params/outputs types
  */
-export declare class PluginRenderCtx<F extends PluginFactoryLike = PluginFactoryLike> {
-    private readonly ctx;
-    private readonly handle;
-    private readonly wrappedInputs;
-    constructor(handle: PluginHandle<F>, wrappedInputs: Record<string, () => unknown>);
-    private dataCache?;
-    /** Plugin's persistent data from blockStorage.__plugins.{pluginId}.__data */
-    get data(): InferFactoryData<F>;
-    private paramsCache?;
-    /** Params derived from block context via pre-wrapped input callbacks */
-    get params(): InferFactoryParams<F>;
-    /** Result pool — same as block, from cfgRenderCtx methods */
-    readonly resultPool: ResultPool;
+declare class PluginRenderCtx<F extends PluginFactoryLike = PluginFactoryLike> {
+  private readonly ctx;
+  private readonly handle;
+  private readonly wrappedInputs;
+  constructor(handle: PluginHandle<F>, wrappedInputs: Record<string, () => unknown>);
+  private dataCache?;
+  /** Plugin's persistent data from blockStorage.__plugins.{pluginId}.__data */
+  get data(): InferFactoryData<F>;
+  private paramsCache?;
+  /** Params derived from block context via pre-wrapped input callbacks */
+  get params(): InferFactoryParams<F>;
+  /** Result pool — same as block, from cfgRenderCtx methods */
+  readonly resultPool: ResultPool;
 }
 /** @deprecated Use BlockRenderCtx instead */
-export type RenderCtx<Args = unknown, Data = unknown> = BlockRenderCtx<Args, Data>;
-export type RenderFunction<Args = unknown, State = unknown, Ret = unknown> = (rCtx: BlockRenderCtx<Args, State>) => Ret;
-export type RenderFunctionLegacy<Args = unknown, State = unknown, Ret = unknown> = (rCtx: RenderCtxLegacy<Args, State>) => Ret;
-export type UnwrapFutureRef<K> = K extends FutureRef<infer T> ? T : K extends bigint | boolean | null | number | string | symbol | undefined ? K : {
-    [key in keyof K]: UnwrapFutureRef<K[key]>;
-};
-export type InferRenderFunctionReturn<RF extends AnyFunction> = RF extends (...args: any) => infer R ? UnwrapFutureRef<R> : never;
-export {};
+type RenderCtx<Args = unknown, Data = unknown> = BlockRenderCtx<Args, Data>;
+type RenderFunction<Args = unknown, State = unknown, Ret = unknown> = (rCtx: BlockRenderCtx<Args, State>) => Ret;
+type RenderFunctionLegacy<Args = unknown, State = unknown, Ret = unknown> = (rCtx: RenderCtxLegacy<Args, State>) => Ret;
+type UnwrapFutureRef<K> = K extends FutureRef<infer T> ? T : K extends bigint | boolean | null | number | string | symbol | undefined ? K : { [key in keyof K]: UnwrapFutureRef<K[key]> };
+type InferRenderFunctionReturn<RF extends AnyFunction> = RF extends ((...args: any) => infer R) ? UnwrapFutureRef<R> : never;
+//#endregion
+export { BlockRenderCtx, InferRenderFunctionReturn, PluginRenderCtx, RenderCtx, RenderCtxBase, RenderCtxLegacy, RenderFunction, RenderFunctionLegacy, ResultPool, UniversalColumnOption, UnwrapFutureRef };
 //# sourceMappingURL=api.d.ts.map