SDK API
Complete public declarations from @backlit/sdk.
This page is generated from the built SDK declarations. Import these names
from @backlit/sdk. The signatures include overloads, type parameters,
options, and public members. Do not edit this page by hand.
Start with App and areas, Resources, Search state, or Extensions for usage.
ActionDefinition
declare class ActionDefinition<Resource extends string, Name extends string, Schema extends StandardSchemaV1, Params extends ParamNames = readonly [
]> {
readonly resource: Resource;
readonly name: Name;
readonly params: Params;
readonly schema: Schema;
constructor(resource: Resource, name: Name, params: Params, schema: Schema, handler: ActionHandler<Schema, Params>);
setAgentOptions(options: AgentOptions): this;
get agentOptions(): AgentOptions | undefined;
toAgentTool(): AgentTool | undefined;
getAddress(values?: (string | number)[]): ActionAddress;
validate(input: unknown): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<Schema>>>;
execute(ctx: RequestContext<'action', Params, StandardSchemaV1.InferOutput<Schema>>): Promise<ValidActionResponse>;
attempt(ctx: RequestContext<'action', Params, StandardSchemaV1.InferOutput<Schema>>): Promise<ValidActionResponse>;
}ActionDialogOptions
type ActionDialogOptions = ActionDialog & {
submitLabel?: string;
};ActionTargetBuilder
declare class ActionTargetBuilder<Input extends Record<string, unknown>, Params extends ParamNames, Row = unknown, HasDialog extends boolean = false> implements TargetBuilderContract<Row> {
readonly setFields: HasDialog extends true ? <FieldRow = Row, const Fields extends readonly GetFieldBuildersFor<Input, FieldRow>[] = readonly GetFieldBuildersFor<Input, FieldRow>[]>(fields: Fields) => ActionTargetBuilder<Input, Params, Row & FieldRow, HasDialog> : never;
constructor(action: {
resource: string;
name: string;
params: Params;
}, args?: GetArgsFor<Params> | ((record: Row) => GetArgsFor<Params>), presentation?: ActionTargetPresentationFor<Row>);
withInitialData(values: FormInitialData<Input>): this;
setDialog<DialogRow = Row>(options: ActionDialogOptions | ((record: DialogRow) => ActionDialogOptions)): ActionTargetBuilder<Input, Params, Row & DialogRow, true>;
[TO_NODE](ctx: RequestContext): ActionTargetDefinition;
[VALUE_FOR](record: Row, report: ReportDefect, options: {
ctx: RequestContext;
onDefect: DefectReporter;
requireLabel?: boolean;
repeated?: boolean;
}): ActionTargetValue | undefined;
}ActionTargetPresentation
type ActionTargetPresentation = TargetPresentation & ActionPresentation & {
skip?: boolean;
disabled?: boolean;
};ActionTargetPresentationFor
type ActionTargetPresentationFor<Row> = ActionTargetPresentation | ((record: Row) => ActionTargetPresentation);App
declare class App<AreaResources extends Record<string, Record<string, ResourceLoader>>> {
constructor(config: {
preferences?: AppPreferences;
extensions?: BacklitExtension[];
middleware?: MiddlewareLoader[];
areas: Record<string, {
label: string;
icon?: string;
resources: Record<string, ResourceLoader>;
navigation: NavigationItem<string>[];
}>;
});
renderView(resource: string, view: string, args?: string[], transport?: Transport, search?: SearchParams): Promise<ValidViewResponse>;
renderZone(resource: string, view: string, zone: string, args?: string[], transport?: Transport, search?: SearchParams): Promise<ValidZoneResponse>;
handleAction(resource: string, action: string, payload: unknown, args?: string[], transport?: Transport): Promise<ValidActionResponse>;
handleLookup(resource: string, lookup: string, searchQuery: string, args?: string[], transport?: Transport): Promise<ValidLookupResponse>;
resourceNames(): string[];
loadResource<Name extends ExtractResourceNames<AreaResources>>(name: Name): Promise<UnWrapLazyImport<ExtractResourceLoader<AreaResources, Name>>>;
toManifest(): Manifest;
}assertLookupArgs
declare function assertLookupArgs(fields: Field[], has: (name: string) => boolean): void;BarListChartBuilder
declare class BarListChartBuilder<Row extends Record<string, unknown> = Record<string, unknown>> implements Nodeable<BarListChart> {
constructor(data: Row[]);
setFields(fields: BarListFieldsInput<Row>): this;
setOptions(options: BarListOptions): this;
setColor(color: ChartColor | ((row: Row) => ChartColor | undefined)): this;
onClick(target: LinkTarget<Linkable, Row>): this;
onDefect(reporter: DefectReporter): this;
[TO_NODE](ctx: RequestContext): BarListChart;
}BarListFieldsInput
type BarListFieldsInput<Row> = {
label: FieldBuilderContract<string, unknown, Row>;
value: NumberFieldBuilder<string, Row>;
};BooleanFieldBuilder
declare class BooleanFieldBuilder<Name extends string = string, Row = unknown> implements Nodeable<BooleanField>, FieldBuilderContract<Name, boolean, Row> {
readonly [FIELD_VALUE]?: boolean;
readonly [FIELD_ROW]?: (row: Row) => void;
constructor(name: Name, options?: BooleanFieldOptions<Row>);
get [FIELD_NAME](): Name;
revealWhen<Scope>(condition: ConditionBuilder<Scope>): BooleanFieldBuilder<Name, Row>;
enableWhen<Scope>(condition: ConditionBuilder<Scope>): BooleanFieldBuilder<Name, Row>;
configure<R = Row>(options: BooleanFieldOptions<R>): BooleanFieldBuilder<Name, R>;
clone(): BooleanFieldBuilder<Name, Row>;
[TO_NODE](ctx?: RequestContext): {
enable?: import("@backlit/contract").Condition;
reveal?: import("@backlit/contract").Condition;
displayVariant?: BooleanDisplayVariant;
link?: import("@backlit/contract").LinkTargetAddress;
label: string;
inputVariant?: import("@backlit/contract").BooleanInputVariant;
description?: string;
kind: "boolean";
name: Name;
};
[VALUE_FOR](row: Row, node: BooleanField, report: ReportDefect, options?: {
role?: FieldRole;
}): unknown;
}BooleanFieldOptions
type BooleanFieldOptions<Row = unknown> = Prettify<ConditionableOptions<Partial<Omit<BooleanField, 'kind' | 'name' | 'link' | 'displayVariant'>> & {
link?: LinkTarget<Linkable, Row>;
displayVariant?: BooleanDisplayVariant;
}>>;callout
declare function callout(text: string): CalloutBuilder;CalloutBuilder
declare class CalloutBuilder implements Nodeable<CalloutNode> {
constructor(text: string);
setTitle(title: string): this;
setTone(tone: Tone): this;
setIcon(token: string): this;
[TO_NODE](): {
icon?: string;
tone?: Tone;
title?: string;
kind: "callout";
text: string;
};
}CategoryBarChartBuilder
declare class CategoryBarChartBuilder<Row extends Record<string, unknown> = Record<string, unknown>> implements Nodeable<CategoryBarChart> {
constructor(data: Row);
setFields(fields: CategoryBarFieldsInput<Row>): this;
setOptions(options: CategoryBarOptions): this;
onDefect(reporter: DefectReporter): this;
[TO_NODE](ctx: RequestContext): CategoryBarChart;
}CategoryBarFieldsInput
type CategoryBarFieldsInput<Row> = {
values: readonly NumberFieldBuilder<string, Row>[];
};charts
declare const charts: ChartsFactory;ChartsFactory
declare class ChartsFactory extends Macroable {
sparkArea<Row extends Record<string, unknown>>(data: Row[]): SparkAreaChartBuilder<Row>;
categoryBar<Row extends Record<string, unknown>>(data: Row): CategoryBarChartBuilder<Row>;
barList<Row extends Record<string, unknown>>(data: Row[]): BarListChartBuilder<Row>;
line<Row extends Record<string, unknown>>(data: Row[]): LineChartBuilder<Row>;
}completeTarget
declare function completeTarget(node: () => TargetDefinition, value: TargetValue): Target;ConditionBuilder
declare abstract class ConditionBuilder<Scope> {
protected constructor();
abstract [TO_NODE](ctx?: RequestContext): Condition;
}ConditionComposer
declare class ConditionComposer<Scope extends object> {
constructor(form: FormBuilder<any>, onDefect: DefectReporter, scope?: string);
when<const Path extends DataPath<Scope>>(path: Path): PredicateFor<Scope, GetValueAtPath<Scope, Path>>;
ref<const Path extends DataPath<Scope>>(path: Path): Ref<Scope, NonNullable<GetValueAtPath<Scope, Path>>>;
all(first: ConditionBuilder<Scope>, ...rest: ConditionBuilder<Scope>[]): ConditionBuilder<Scope>;
any(first: ConditionBuilder<Scope>, ...rest: ConditionBuilder<Scope>[]): ConditionBuilder<Scope>;
none(first: ConditionBuilder<Scope>, ...rest: ConditionBuilder<Scope>[]): ConditionBuilder<Scope>;
}datalist
declare function datalist<Row extends Record<string, unknown>>(data: Row): DatalistBuilder<Row>;DatalistBuilder
declare class DatalistBuilder<Row extends Record<string, unknown> = Record<string, unknown>, Fields extends readonly FieldBuilderContract<string, unknown, never>[] = readonly FieldBuilderContract<string, unknown, never>[]> implements Nodeable<DatalistNode> {
constructor(data: Row);
setFields<const SelectedFields extends readonly FieldBuilderContract<string, unknown, never>[]>(fields: SelectedFields & readonly FieldBuilderContract<string, unknown, Row>[]): DatalistBuilder<Row, SelectedFields>;
peers(...sets: ExtractFieldNames<Fields>[][]): this;
setRoles(roles: GetFieldRoleSelectionsFor<Fields>): this;
onDefect(reporter: DefectReporter): this;
[TO_NODE](ctx: RequestContext): DatalistNode;
}DateFieldBuilder
declare class DateFieldBuilder<Name extends string = string, Row = unknown> implements Nodeable<DateField>, FieldBuilderContract<Name, string, Row> {
readonly [FIELD_VALUE]?: string;
readonly [FIELD_ROW]?: (row: Row) => void;
constructor(name: Name, options?: DateFieldOptions<Row>);
get [FIELD_NAME](): Name;
revealWhen<Scope>(condition: ConditionBuilder<Scope>): DateFieldBuilder<Name, Row>;
enableWhen<Scope>(condition: ConditionBuilder<Scope>): DateFieldBuilder<Name, Row>;
configure<R = Row>(options: DateFieldOptions<R>): DateFieldBuilder<Name, R>;
clone(): DateFieldBuilder<Name, Row>;
[TO_NODE](ctx?: RequestContext): {
enable?: import("@backlit/contract").Condition;
reveal?: import("@backlit/contract").Condition;
displayVariant?: DateDisplayVariant;
link?: import("@backlit/contract").LinkTargetAddress;
label: string;
inputVariant?: import("@backlit/contract").DateInputVariant;
description?: string;
max?: string;
min?: string;
precision?: import("@backlit/contract").DatePrecision;
timeZone?: string;
minuteStep?: number;
kind: "date";
name: Name;
};
[VALUE_FOR](row: Row, node: DateField, report: ReportDefect, options?: {
role?: FieldRole;
}): unknown;
}DateFieldOptions
type DateFieldOptions<Row = unknown> = Prettify<ConditionableOptions<Partial<Omit<DateField, 'kind' | 'name' | 'link' | 'displayVariant'>> & {
link?: LinkTarget<Linkable, Row>;
displayVariant?: DateDisplayVariant;
}>>;DateRangeFilterBuilder
declare class DateRangeFilterBuilder<Name extends string = string> implements Nodeable<DateRangeFilter>, FilterBuilderContract<Name, {
from?: string;
to?: string;
}> {
readonly [FILTER_VALUE]?: {
from?: string;
to?: string;
};
constructor(name: Name);
get [FILTER_NAME](): Name;
setLabel(text: string): this;
[PARSE](raw: unknown): {
from?: string;
to?: string;
} | undefined;
[STRINGIFY](value: {
from?: string;
to?: string;
}): string;
[TO_NODE](): {
kind: "date-range";
name: Name;
label: string;
};
}defineApp
declare function defineApp<AreaResources extends Record<string, Record<string, ResourceLoader>>>(config: AppConfig<AreaResources>): App<AreaResources>;defineFilters
declare function defineFilters<const Filters extends readonly FilterBuilderContract<string>[]>(filters: Filters): FilterBar<Filters>;definePaginator
declare function definePaginator(options: {
perPage: number;
param?: string;
}): Paginator;defineResource
declare function defineResource<Name extends string, const Fields extends readonly FieldBuilderContract<string, unknown, never>[]>(name: Name, fields: Fields): Resource<Name, Fields>;defineSorter
declare function defineSorter<const Fields extends readonly FieldBuilderContract<string, unknown, never>[]>(options: {
columns: Fields;
param?: string;
}): Sorter<ExtractFieldNames<Fields>[]>;E_ACTION_FAILED
declare const E_ACTION_FAILED: new (args: [
action: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_ACTION_TARGET_ARGS_MISMATCH
declare const E_ACTION_TARGET_ARGS_MISMATCH: new (args: [
resource: string,
action: string,
expected: number,
received: number
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_ACTION_VALIDATION_FAILED
declare const E_ACTION_VALIDATION_FAILED: new (args: [
action: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_AGENT_PARAM_COLLISION
declare const E_AGENT_PARAM_COLLISION: new (args: [
address: string,
key: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_AGENT_SCHEMA_WITHOUT_JSON
declare const E_AGENT_SCHEMA_WITHOUT_JSON: new (args: [
address: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_AGENT_TOOL_FAILED
declare const E_AGENT_TOOL_FAILED: new (args: [
tool: string,
code: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_BAR_LIST_VALUE_NOT_NUMBER
declare const E_BAR_LIST_VALUE_NOT_NUMBER: new (args: [
name: string,
kind: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_BAR_LIST_WITHOUT_LABEL
declare const E_BAR_LIST_WITHOUT_LABEL: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;E_BAR_LIST_WITHOUT_VALUE
declare const E_BAR_LIST_WITHOUT_VALUE: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;E_CATEGORY_BAR_VALUE_NOT_NUMBER
declare const E_CATEGORY_BAR_VALUE_NOT_NUMBER: new (args: [
name: string,
kind: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_CATEGORY_BAR_WITHOUT_VALUES
declare const E_CATEGORY_BAR_WITHOUT_VALUES: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;E_CONDITION_PATH_WITHOUT_FIELD
declare const E_CONDITION_PATH_WITHOUT_FIELD: new (args: [
path: string,
found: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_DUPLICATE_ACTION
declare const E_DUPLICATE_ACTION: new (args: [
name: string,
resource: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_DUPLICATE_FIELD
declare const E_DUPLICATE_FIELD: new (args: [
name: string,
resource: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_DUPLICATE_FILTER
declare const E_DUPLICATE_FILTER: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_DUPLICATE_LOOKUP
declare const E_DUPLICATE_LOOKUP: new (args: [
name: string,
resource: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_DUPLICATE_RESOURCE
declare const E_DUPLICATE_RESOURCE: new (args: [
name: string,
first: string,
second: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_DUPLICATE_SORT_COLUMN
declare const E_DUPLICATE_SORT_COLUMN: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_DUPLICATE_STATE_FIELD
declare const E_DUPLICATE_STATE_FIELD: new (args: [
name: string,
keyword: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_DUPLICATE_VIEW
declare const E_DUPLICATE_VIEW: new (args: [
name: string,
resource: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_DUPLICATE_ZONE
declare const E_DUPLICATE_ZONE: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_EMPTY_SORT_COLUMNS
declare const E_EMPTY_SORT_COLUMNS: new (args: [
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_FOOTER_LABEL_HAS_NO_ROOM
declare const E_FOOTER_LABEL_HAS_NO_ROOM: new (args: [
label: string,
field: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_INVALID_FILTER_NAME
declare const E_INVALID_FILTER_NAME: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_INVALID_NUMBER_RANGE
declare const E_INVALID_NUMBER_RANGE: new (args: [
name: string,
reason: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_INVALID_SORT_COLUMN
declare const E_INVALID_SORT_COLUMN: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_INVALID_STATE_FIELD_NAME
declare const E_INVALID_STATE_FIELD_NAME: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_INVALID_ZONE_NAME
declare const E_INVALID_ZONE_NAME: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_KEYWORD_CONFLICT
declare const E_KEYWORD_CONFLICT: new (args: [
keyword: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_LINE_CHART_SERIES_NOT_NUMBER
declare const E_LINE_CHART_SERIES_NOT_NUMBER: new (args: [
name: string,
kind: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_LINE_CHART_WITHOUT_SERIES
declare const E_LINE_CHART_WITHOUT_SERIES: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;E_LINE_CHART_WITHOUT_X
declare const E_LINE_CHART_WITHOUT_X: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;E_LIST_POSITION_OVERFULL
declare const E_LIST_POSITION_OVERFULL: new (args: [
position: string,
limit: number
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_LIST_WITHOUT_TITLE
declare const E_LIST_WITHOUT_TITLE: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;E_LOOKUP_ARG_WITHOUT_FIELD
declare const E_LOOKUP_ARG_WITHOUT_FIELD: new (args: [
arg: string,
input: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_MISSING_FIELD_REMAPPER
declare const E_MISSING_FIELD_REMAPPER: new (args: [
role: string,
kind: string,
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_MISSING_PARAMS
declare const E_MISSING_PARAMS: new (args: [
resource: string,
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_MISSING_RELATION_DISPLAY
declare const E_MISSING_RELATION_DISPLAY: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_MIXED_STATE_SCOPES
declare const E_MIXED_STATE_SCOPES: new (args: [
sorter: string,
paginator: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_NESTED_FORM
declare const E_NESTED_FORM: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;E_NO_RESPONSE
declare const E_NO_RESPONSE: new (args: [
address: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_SEGMENTS_MANY
declare const E_SEGMENTS_MANY: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_SEGMENTS_NOT_SELECT
declare const E_SEGMENTS_NOT_SELECT: new (args: [
name: string,
kind: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_SEGMENTS_ONE_FILTER
declare const E_SEGMENTS_ONE_FILTER: new (args: [
count: number
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_SEGMENTS_RESERVED_ALL
declare const E_SEGMENTS_RESERVED_ALL: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_SPARK_AREA_CHART_SERIES_NOT_NUMBER
declare const E_SPARK_AREA_CHART_SERIES_NOT_NUMBER: new (args: [
name: string,
kind: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_SPARK_AREA_CHART_WITHOUT_SERIES
declare const E_SPARK_AREA_CHART_WITHOUT_SERIES: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;E_SPARK_AREA_CHART_WITHOUT_X
declare const E_SPARK_AREA_CHART_WITHOUT_X: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;E_STAT_CURRENCY_WITHOUT_CODE
declare const E_STAT_CURRENCY_WITHOUT_CODE: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_STAT_FIELD_NOT_NUMBER
declare const E_STAT_FIELD_NOT_NUMBER: new (args: [
name: string,
kind: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_TABS_DUPLICATE_TAB
declare const E_TABS_DUPLICATE_TAB: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_TABS_EMPTY
declare const E_TABS_EMPTY: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;E_TABS_UNKNOWN_INITIAL
declare const E_TABS_UNKNOWN_INITIAL: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_TARGET_ARG_UNDEFINED
declare const E_TARGET_ARG_UNDEFINED: new (args: [
resource: string,
target: string,
position: number
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_TIMELINE_POSITION_OVERFULL
declare const E_TIMELINE_POSITION_OVERFULL: new (args: [
position: string,
limit: number
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_TIMELINE_WITHOUT_TIME
declare const E_TIMELINE_WITHOUT_TIME: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;E_TIMELINE_WITHOUT_TITLE
declare const E_TIMELINE_WITHOUT_TITLE: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;E_UNKNOWN_FIELD
declare const E_UNKNOWN_FIELD: new (args: [
name: string,
resource: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_UNKNOWN_FIELD_REMAPPER_ROLE
declare const E_UNKNOWN_FIELD_REMAPPER_ROLE: new (args: [
role: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_UNKNOWN_FILTER
declare const E_UNKNOWN_FILTER: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_UNKNOWN_FOOTER_FIELD
declare const E_UNKNOWN_FOOTER_FIELD: new (args: [
label: string,
field: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_UNKNOWN_NAVIGATION_RESOURCE
declare const E_UNKNOWN_NAVIGATION_RESOURCE: new (args: [
label: string,
resource: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_UNKNOWN_RESOURCE
declare const E_UNKNOWN_RESOURCE: new (args: [
name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_VIEW_TARGET_ARGS_MISMATCH
declare const E_VIEW_TARGET_ARGS_MISMATCH: new (args: [
resource: string,
view: string,
expected: number,
received: number
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_VIEW_TARGET_FILTER_UNKNOWN
declare const E_VIEW_TARGET_FILTER_UNKNOWN: new (args: [
resource: string,
view: string,
filter: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;E_WIDGET_EMPTY
declare const E_WIDGET_EMPTY: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;E_ZONE_STATE_COLLISION
declare const E_ZONE_STATE_COLLISION: new (args: [
name: string,
keyword: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;EnumFieldBuilder
declare class EnumFieldBuilder<Name extends string = string, Choices extends readonly EnumOption[] = readonly EnumOption[], Row = unknown> implements Nodeable<EnumField>, FieldBuilderContract<Name, Choices[number]['value'], Row> {
readonly [FIELD_VALUE]?: Choices[number]['value'];
readonly [FIELD_ROW]?: (row: Row) => void;
constructor(name: Name, choices: Choices, options?: EnumFieldOptions<Row, Choices[number]['value']>);
get [FIELD_NAME](): Name;
revealWhen<Scope>(condition: ConditionBuilder<Scope>): EnumFieldBuilder<Name, Choices, Row>;
enableWhen<Scope>(condition: ConditionBuilder<Scope>): EnumFieldBuilder<Name, Choices, Row>;
configure<R = Row>(options: EnumFieldOptions<R, Choices[number]['value']>): EnumFieldBuilder<Name, Choices, R>;
getOptionValues(): {
[Index in keyof Choices]: Choices[Index]['value'];
};
getOptionLabels(): {
[Index in keyof Choices]: Choices[Index]['label'];
};
clone(): EnumFieldBuilder<Name, Choices, Row>;
[TO_NODE](ctx?: RequestContext): {
enable?: import("@backlit/contract").Condition;
reveal?: import("@backlit/contract").Condition;
inputVariant?: "select" | "radio" | "checkboxes" | SearchInputVariant$1 | OptionsInputVariant$1;
displayVariant?: EnumDisplayVariant;
link?: import("@backlit/contract").LinkTargetAddress;
label: string;
options: Choices[number][];
description?: string;
cardinality?: import("@backlit/contract").Cardinality;
kind: "enum";
name: Name;
};
[VALUE_FOR](row: Row, node: EnumField, report: ReportDefect, options?: {
role?: FieldRole;
}): unknown;
}EnumFieldOptions
type EnumFieldOptions<Row = unknown, Value = string> = Prettify<ConditionableOptions<Partial<Omit<EnumField, 'kind' | 'name' | 'options' | 'link' | 'displayVariant' | 'inputVariant'>> & {
link?: LinkTarget<Linkable, Row>;
displayVariant?: EnumDisplayVariant;
inputVariant?: Exclude<EnumInputVariant, SearchInputVariant$1 | OptionsInputVariant$1> | SearchInputVariant<Value> | OptionsInputVariant<Value>;
}>>;ErrorResponseBuilder
declare class ErrorResponseBuilder extends BaseResponseBuilder implements Respondable<ErrorResponse> {
constructor(status: HttpErrorStatusCode, code: string);
setErrors(errors: ValidationError[]): this;
[TO_RESPONSE](): ErrorResponse;
}ExtensionManager
declare class ExtensionManager {
install(extension: BacklitExtension): void;
list(): ManifestExtension[];
}ExtractNumberFormat
type ExtractNumberFormat<Options> = Options extends {
format: infer Format extends NumberFormat;
} ? Format : undefined;FieldRemappers
declare class FieldRemappers {
constructor();
registerRole<Role extends FieldRole>(role: Role, remappers: FieldRemapperMap<Role>): void;
registerRemappers<Role extends FieldRole>(role: Role, remappers: Partial<FieldRemapperMap<Role>>): void;
remapField<Role extends FieldRole>(field: Field, record: Record<string, unknown>, value: unknown, role: Role, fallbackRole: FieldRemapperFallbackRole, report: ReportDefect): unknown;
}fields
declare const fields: FieldsFactory;FieldsFactory
declare class FieldsFactory extends Macroable {
text<Name extends string>(name: Name, options?: TextFieldOptions): TextFieldBuilder<Name, unknown>;
number<Name extends string, const Options extends NumberFieldOptions = {}>(name: Name, options?: Options): NumberFieldBuilder<Name, unknown, ExtractNumberFormat<Options>>;
boolean<Name extends string>(name: Name, options?: BooleanFieldOptions): BooleanFieldBuilder<Name, unknown>;
date<Name extends string>(name: Name, options?: DateFieldOptions): DateFieldBuilder<Name, unknown>;
enum<Name extends string, const Choices extends readonly EnumOption[]>(name: Name, choices: Choices, options?: EnumFieldOptions): EnumFieldBuilder<Name, Choices, unknown>;
ref<Name extends string, Target extends Resource<string, readonly FieldBuilderContract<string, unknown, never>[]>, const Options extends RefFieldOptions<unknown, ExtractResourceRecord<Target>, ExtractResourceFieldNames<Target>> & {
display: ExtractResourceFieldNames<Target> | FieldBuilderContract<string, unknown, ExtractResourceRecord<Target>>;
}>(name: Name, to: () => Target, options: Options): RefFieldBuilder<Name, GetRefFieldValueFor<Options>, GetRefFieldCardinalityFor<Options>, ExtractResourceRecord<Target>, unknown>;
has<Name extends string, Target extends Resource<string, readonly FieldBuilderContract<string, unknown, never>[]>>(name: Name, of: () => Target, options: HasFieldOptions<ExtractResourceRecord<Target>, ExtractResourceFieldNames<Target>> & {
display: ExtractResourceFieldNames<Target> | FieldBuilderContract<string, unknown, ExtractResourceRecord<Target>>;
}): HasFieldBuilder<Name, ExtractResourceRecord<Target>, unknown>;
group<Name extends string>(name: Name, fields: FieldBuilderContract<string, unknown, never>[], options?: GroupFieldOptions): GroupFieldBuilder<Name, unknown>;
}FilterBar
declare class FilterBar<Filters extends readonly FilterBuilderContract<string>[] = readonly FilterBuilderContract<string>[]> implements StateAtomContract<ParseFilters<Filters>> {
readonly [KEYWORD] = "f";
readonly definesResult = true;
readonly dependsOnResult = false;
constructor(filters: Filters);
fieldNames(): string[];
list(): Filters;
get<Name extends ExtractFilterNames<Filters>>(name: Name): ExtractFilterByName<Filters, Name>;
[PARSE](values: SearchValues): ParseFilters<Filters>;
}filters
declare const filters: FiltersFactory;FiltersFactory
declare class FiltersFactory extends Macroable {
text<Name extends string>(name: Name): TextFilterBuilder<Name>;
select<Name extends string, const Options extends readonly FilterOption[]>(name: Name, options: Options): SelectFilterBuilder<Name, Options, "one">;
toggle<Name extends string>(name: Name): ToggleFilterBuilder<Name>;
dateRange<Name extends string>(name: Name): DateRangeFilterBuilder<Name>;
numberRange<Name extends string>(name: Name, options: NumberRangeOptions): NumberRangeFilterBuilder<Name>;
period<Name extends string, const Units extends readonly PeriodFilter['units'][number][]>(name: Name, units: Units): PeriodFilterBuilder<Name, Units>;
}form
declare function form<Schema extends StandardSchemaV1<Record<string, unknown>, unknown>>(action: ActionDefinition<string, string, Schema, ParamNames>): FormBuilder<StandardSchemaV1.InferInput<Schema>>;FormBuilder
declare class FormBuilder<SchemaInput extends Record<string, unknown>> implements Resolvable<FormNode> {
constructor(resource: string, action: string);
[FIELD_FOR](path: string): FieldBuilderContract<string, unknown, never> | undefined;
[REPEATER_FOR](name: string): FormRepeaterBuilder | undefined;
fields<const Fields extends readonly GetFieldBuildersFor<SchemaInput>[]>(...picked: Fields): FormFieldsBuilder<Fields>;
repeater<const Key extends ExtractRepeaterKeys<SchemaInput>, const Fields extends readonly GetFieldBuildersFor<ExtractRepeaterRow<SchemaInput, Key>>[]>(name: Key, fields: Fields | ((row: ConditionComposer<ExtractRepeaterRow<SchemaInput, Key>>) => Fields)): FormRepeaterBuilder<Fields>;
when<const Path extends DataPath<SchemaInput>>(path: Path): PredicateFor<SchemaInput, GetValueAtPath<SchemaInput, Path>>;
ref<const Path extends DataPath<SchemaInput>>(path: Path): Ref<SchemaInput, NonNullable<GetValueAtPath<SchemaInput, Path>>>;
all(first: ConditionBuilder<SchemaInput>, ...rest: ConditionBuilder<SchemaInput>[]): ConditionBuilder<SchemaInput>;
any(first: ConditionBuilder<SchemaInput>, ...rest: ConditionBuilder<SchemaInput>[]): ConditionBuilder<SchemaInput>;
none(first: ConditionBuilder<SchemaInput>, ...rest: ConditionBuilder<SchemaInput>[]): ConditionBuilder<SchemaInput>;
setContent(content: Producer[]): this;
withInitialData(values: FormInitialData<SchemaInput>): this;
setSubmitAction(options: {
label: string;
}): this;
setClearAction(options: {
label: string;
}): this;
onDefect(reporter: DefectReporter): this;
serialize(ctx: RequestContext, blocks: readonly FormFieldsBuilder[], initialData: Record<string, unknown> | undefined): {
target: FormNode['target'];
fields: FormFieldsNode[];
initial?: Record<string, unknown>;
};
[RESOLVE](ctx: RequestContext<'view' | 'zone'>): Promise<FormNode>;
[RESOLVE_FOR](ctx: RequestContext<'view' | 'zone'>, zone: string): Promise<ZoneNode | undefined>;
}FormFieldsBuilder
declare class FormFieldsBuilder<Fields extends readonly FieldBuilderContract<string>[] = readonly FieldBuilderContract<string>[]> implements Nodeable<FormFieldsNode> {
constructor(fields: FieldBuilderContract<ExtractFieldNames<Fields>>[], onFields?: (fields: {
builder: FieldBuilderContract<string, unknown, never>;
node: Field;
}[], roles: Partial<Record<string, FieldRole>>) => void);
peers(...sets: ExtractFieldNames<Fields>[][]): this;
setRoles(roles: GetFieldRoleSelectionsFor<Fields>): this;
revealWhen<Scope>(condition: ConditionBuilder<Scope>): this;
enableWhen<Scope>(condition: ConditionBuilder<Scope>): this;
[TO_NODE](ctx: RequestContext): FormFieldsNode;
}FormRepeaterBuilder
declare class FormRepeaterBuilder<Fields extends readonly FieldBuilderContract<string>[] = readonly FieldBuilderContract<string>[]> implements Nodeable<FormRepeaterNode> {
constructor(name: string, fields: FieldBuilderContract<ExtractFieldNames<Fields>>[], onRows?: (name: string, fields: {
builder: FieldBuilderContract<string, unknown, never>;
node: Field;
}[], roles: Partial<Record<string, FieldRole>>) => void);
get [FIELD_NAME](): string;
[FIELD_FOR](path: string): FieldBuilderContract<string, unknown, never> | undefined;
peers(...sets: ExtractFieldNames<Fields>[][]): this;
setRoles(roles: GetFieldRoleSelectionsFor<Fields>): this;
setAddAction(options: {
label: string;
}): this;
setRemoveAction(options: {
label: string;
}): this;
setRowTitle(title: string): this;
setLimits(limits: {
min?: number;
max?: number;
}): this;
revealWhen<Scope>(condition: ConditionBuilder<Scope>): this;
[TO_NODE](ctx: RequestContext): FormRepeaterNode;
}GetRefFieldCardinalityFor
type GetRefFieldCardinalityFor<Options, Fallback extends Cardinality = 'one'> = Options extends {
cardinality: infer Card extends Cardinality;
} ? Card : Fallback;GetRefFieldValueFor
type GetRefFieldValueFor<Options, Fallback = never> = Options extends {
inputVariant: SearchInputVariant<infer Value>;
} ? Value : Options extends {
inputVariant: OptionsInputVariant<infer Value>;
} ? Value : Fallback;group
declare function group(content: Producer[]): GroupBuilder;GroupBuilder
declare class GroupBuilder implements Resolvable<GroupNode> {
constructor(content: Producer[]);
[RESOLVE](ctx: RequestContext<'view' | 'zone'>): Promise<GroupNode>;
[RESOLVE_FOR](ctx: RequestContext<'view' | 'zone'>, zoneId: string): Promise<ZoneNode | undefined>;
}GroupFieldBuilder
declare class GroupFieldBuilder<Name extends string = string, Row = unknown> implements Nodeable<GroupField>, FieldBuilderContract<Name, never, Row> {
readonly [FIELD_ROW]?: (row: Row) => void;
constructor(name: Name, fields: FieldBuilderContract<string, unknown, never>[], options?: GroupFieldOptions<Row>);
get [FIELD_NAME](): Name;
[FIELD_FOR](path: string): FieldBuilderContract<string, unknown, never> | undefined;
revealWhen<Scope>(condition: ConditionBuilder<Scope>): GroupFieldBuilder<Name, Row>;
enableWhen<Scope>(condition: ConditionBuilder<Scope>): GroupFieldBuilder<Name, Row>;
configure<R = Row>(options: GroupFieldOptions<R>): GroupFieldBuilder<Name, R>;
clone(): GroupFieldBuilder<Name, Row>;
[TO_NODE](ctx: RequestContext): {
enable?: import("@backlit/contract").Condition;
reveal?: import("@backlit/contract").Condition;
link?: import("@backlit/contract").LinkTargetAddress;
label: string;
fields: import("@backlit/contract").Field[];
description?: string;
kind: "group";
name: Name;
};
[VALUE_FOR](row: Record<string, unknown>, node: GroupField, report: ReportDefect, options?: {
role?: FieldRole;
}): unknown;
}GroupFieldOptions
type GroupFieldOptions<Row = unknown> = Prettify<ConditionableOptions<Partial<Omit<GroupField, 'kind' | 'name' | 'fields' | 'link'>>> & {
link?: LinkTarget<Linkable, Row>;
}>;HasFieldBuilder
declare class HasFieldBuilder<Name extends string = string, TargetRow = never, Row = unknown> implements Nodeable<HasField>, FieldBuilderContract<Name, never, Row> {
readonly [FIELD_ROW]?: (row: Row) => void;
constructor(name: Name, of: () => unknown, options?: HasFieldOptions<TargetRow, string, Row>);
get [FIELD_NAME](): Name;
revealWhen<Scope>(condition: ConditionBuilder<Scope>): HasFieldBuilder<Name, TargetRow, Row>;
enableWhen<Scope>(condition: ConditionBuilder<Scope>): HasFieldBuilder<Name, TargetRow, Row>;
configure<R = Row>(options: HasFieldOptions<TargetRow, string, R>): HasFieldBuilder<Name, TargetRow, R>;
clone(): HasFieldBuilder<Name, TargetRow, Row>;
[TO_NODE](ctx: RequestContext): {
enable?: import("@backlit/contract").Condition;
reveal?: import("@backlit/contract").Condition;
link?: import("@backlit/contract").LinkTargetAddress;
label: string;
display: import("@backlit/contract").Field;
description?: string;
cardinality?: import("@backlit/contract").Cardinality;
kind: "has";
name: Name;
};
[VALUE_FOR](row: Record<string, unknown>, node: HasField, report: ReportDefect, options?: {
role?: FieldRole;
}): unknown;
}HasFieldOptions
type HasFieldOptions<TargetRow = never, Names extends string = string, Row = unknown> = Prettify<ConditionableOptions<Partial<Omit<HasField, 'kind' | 'name' | 'display' | 'link'>> & {
link?: LinkTarget<Linkable, Row>;
display?: Names | FieldBuilderContract<string, unknown, TargetRow>;
}>>;HttpRequest
declare class HttpRequest {
constructor(options: HttpRequestOptions);
query(): Record<string, string | string[]>;
headers(): Record<string, string>;
cookies(): Record<string, string>;
json(): Promise<unknown>;
formdata(): Promise<FormData>;
}ItemListBuilder
declare class ItemListBuilder<Row extends Record<string, unknown> = Record<string, unknown>> implements Nodeable<ItemListNode> {
constructor(data: Row[], configure: (item: ListItemBuilder<Row>, row: Row) => void);
setDensity(density: ListDensity): this;
onDefect(reporter: DefectReporter): this;
setPaginator(binding: StateBinding<Paginator>, options?: {
total?: number;
}): this;
[TO_NODE](ctx: RequestContext): ItemListNode;
}ItemTimelineBuilder
declare class ItemTimelineBuilder<Row extends Record<string, unknown> = Record<string, unknown>> implements Nodeable<ItemTimelineNode> {
constructor(data: Row[], configure: (item: TimelineItemBuilder<Row>, row: Row) => void);
setDensity(density: ListDensity): this;
onDefect(reporter: DefectReporter): this;
setPaginator(binding: StateBinding<Paginator>, options?: {
total?: number;
}): this;
[TO_NODE](ctx: RequestContext): ItemTimelineNode;
}Kernel
declare class Kernel {
constructor(resources: Record<string, ResourceLoader>, middleware: MiddlewareLoader[]);
renderView(resource: string, view: string, args?: string[], transport?: Transport, search?: SearchParams): Promise<ValidViewResponse>;
renderZone(resource: string, view: string, zone: string, args?: string[], transport?: Transport, search?: SearchParams): Promise<ValidZoneResponse>;
handleAction(resource: string, action: string, payload: unknown, args?: string[], transport?: Transport): Promise<ValidActionResponse>;
handleLookup(resource: string, lookup: string, searchQuery: string, args?: string[], transport?: Transport): Promise<ValidLookupResponse>;
}LineChartBuilder
declare class LineChartBuilder<Row extends Record<string, unknown> = Record<string, unknown>> implements Nodeable<LineChart> {
constructor(data: Row[]);
setFields(fields: LineChartFieldsInput<Row>): this;
setOptions(options: LineChartOptions): this;
onClick(target: LinkTarget<Linkable, Row>): this;
onDefect(reporter: DefectReporter): this;
[TO_NODE](ctx: RequestContext): LineChart;
}LineChartFieldsInput
type LineChartFieldsInput<Row> = {
x: FieldBuilderContract<string, unknown, Row>;
series: NumberFieldBuilder<string, Row> | readonly NumberFieldBuilder<string, Row>[];
};LinkTarget
declare class LinkTarget<View extends Linkable = Linkable, Row = unknown> {
constructor(source: () => View, args?: GetArgsFor<View['params']> | ((record: Row) => GetArgsFor<View['params']>), options?: ViewTargetOptions<View, Row>);
[TO_NODE](): LinkTargetAddress;
valueFor(record: Row): LinkTargetValue;
}linkTo
declare function linkTo<View extends Linkable, Row = unknown>(view: View | (() => View), ...rest: View['params'] extends readonly [
] ? [
args?: GetArgsFor<View['params']> | ((record: Row) => GetArgsFor<View['params']>),
options?: ViewTargetOptions<View, Row>
] : [
args: GetArgsFor<View['params']> | ((record: Row) => GetArgsFor<View['params']>),
options?: ViewTargetOptions<View, Row>
]): LinkTarget<View, Row>;list
declare function list<Row extends Record<string, unknown>>(data: Row[]): RecordListBuilder<Row>;
declare function list<Row extends Record<string, unknown>>(data: Row[], configure: (item: ListItemBuilder<Row>, row: Row) => void): ItemListBuilder<Row>;ListItemBuilder
declare class ListItemBuilder<Row extends Record<string, unknown> = Record<string, unknown>> {
setFields(fields: ListItemFieldsInput<Row>): this;
onClick(target: LinkTarget<Linkable, Row>): this;
setActions(targets: TargetBuilderContract<Row>[]): this;
[TO_NODE](ctx: RequestContext, { row, index, onDefect }: ItemEmit$1<Row>): ListItem;
}ListItemFieldsInput
type ListItemFieldsInput<Row> = {
leading?: PositionInput$2<Row> | undefined;
title: PositionInput$2<Row>;
description?: PositionInput$2<Row> | undefined;
meta?: PositionInput$2<Row> | undefined;
trailing?: PositionInput$2<Row> | undefined;
};LookupBuilder
declare class LookupBuilder<Fields extends readonly FieldBuilderContract<string, unknown, never>[] = readonly FieldBuilderContract<string, unknown, never>[]> implements Nodeable<LookupNode> {
setFields<const F extends readonly FieldBuilderContract<string, unknown, never>[]>(fields: F): LookupBuilder<F>;
withData(data: Record<string, unknown>[]): this;
setRoles(roles: GetFieldRoleSelectionsFor<Fields>): this;
onDefect(reporter: DefectReporter): this;
[TO_NODE](ctx: RequestContext): LookupNode;
}LookupDefinition
declare class LookupDefinition<Resource extends string, Name extends string, Fields extends readonly FieldBuilderContract<string, unknown, never>[], Params extends ParamNames = readonly [
]> {
readonly resource: Resource;
readonly name: Name;
readonly params: Params;
constructor(resource: Resource, name: Name, params: Params, resolver: LookupResolver<Fields, Params>);
setAgentOptions(options: AgentOptions): this;
get agentOptions(): AgentOptions | undefined;
toAgentTool(): AgentTool | undefined;
resolve(ctx: RequestContext<'lookup', Params>): Promise<ValidLookupResponse>;
}LookupTarget
declare class LookupTarget implements Nodeable<LookupTarget$1> {
constructor(source: () => LookupDefinition<string, string, readonly FieldBuilderContract<string>[], ParamNames>, args: GetLookupArgsFor<ParamNames>);
[TO_NODE](): LookupTarget$1;
}lookupVia
declare function lookupVia<Fields extends readonly FieldBuilderContract<string>[], Params extends ParamNames, Value extends ExtractFieldNames<Fields>>(source: LookupDefinition<string, string, Fields, Params> | (() => LookupDefinition<string, string, Fields, Params>), ...rest: Params extends readonly [
] ? [
options: {
value: Value;
label: ExtractFieldNames<Fields>;
create?: VisitTarget<Linkable, never>;
}
] : [
args: GetLookupArgsFor<Params>,
options: {
value: Value;
label: ExtractFieldNames<Fields>;
create?: VisitTarget<Linkable, never>;
}
]): SearchInputVariant<ExtractFieldValue<ExtractFieldByName<Fields, Value>>>;NumberFieldBuilder
declare class NumberFieldBuilder<Name extends string = string, Row = unknown, Format extends NumberFormat | undefined = undefined> implements Nodeable<NumberField>, FieldBuilderContract<Name, number, Row> {
readonly [FIELD_VALUE]?: number;
readonly [FIELD_ROW]?: (row: Row) => void;
constructor(name: Name, options?: NumberFieldOptions<Row>, perRecord?: ((row: Row) => ResolvedPerRecord | undefined)[]);
get [FIELD_NAME](): Name;
revealWhen<Scope>(condition: ConditionBuilder<Scope>): NumberFieldBuilder<Name, Row, Format>;
enableWhen<Scope>(condition: ConditionBuilder<Scope>): NumberFieldBuilder<Name, Row, Format>;
configure<R = Row, const Options extends NumberFieldOptions<R> = NumberFieldOptions<R>>(options: Options): NumberFieldBuilder<Name, R, Options extends {
format: NumberFormat;
} ? ExtractNumberFormat<Options> : Format>;
configure<R = Row>(perRecord: (row: R) => NumberPerRecordOptions<Format> | undefined): NumberFieldBuilder<Name, R, Format>;
clone(): NumberFieldBuilder<Name, Row, Format>;
[TO_NODE](ctx?: RequestContext): NumberField;
[VALUE_FOR](row: Row, node: NumberField, report: ReportDefect, options?: {
role?: FieldRole;
}): unknown;
}NumberFieldFormatOptions
type NumberFieldFormatOptions = ({
format?: undefined;
decimals?: NumberDecimals;
} & {
[Key in Exclude<FormatOptionKeys, 'decimals'>]?: never;
}) | {
[Format in NumberFormat]: ExclusiveFormatOptions<Format>;
}[NumberFormat];NumberFieldOptions
type NumberFieldOptions<Row = unknown> = Prettify<NumberFieldCommonOptions<Row> & NumberFieldFormatOptions>;NumberPerRecordOptions
type NumberPerRecordOptions<Format> = Format extends NumberFormat ? Partial<Omit<ExclusiveFormatOptions<Format>, 'format' | 'decimals'>> & {
decimals?: never;
} : {
[Key in FormatOptionKeys]?: never;
};NumberRangeFilterBuilder
declare class NumberRangeFilterBuilder<Name extends string = string> implements Nodeable<NumberRangeFilter>, FilterBuilderContract<Name, {
from?: number;
to?: number;
}> {
readonly [FILTER_VALUE]?: {
from?: number;
to?: number;
};
constructor(name: Name, options: NumberRangeOptions);
get [FILTER_NAME](): Name;
setLabel(text: string): this;
[PARSE](raw: unknown): {
from?: number;
to?: number;
} | undefined;
[STRINGIFY](value: {
from?: number;
to?: number;
}): string;
[TO_NODE](): {
step?: number;
kind: "number-range";
name: Name;
label: string;
min: number;
max: number;
};
}NumberRangeOptions
type NumberRangeOptions = {
min: number;
max: number;
step?: number;
};OptionsInputVariant
declare class OptionsInputVariant<Value = unknown> implements Nodeable<OptionsInputVariant$1> {
readonly target: LookupTarget;
constructor(target: LookupTarget, value: string, label: string);
[TO_NODE](): OptionsInputVariant$1;
[VALUE_FOR](value: unknown, node: OptionsInputVariant$1, report: ReportDefect): unknown;
}optionsVia
declare function optionsVia<Fields extends readonly FieldBuilderContract<string>[], Params extends ParamNames, Value extends ExtractFieldNames<Fields>>(source: LookupDefinition<string, string, Fields, Params> | (() => LookupDefinition<string, string, Fields, Params>), ...rest: Params extends readonly [
] ? [
options: {
value: Value;
label: ExtractFieldNames<Fields>;
}
] : [
args: GetLookupArgsFor<Params>,
options: {
value: Value;
label: ExtractFieldNames<Fields>;
}
]): OptionsInputVariant<ExtractFieldValue<ExtractFieldByName<Fields, Value>>>;Paginator
declare class Paginator implements StateAtomContract<PaginatorState> {
readonly [KEYWORD] = "p";
readonly definesResult = false;
readonly dependsOnResult = true;
constructor(options: {
perPage: number;
param?: string;
});
fieldNames(): string[];
param(): string;
perPage(): number;
[PARSE](values: SearchValues): PaginatorState;
}panel
declare function panel(content: Producer[]): PanelBuilder;PanelBuilder
declare class PanelBuilder implements Resolvable<PanelNode> {
constructor(content: Producer[]);
setTitle(text: string, options?: {
icon?: string;
}): this;
setDescription(text: string, options?: {
icon?: string;
}): this;
setBadge(text: string, options?: {
tone?: Tone;
icon?: string;
}): this;
setFootnote(text: string, options?: {
icon?: string;
}): this;
setActions(targets: TargetBuilderContract<never>[]): this;
setFilters(binding: StateBinding<FilterBar>): this;
revealWhen<Scope>(condition: ConditionBuilder<Scope>): this;
[RESOLVE](ctx: RequestContext<'view' | 'zone'>): Promise<PanelNode>;
[RESOLVE_FOR](ctx: RequestContext<'view' | 'zone'>, zone: string): Promise<ZoneNode | undefined>;
}parseSearchParams
declare function parseSearchParams(queryString: string): SearchParams;PeriodFilterBuilder
declare class PeriodFilterBuilder<Name extends string = string, Units extends readonly PeriodFilter['units'][number][] = readonly PeriodFilter['units'][number][]> implements Nodeable<PeriodFilter>, FilterBuilderContract<Name, Units[number]> {
readonly [FILTER_VALUE]?: Units[number];
constructor(name: Name, units: Units);
get [FILTER_NAME](): Name;
setLabel(text: string): this;
[PARSE](raw: unknown): Units[number] | undefined;
[STRINGIFY](value: Units[number]): string;
[TO_NODE](): {
kind: "period";
name: Name;
label: string;
units: Units[number][];
};
}RecordListBuilder
declare class RecordListBuilder<Row extends Record<string, unknown> = Record<string, unknown>> implements Nodeable<RecordListNode> {
constructor(data: Row[]);
setFields(fields: RecordListFieldsInput<Row>): this;
setDensity(density: ListDensity): this;
onRowClick(target: LinkTarget<Linkable, Row>): this;
setRowActions(targets: TargetBuilderContract<Row>[]): this;
onDefect(reporter: DefectReporter): this;
setPaginator(binding: StateBinding<Paginator>, options?: {
total?: number;
}): this;
setSorter(binding: StateBinding<Sorter>): this;
[TO_NODE](ctx: RequestContext): RecordListNode;
}RecordListFieldsInput
type RecordListFieldsInput<Row> = {
leading?: PositionInput$3<Row>;
title: PositionInput$3<Row>;
description?: PositionInput$3<Row>;
meta?: PositionInput$3<Row>;
trailing?: PositionInput$3<Row>;
};RecordTimelineBuilder
declare class RecordTimelineBuilder<Row extends Record<string, unknown> = Record<string, unknown>> implements Nodeable<RecordTimelineNode> {
constructor(data: Row[]);
setFields(fields: RecordTimelineFieldsInput<Row>): this;
setDensity(density: ListDensity): this;
onRowClick(target: LinkTarget<Linkable, Row>): this;
setRowActions(targets: TargetBuilderContract<Row>[]): this;
onDefect(reporter: DefectReporter): this;
setPaginator(binding: StateBinding<Paginator>, options?: {
total?: number;
}): this;
setSorter(binding: StateBinding<Sorter>): this;
[TO_NODE](ctx: RequestContext): RecordTimelineNode;
}RecordTimelineFieldsInput
type RecordTimelineFieldsInput<Row> = {
marker?: FieldBuilderContract<string, unknown, Row>;
time: FieldBuilderContract<string, unknown, Row>;
title: PositionInput$1<Row>;
description?: PositionInput$1<Row>;
meta?: PositionInput$1<Row>;
body?: FieldBuilderContract<string, unknown, Row>;
};RedirectResponseBuilder
declare class RedirectResponseBuilder extends BaseResponseBuilder implements Respondable<RedirectResponse> {
constructor(resource: string, view: string, args?: readonly (string | number)[]);
[TO_RESPONSE](): RedirectResponse;
}Ref
declare class Ref<Scope, Value> {
readonly path: string;
constructor(path: string);
}RefFieldBuilder
declare class RefFieldBuilder<Name extends string = string, Value = never, Card extends Cardinality = 'one', TargetRow = never, Row = unknown> implements Nodeable<RefField>, FieldBuilderContract<Name, CardinalityValue<Value, Card>, Row> {
readonly [FIELD_VALUE]?: CardinalityValue<Value, Card>;
readonly [FIELD_ROW]?: (row: Row) => void;
constructor(name: Name, to: () => unknown, options?: RefFieldOptions<unknown, TargetRow, string, Row>);
get [FIELD_NAME](): Name;
revealWhen<Scope>(condition: ConditionBuilder<Scope>): RefFieldBuilder<Name, Value, Card, TargetRow, Row>;
enableWhen<Scope>(condition: ConditionBuilder<Scope>): RefFieldBuilder<Name, Value, Card, TargetRow, Row>;
configure<R = Row, const Options extends RefFieldOptions<unknown, TargetRow, string, R> = RefFieldOptions<unknown, TargetRow, string, R>>(options: Options): RefFieldBuilder<Name, GetRefFieldValueFor<Options, Value>, GetRefFieldCardinalityFor<Options, Card>, TargetRow, R>;
clone(): RefFieldBuilder<Name, Value, Card, TargetRow, Row>;
[TO_NODE](ctx: RequestContext): {
enable?: import("@backlit/contract").Condition;
reveal?: import("@backlit/contract").Condition;
inputVariant?: import("@backlit/contract").SearchInputVariant | import("@backlit/contract").OptionsInputVariant;
link?: import("@backlit/contract").LinkTargetAddress;
label: string;
display: import("@backlit/contract").Field;
description?: string;
cardinality?: Cardinality;
kind: "ref";
name: Name;
};
[VALUE_FOR](row: Record<string, unknown>, node: RefField, report: ReportDefect, options?: {
role?: FieldRole;
}): unknown;
}RefFieldOptions
type RefFieldOptions<Value = unknown, TargetRow = never, Names extends string = string, Row = unknown> = Prettify<ConditionableOptions<Partial<Omit<RefField, 'kind' | 'name' | 'display' | 'link' | 'inputVariant'>> & {
link?: LinkTarget<Linkable, Row>;
display?: Names | FieldBuilderContract<string, unknown, TargetRow>;
inputVariant?: SearchInputVariant<Value> | OptionsInputVariant<Value>;
}>>;RefreshResponseBuilder
declare class RefreshResponseBuilder extends BaseResponseBuilder implements Respondable<RefreshResponse> {
constructor(zones: string[]);
[TO_RESPONSE](): RefreshResponse;
}remappers
declare const remappers: FieldRemappers;RequestContext
declare class RequestContext<Kind extends RequestKind = RequestKind, Params extends ParamNames = ParamNames, Data = Kind extends 'action' ? unknown : never, SearchQuery = Kind extends 'lookup' ? string : never> {
readonly kind: Kind;
readonly resource: string;
readonly name: string;
readonly mode: TargetMode;
readonly args: string[];
readonly paramValues: GetParamValuesFor<Params>;
readonly searchQuery: SearchQuery;
constructor(request: RequestContextOptions<Kind, Params, Data, SearchQuery>);
get data(): Data;
fillParams(names: ParamNames): void;
fillData(data: Data): void;
parse<Atoms extends StateAtoms>(scope: {
state: ExtractStateBindings<Atoms>;
}): ParseState<Atoms>;
reserveStateFields(bindings: ExtractStateBindings<StateAtoms>): void;
register(zone: string, atoms?: Iterable<StateAtomContract>): void;
fail(rejection: string | Record<string, string>, options?: {
code?: string;
}): never;
notify(notification: string | {
text: string;
title?: string;
tone?: Tone;
}): SuccessResponseBuilder;
redirectTo<View extends ViewDefinition<string, string, ParamNames>>(view: View, ...args: View['params'] extends (infer TargetParams extends ParamNames) ? TargetParams extends readonly [
] ? [
] : [
values: {
readonly [Index in keyof TargetParams]: string | number;
}
] : never): RedirectResponseBuilder;
redirectTo(target: {
resource: string;
view: string;
}, args?: readonly (string | number)[]): RedirectResponseBuilder;
refresh(): RefreshResponseBuilder;
refreshZones(zones: string[]): RefreshResponseBuilder;
error(status: HttpErrorStatusCode, code: string): ErrorResponseBuilder;
}Resource
declare class Resource<Name extends string, Fields extends readonly FieldBuilderContract<string, unknown, never>[]> {
constructor(name: Name, fields: Fields);
get name(): Name;
pick<const Names extends readonly ExtractFieldNames<Fields>[]>(...names: Names): PickFieldBuilders<Fields, Names>;
get<FieldName extends ExtractFieldNames<Fields>>(name: FieldName): ExtractFieldByName<Fields, FieldName>;
group(fields: FieldBuilderContract<string, unknown, ExtractRecordOf<Fields>>[]): GroupFieldBuilder<'', ExtractRecordOf<Fields>>;
view<ViewName extends string>(name: ViewName, resolver: ViewResolver<readonly [
]>): ViewDefinition<Name, ViewName>;
view<ViewName extends string, const Params extends ParamNames>(name: ViewName, params: Params, resolver: ViewResolver<Params>): ViewDefinition<Name, ViewName, Params>;
view<ViewName extends string, Atoms extends StateAtoms>(name: ViewName, atoms: Atoms, resolver: ViewResolver<readonly [
], Atoms>): ViewDefinition<Name, ViewName, readonly [
], Atoms>;
view<ViewName extends string, const Params extends ParamNames, Atoms extends StateAtoms>(name: ViewName, params: Params, atoms: Atoms, resolver: ViewResolver<Params, Atoms>): ViewDefinition<Name, ViewName, Params, Atoms>;
getView(name: string): ViewDefinition<Name, string, ParamNames> | undefined;
views(): ViewDefinition<Name, string, ParamNames>[];
action<ActionName extends string, Schema extends StandardSchemaV1>(name: ActionName, schema: Schema, handler: ActionHandler<Schema, readonly [
]>): ActionDefinition<Name, ActionName, Schema>;
action<ActionName extends string, const Params extends ParamNames, Schema extends StandardSchemaV1>(name: ActionName, params: Params, schema: Schema, handler: ActionHandler<Schema, Params>): ActionDefinition<Name, ActionName, Schema, Params>;
getAction(name: string): ActionDefinition<Name, string, any, ParamNames> | undefined;
actions(): ActionDefinition<Name, string, any, ParamNames>[];
lookup<LookupName extends string, const LookupFields extends readonly FieldBuilderContract<string, unknown, never>[]>(name: LookupName, resolver: LookupResolver<LookupFields>): LookupDefinition<Name, LookupName, LookupFields>;
lookup<LookupName extends string, const LookupFields extends readonly FieldBuilderContract<string, unknown, never>[], const Params extends ParamNames>(name: LookupName, options: {
params: Params;
}, resolver: LookupResolver<LookupFields, Params>): LookupDefinition<Name, LookupName, LookupFields, Params>;
getLookup(name: string): LookupDefinition<Name, string, readonly FieldBuilderContract<string, unknown, never>[], ParamNames> | undefined;
lookups(): LookupDefinition<Name, string, readonly FieldBuilderContract<string, unknown, never>[], ParamNames>[];
toAgentTools(): AgentTool[];
}SearchInputVariant
declare class SearchInputVariant<Value = unknown> implements Nodeable<SearchInputVariant$1> {
readonly target: LookupTarget;
constructor(target: LookupTarget, value: string, label: string, create?: VisitTarget<Linkable, never>);
[TO_NODE](ctx: RequestContext): SearchInputVariant$1;
[VALUE_FOR](value: unknown, node: SearchInputVariant$1, report: ReportDefect): unknown;
}section
declare function section(title?: string): SectionBuilder;SectionBuilder
declare class SectionBuilder implements Resolvable<SectionNode> {
constructor(title?: string);
setDescription(description: string): this;
setContent(nodes: Producer[]): this;
setAside(nodes: Producer[]): this;
setActions(targets: TargetBuilderContract<never>[]): this;
setFilters(binding: StateBinding<FilterBar>): this;
revealWhen<Scope>(condition: ConditionBuilder<Scope>): this;
[RESOLVE](ctx: RequestContext<'view' | 'zone'>): Promise<SectionNode>;
[RESOLVE_FOR](ctx: RequestContext<'view' | 'zone'>, zoneId: string): Promise<ZoneNode | undefined>;
}SegmentableFilters
type SegmentableFilters = readonly [
FilterBuilderContract<string, string>
];segments
declare function segments<const Filters extends SegmentableFilters>(binding: StateBinding<FilterBar<Filters>>, options?: SegmentsOptions<ExtractFilterValue<Filters[0]> & string>): SegmentsBuilder<Filters>;SegmentsBuilder
declare class SegmentsBuilder<Filters extends SegmentableFilters = SegmentableFilters> implements Nodeable<SegmentsNode> {
constructor(binding: StateBinding<FilterBar<Filters>>, options?: SegmentsOptions<ExtractFilterValue<Filters[0]> & string>);
[TO_NODE](ctx: RequestContext): SegmentsNode;
}SegmentsOptions
type SegmentsOptions<Value extends string> = {
counts?: Partial<Record<Value | 'all', number>>;
tones?: Partial<Record<Value | 'all', Tone>>;
labels?: Partial<Record<Value | 'all', string>>;
};SelectFilterBuilder
declare class SelectFilterBuilder<Name extends string = string, Options extends readonly FilterOption[] = readonly FilterOption[], Card extends Cardinality = 'one'> implements Nodeable<SelectFilter>, FilterBuilderContract<Name, CardinalityValue<Options[number]['value'], Card>> {
readonly [FILTER_VALUE]?: CardinalityValue<Options[number]['value'], Card>;
constructor(name: Name, options: Options);
get [FILTER_NAME](): Name;
setLabel(text: string): this;
setCardinality<C extends Cardinality>(cardinality: C): SelectFilterBuilder<Name, Options, C>;
[PARSE](raw: unknown): CardinalityValue<Options[number]['value'], Card> | undefined;
[STRINGIFY](value: CardinalityValue<Options[number]['value'], Card>): string | string[];
[TO_NODE](): {
cardinality?: Cardinality;
kind: "select";
name: Name;
label: string;
options: Options[number][];
};
}Sorter
declare class Sorter<Columns extends readonly string[] = readonly string[]> implements StateAtomContract<SorterState<Columns>> {
readonly [KEYWORD] = "s";
readonly definesResult = true;
readonly dependsOnResult = false;
constructor(options: {
columns: readonly FieldBuilderContract<string, unknown, never>[];
param?: string;
});
fieldNames(): string[];
param(): string;
columns(): Columns;
[PARSE](values: SearchValues): SorterState<Columns>;
}SparkAreaChartBuilder
declare class SparkAreaChartBuilder<Row extends Record<string, unknown> = Record<string, unknown>> implements Nodeable<SparkAreaChart> {
constructor(data: Row[]);
setFields(fields: SparkAreaChartFieldsInput<Row>): this;
setOptions(options: SparkAreaChartOptions): this;
onDefect(reporter: DefectReporter): this;
[TO_NODE](ctx: RequestContext): SparkAreaChart;
}SparkAreaChartFieldsInput
type SparkAreaChartFieldsInput<Row> = {
x: FieldBuilderContract<string, unknown, Row>;
series: NumberFieldBuilder<string, Row> | readonly NumberFieldBuilder<string, Row>[];
};StatInput
type StatInput = {
value: number;
field: NumberFieldBuilder<string, never>;
prior?: number;
delta?: Stat['delta'];
tone?: Tone;
description?: string;
descriptionIcon?: string;
};stringifySearchParams
declare function stringifySearchParams(search: SearchParams): string;submitTo
declare function submitTo<Schema extends StandardSchemaV1<Record<string, unknown>, unknown>, Params extends ParamNames, Row = unknown>(action: ActionDefinition<string, string, Schema, Params>, ...rest: Params extends readonly [
] ? [
args?: GetArgsFor<Params> | ((record: Row) => GetArgsFor<Params>),
presentation?: ActionTargetPresentationFor<Row>
] : [
args: GetArgsFor<Params> | ((record: Row) => GetArgsFor<Params>),
presentation?: ActionTargetPresentationFor<Row>
]): ActionTargetBuilder<StandardSchemaV1.InferInput<Schema>, Params, Row>;SuccessResponseBuilder
declare class SuccessResponseBuilder extends BaseResponseBuilder implements Respondable<ValidActionResponse> {
[TO_RESPONSE](): ValidActionResponse;
}tab
declare function tab(name: string, title: string): TabBuilder;TabBuilder
declare class TabBuilder {
readonly name: string;
constructor(name: string, title: string);
setIcon(name: string): this;
setCount(count: number, options?: {
tone?: Tone;
variant?: 'badge';
}): this;
setContent(nodes: Producer[]): this;
[RESOLVE](ctx: RequestContext<'view' | 'zone'>): Promise<TabNode>;
[RESOLVE_FOR](ctx: RequestContext<'view' | 'zone'>, zone: string): Promise<ZoneNode | undefined>;
}table
declare function table<Row extends Record<string, unknown>>(data: Row[]): TableBuilder<Row>;TableBuilder
declare class TableBuilder<Row extends Record<string, unknown> = Record<string, unknown>, Fields extends readonly FieldBuilderContract<string, unknown, never>[] = readonly FieldBuilderContract<string, unknown, never>[]> implements Nodeable<TableNode> {
constructor(data: Row[]);
setFields<const SelectedFields extends readonly FieldBuilderContract<string, unknown, never>[]>(fields: SelectedFields & readonly FieldBuilderContract<string, unknown, Row>[]): TableBuilder<Row, SelectedFields>;
withFooter(rows: TableFooterRow<ExtractFieldNames<Fields>>[]): this;
setRoles(roles: GetFieldRoleSelectionsFor<Fields>): this;
onRowClick(target: LinkTarget<Linkable, Row>): this;
setRowActions(targets: TargetBuilderContract<Row>[]): this;
onDefect(reporter: DefectReporter): this;
setPaginator(binding: StateBinding<Paginator>, options?: {
total?: number;
}): this;
setSorter(binding: StateBinding<Sorter>): this;
[TO_NODE](ctx: RequestContext): TableNode;
}tabs
declare function tabs(items: TabBuilder[]): TabsBuilder;TabsBuilder
declare class TabsBuilder implements Resolvable<TabsNode> {
constructor(items: TabBuilder[]);
setInitial(name: string): this;
setWidth(width: NonNullable<TabsNode['width']>): this;
setDensity(density: NonNullable<TabsNode['density']>): this;
[RESOLVE](ctx: RequestContext<'view' | 'zone'>): Promise<TabsNode>;
[RESOLVE_FOR](ctx: RequestContext<'view' | 'zone'>, zone: string): Promise<ZoneNode | undefined>;
}TextFieldBuilder
declare class TextFieldBuilder<Name extends string = string, Row = unknown> implements Nodeable<TextField>, FieldBuilderContract<Name, string, Row> {
readonly [FIELD_VALUE]?: string;
readonly [FIELD_ROW]?: (row: Row) => void;
constructor(name: Name, options?: TextFieldOptions<Row>);
get [FIELD_NAME](): Name;
revealWhen<Scope>(condition: ConditionBuilder<Scope>): TextFieldBuilder<Name, Row>;
enableWhen<Scope>(condition: ConditionBuilder<Scope>): TextFieldBuilder<Name, Row>;
configure<R = Row>(options: TextFieldOptions<R>): TextFieldBuilder<Name, R>;
clone(): TextFieldBuilder<Name, Row>;
[TO_NODE](ctx?: RequestContext): {
enable?: import("@backlit/contract").Condition;
reveal?: import("@backlit/contract").Condition;
inputVariant?: "input" | "textarea";
displayVariant?: never;
link?: import("@backlit/contract").LinkTargetAddress;
description?: string;
format?: import("@backlit/contract").TextFormat;
kind: "text";
name: Name;
label: string;
};
[VALUE_FOR](row: Row, node: TextField, report: ReportDefect, options?: {
role?: FieldRole;
}): unknown;
}TextFieldOptions
type TextFieldOptions<Row = unknown> = Prettify<ConditionableOptions<Partial<Omit<TextField, 'kind' | 'name' | 'link' | 'displayVariant' | 'inputVariant'>> & {
link?: LinkTarget<Linkable, Row>;
displayVariant?: TextDisplayVariant;
inputVariant?: 'input' | 'textarea';
}>>;TextFilterBuilder
declare class TextFilterBuilder<Name extends string = string> implements Nodeable<TextFilter>, FilterBuilderContract<Name, string> {
readonly [FILTER_VALUE]?: string;
constructor(name: Name);
get [FILTER_NAME](): Name;
setLabel(text: string): this;
[PARSE](raw: unknown): string | undefined;
[STRINGIFY](value: string): string;
[TO_NODE](): {
kind: "text";
name: Name;
label: string;
};
}timeline
declare function timeline<Row extends Record<string, unknown>>(data: Row[]): RecordTimelineBuilder<Row>;
declare function timeline<Row extends Record<string, unknown>>(data: Row[], configure: (item: TimelineItemBuilder<Row>, row: Row) => void): ItemTimelineBuilder<Row>;TimelineItemBuilder
declare class TimelineItemBuilder<Row extends Record<string, unknown> = Record<string, unknown>> {
setFields(fields: TimelineItemFieldsInput<Row>): this;
onClick(target: LinkTarget<Linkable, Row>): this;
setActions(targets: TargetBuilderContract<Row>[]): this;
[TO_NODE](ctx: RequestContext, { row, index, onDefect }: ItemEmit<Row>): TimelineItem;
}TimelineItemFieldsInput
type TimelineItemFieldsInput<Row> = {
marker?: FieldBuilderContract<string, unknown, Row> | undefined;
time: FieldBuilderContract<string, unknown, Row>;
title: PositionInput<Row>;
description?: PositionInput<Row> | undefined;
meta?: PositionInput<Row> | undefined;
body?: FieldBuilderContract<string, unknown, Row> | undefined;
};toActionNodes
declare function toActionNodes(targets: VisitTarget<Linkable, never>[], ctx: RequestContext): VisitTarget$1[];
declare function toActionNodes(targets: TargetBuilderContract<never>[], ctx: RequestContext): Target[];toAgentInputSchema
declare function toAgentInputSchema(keys: {
name: string;
description: string;
}[], payload?: Record<string, unknown>): Record<string, unknown>;toAgentParamKeys
declare function toAgentParamKeys(params: readonly string[]): {
name: string;
description: string;
}[];toFiltersNode
declare function toFiltersNode(binding: StateBinding<FilterBar>, ctx: RequestContext<'view' | 'zone'>): FiltersNode;ToggleFilterBuilder
declare class ToggleFilterBuilder<Name extends string = string> implements Nodeable<ToggleFilter>, FilterBuilderContract<Name, boolean> {
readonly [FILTER_VALUE]?: boolean;
constructor(name: Name);
get [FILTER_NAME](): Name;
setLabel(text: string): this;
[PARSE](raw: unknown): boolean | undefined;
[STRINGIFY](value: boolean): string;
[TO_NODE](): {
kind: "toggle";
name: Name;
label: string;
};
}toNodes
declare function toNodes<Node extends Block>(producers: (Nodeable<Node> | Resolvable<Node>)[], ctx: RequestContext<'view' | 'zone'>): Promise<Node[]>;
declare function toNodes<Node extends Block>(producers: Producer<Node>[], ctx: RequestContext<'view' | 'zone'>): Promise<(Node | ZoneNode)[]>;toSelectedOption
declare function toSelectedOption(value: unknown, read: {
value: string;
label: string;
}, report: ReportDefect): unknown;toStateAddress
declare function toStateAddress(binding: StateBinding<StateAtomContract>, ctx: RequestContext): {
keyword: string;
definesResult: boolean;
dependsOnResult: boolean;
zone?: string;
args?: string[];
resource: string;
view: string;
};toZoneNode
declare function toZoneNode(nodes: Producer[], ctx: RequestContext<'view' | 'zone'>, zoneId: string): Promise<ZoneNode | undefined>;view
declare function view<Atoms extends StateAtoms = {}>(name: string, atoms?: Atoms): ViewBuilder<Atoms>;ViewBreadcrumbOptions
type ViewBreadcrumbOptions<Row extends Record<string, unknown>> = {
ancestors: VisitTarget$1<Linkable, never>[];
fields?: FieldBuilderContract<string, unknown, Row>[];
};ViewBuilder
declare class ViewBuilder<Atoms extends StateAtoms = {}> implements Resolvable<ViewNode> {
constructor(name: string, atoms?: Atoms);
get state(): ExtractStateBindings<Atoms>;
setTitle(title: string): this;
setDescription(description: string): this;
setBreadcrumb<Row extends Record<string, unknown>>(data: Row, breadcrumb: ViewBreadcrumbOptions<Row>): this;
setContent(nodes: Producer[]): this;
[RESOLVE](ctx: RequestContext<'view' | 'zone'>): Promise<ViewNode>;
[RESOLVE_FOR](ctx: RequestContext<'view' | 'zone'>, zone: string): Promise<ZoneNode | undefined>;
}ViewDefinition
declare class ViewDefinition<Resource extends string, Name extends string, Params extends ParamNames = readonly [
], Atoms extends StateAtoms = {}> {
readonly resource: Resource;
readonly name: Name;
readonly params: Params;
constructor(resource: Resource, name: Name, params: Params, resolver: ViewResolver<Params, Atoms>, atoms?: Atoms);
setAgentOptions(options: AgentOptions): this;
get agentOptions(): AgentOptions | undefined;
get atoms(): Atoms | undefined;
toAgentTool(): AgentTool | undefined;
getAddress(values?: (string | number)[]): ViewAddress;
resolve(ctx: RequestContext<'view' | 'zone', Params>): Promise<ValidViewResponse>;
resolveZone(ctx: RequestContext<'view' | 'zone', Params>, zone: string): Promise<ValidZoneResponse>;
}VisitTarget
declare class VisitTarget$1<View extends Linkable = Linkable, Row = unknown> implements TargetBuilderContract<Row> {
constructor(reference: ViewTargetReference<View, Row>, presentation?: VisitPresentation<View> | ((record: Row) => VisitPresentation<View>));
[TO_NODE](): VisitTargetAddress;
[VALUE_FOR](record: Row, report: ReportDefect, options: {
ctx: RequestContext;
onDefect: DefectReporter;
requireLabel?: boolean;
}): VisitTargetValue | undefined;
}visitTo
declare function visitTo<View extends Linkable, Row = unknown>(view: View, ...rest: View['params'] extends readonly [
] ? [
args?: GetArgsFor<View['params']> | ((record: Row) => GetArgsFor<View['params']>),
presentation?: (VisitPresentation<View> & {
mode?: TargetMode;
}) | ((record: Row) => VisitPresentation<View>)
] : [
args: GetArgsFor<View['params']> | ((record: Row) => GetArgsFor<View['params']>),
presentation?: (VisitPresentation<View> & {
mode?: TargetMode;
}) | ((record: Row) => VisitPresentation<View>)
]): VisitTarget$1<View, Row>;warnOnDefect
declare const warnOnDefect: DefectReporter;widget
declare function widget(): WidgetBuilder;WidgetBuilder
declare class WidgetBuilder implements Nodeable<WidgetNode> {
setTitle(text: string, options?: {
icon?: string;
}): this;
setDescription(text: string): this;
setFootnote(text: string, options?: {
icon?: string;
tone?: Tone;
}): this;
setCaption(text: string): this;
setStat(stat: StatInput): this;
setChart(chart: Nodeable<Chart>): this;
onDefect(reporter: DefectReporter): this;
[TO_NODE](ctx?: RequestContext): WidgetNode;
}WidgetGroupBuilder
declare class WidgetGroupBuilder implements Resolvable<WidgetGroupNode> {
constructor(widgets: Producer<Widget>[]);
[RESOLVE](ctx: RequestContext<'view' | 'zone'>): Promise<WidgetGroupNode>;
[RESOLVE_FOR](ctx: RequestContext<'view' | 'zone'>, zoneId: string): Promise<ZoneNode | undefined>;
}widgets
declare const widgets: WidgetsFactory;WidgetsFactory
declare class WidgetsFactory extends Macroable {
group(widgets: Producer<Widget>[]): WidgetGroupBuilder;
}zone
declare function zone<Node extends Block>(name: string, resolver: ZoneResolver<Node>): ZoneBuilder<Node>;
declare function zone<Node extends Block, Atoms extends StateAtoms>(name: string, atoms: Atoms, resolver: ZoneResolver<Node, Atoms>): ZoneBuilder<Node, Atoms>;ZoneBuilder
declare class ZoneBuilder<Produces extends Block, Atoms extends StateAtoms = {}> implements Resolvable<ZoneNode> {
readonly name: string;
constructor(name: string, resolver: ZoneResolver<Produces, Atoms>, atoms?: Atoms);
get state(): ExtractStateBindings<Atoms>;
[RESOLVE](ctx: RequestContext<'view' | 'zone'>): Promise<ZoneNode>;
[RESOLVE_FOR](ctx: RequestContext<'view' | 'zone'>, zoneName: string): Promise<ZoneNode | undefined>;
}