---
title: SDK API
description: 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](/reference/app), [Resources](/reference/resources),
[Search state](/reference/state), or [Extensions](/advanced/extensions) for usage.

## ActionDefinition

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type ActionDialogOptions = ActionDialog & {
    submitLabel?: string;
};
```

## ActionTargetBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type ActionTargetPresentation = TargetPresentation & ActionPresentation & {
    skip?: boolean;
    disabled?: boolean;
};
```

## ActionTargetPresentationFor

```ts title="@backlit/sdk"
type ActionTargetPresentationFor<Row> = ActionTargetPresentation | ((record: Row) => ActionTargetPresentation);
```

## App

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare function assertLookupArgs(fields: Field[], has: (name: string) => boolean): void;
```

## BarListChartBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type BarListFieldsInput<Row> = {
    label: FieldBuilderContract<string, unknown, Row>;
    value: NumberFieldBuilder<string, Row>;
};
```

## BooleanFieldBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type BooleanFieldOptions<Row = unknown> = Prettify<ConditionableOptions<Partial<Omit<BooleanField, 'kind' | 'name' | 'link' | 'displayVariant'>> & {
    link?: LinkTarget<Linkable, Row>;
    displayVariant?: BooleanDisplayVariant;
}>>;
```

## callout

```ts title="@backlit/sdk"
declare function callout(text: string): CalloutBuilder;
```

## CalloutBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type CategoryBarFieldsInput<Row> = {
    values: readonly NumberFieldBuilder<string, Row>[];
};
```

## charts

```ts title="@backlit/sdk"
declare const charts: ChartsFactory;
```

## ChartsFactory

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare function completeTarget(node: () => TargetDefinition, value: TargetValue): Target;
```

## ConditionBuilder

```ts title="@backlit/sdk"
declare abstract class ConditionBuilder<Scope> {
    protected constructor();
    abstract [TO_NODE](ctx?: RequestContext): Condition;
}
```

## ConditionComposer

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare function datalist<Row extends Record<string, unknown>>(data: Row): DatalistBuilder<Row>;
```

## DatalistBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type DateFieldOptions<Row = unknown> = Prettify<ConditionableOptions<Partial<Omit<DateField, 'kind' | 'name' | 'link' | 'displayVariant'>> & {
    link?: LinkTarget<Linkable, Row>;
    displayVariant?: DateDisplayVariant;
}>>;
```

## DateRangeFilterBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare function defineApp<AreaResources extends Record<string, Record<string, ResourceLoader>>>(config: AppConfig<AreaResources>): App<AreaResources>;
```

## defineFilters

```ts title="@backlit/sdk"
declare function defineFilters<const Filters extends readonly FilterBuilderContract<string>[]>(filters: Filters): FilterBar<Filters>;
```

## definePaginator

```ts title="@backlit/sdk"
declare function definePaginator(options: {
    perPage: number;
    param?: string;
}): Paginator;
```

## defineResource

```ts title="@backlit/sdk"
declare function defineResource<Name extends string, const Fields extends readonly FieldBuilderContract<string, unknown, never>[]>(name: Name, fields: Fields): Resource<Name, Fields>;
```

## defineSorter

```ts title="@backlit/sdk"
declare function defineSorter<const Fields extends readonly FieldBuilderContract<string, unknown, never>[]>(options: {
    columns: Fields;
    param?: string;
}): Sorter<ExtractFieldNames<Fields>[]>;
```

## E_ACTION_FAILED

```ts title="@backlit/sdk"
declare const E_ACTION_FAILED: new (args: [
    action: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_ACTION_TARGET_ARGS_MISMATCH

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare const E_ACTION_VALIDATION_FAILED: new (args: [
    action: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_AGENT_PARAM_COLLISION

```ts title="@backlit/sdk"
declare const E_AGENT_PARAM_COLLISION: new (args: [
    address: string,
    key: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_AGENT_SCHEMA_WITHOUT_JSON

```ts title="@backlit/sdk"
declare const E_AGENT_SCHEMA_WITHOUT_JSON: new (args: [
    address: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_AGENT_TOOL_FAILED

```ts title="@backlit/sdk"
declare const E_AGENT_TOOL_FAILED: new (args: [
    tool: string,
    code: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_BAR_LIST_VALUE_NOT_NUMBER

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare const E_BAR_LIST_WITHOUT_LABEL: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_BAR_LIST_WITHOUT_VALUE

```ts title="@backlit/sdk"
declare const E_BAR_LIST_WITHOUT_VALUE: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_CATEGORY_BAR_VALUE_NOT_NUMBER

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare const E_CATEGORY_BAR_WITHOUT_VALUES: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_CONDITION_PATH_WITHOUT_FIELD

```ts title="@backlit/sdk"
declare const E_CONDITION_PATH_WITHOUT_FIELD: new (args: [
    path: string,
    found: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_DUPLICATE_ACTION

```ts title="@backlit/sdk"
declare const E_DUPLICATE_ACTION: new (args: [
    name: string,
    resource: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_DUPLICATE_FIELD

```ts title="@backlit/sdk"
declare const E_DUPLICATE_FIELD: new (args: [
    name: string,
    resource: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_DUPLICATE_FILTER

```ts title="@backlit/sdk"
declare const E_DUPLICATE_FILTER: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_DUPLICATE_LOOKUP

```ts title="@backlit/sdk"
declare const E_DUPLICATE_LOOKUP: new (args: [
    name: string,
    resource: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_DUPLICATE_RESOURCE

```ts title="@backlit/sdk"
declare const E_DUPLICATE_RESOURCE: new (args: [
    name: string,
    first: string,
    second: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_DUPLICATE_SORT_COLUMN

```ts title="@backlit/sdk"
declare const E_DUPLICATE_SORT_COLUMN: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_DUPLICATE_STATE_FIELD

```ts title="@backlit/sdk"
declare const E_DUPLICATE_STATE_FIELD: new (args: [
    name: string,
    keyword: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_DUPLICATE_VIEW

```ts title="@backlit/sdk"
declare const E_DUPLICATE_VIEW: new (args: [
    name: string,
    resource: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_DUPLICATE_ZONE

```ts title="@backlit/sdk"
declare const E_DUPLICATE_ZONE: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_EMPTY_SORT_COLUMNS

```ts title="@backlit/sdk"
declare const E_EMPTY_SORT_COLUMNS: new (args: [
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_FOOTER_LABEL_HAS_NO_ROOM

```ts title="@backlit/sdk"
declare const E_FOOTER_LABEL_HAS_NO_ROOM: new (args: [
    label: string,
    field: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_INVALID_FILTER_NAME

```ts title="@backlit/sdk"
declare const E_INVALID_FILTER_NAME: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_INVALID_NUMBER_RANGE

```ts title="@backlit/sdk"
declare const E_INVALID_NUMBER_RANGE: new (args: [
    name: string,
    reason: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_INVALID_SORT_COLUMN

```ts title="@backlit/sdk"
declare const E_INVALID_SORT_COLUMN: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_INVALID_STATE_FIELD_NAME

```ts title="@backlit/sdk"
declare const E_INVALID_STATE_FIELD_NAME: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_INVALID_ZONE_NAME

```ts title="@backlit/sdk"
declare const E_INVALID_ZONE_NAME: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_KEYWORD_CONFLICT

```ts title="@backlit/sdk"
declare const E_KEYWORD_CONFLICT: new (args: [
    keyword: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_LINE_CHART_SERIES_NOT_NUMBER

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare const E_LINE_CHART_WITHOUT_SERIES: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_LINE_CHART_WITHOUT_X

```ts title="@backlit/sdk"
declare const E_LINE_CHART_WITHOUT_X: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_LIST_POSITION_OVERFULL

```ts title="@backlit/sdk"
declare const E_LIST_POSITION_OVERFULL: new (args: [
    position: string,
    limit: number
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_LIST_WITHOUT_TITLE

```ts title="@backlit/sdk"
declare const E_LIST_WITHOUT_TITLE: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_LOOKUP_ARG_WITHOUT_FIELD

```ts title="@backlit/sdk"
declare const E_LOOKUP_ARG_WITHOUT_FIELD: new (args: [
    arg: string,
    input: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_MISSING_FIELD_REMAPPER

```ts title="@backlit/sdk"
declare const E_MISSING_FIELD_REMAPPER: new (args: [
    role: string,
    kind: string,
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_MISSING_PARAMS

```ts title="@backlit/sdk"
declare const E_MISSING_PARAMS: new (args: [
    resource: string,
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_MISSING_RELATION_DISPLAY

```ts title="@backlit/sdk"
declare const E_MISSING_RELATION_DISPLAY: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_MIXED_STATE_SCOPES

```ts title="@backlit/sdk"
declare const E_MIXED_STATE_SCOPES: new (args: [
    sorter: string,
    paginator: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_NESTED_FORM

```ts title="@backlit/sdk"
declare const E_NESTED_FORM: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_NO_RESPONSE

```ts title="@backlit/sdk"
declare const E_NO_RESPONSE: new (args: [
    address: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_SEGMENTS_MANY

```ts title="@backlit/sdk"
declare const E_SEGMENTS_MANY: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_SEGMENTS_NOT_SELECT

```ts title="@backlit/sdk"
declare const E_SEGMENTS_NOT_SELECT: new (args: [
    name: string,
    kind: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_SEGMENTS_ONE_FILTER

```ts title="@backlit/sdk"
declare const E_SEGMENTS_ONE_FILTER: new (args: [
    count: number
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_SEGMENTS_RESERVED_ALL

```ts title="@backlit/sdk"
declare const E_SEGMENTS_RESERVED_ALL: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_SPARK_AREA_CHART_SERIES_NOT_NUMBER

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare const E_SPARK_AREA_CHART_WITHOUT_SERIES: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_SPARK_AREA_CHART_WITHOUT_X

```ts title="@backlit/sdk"
declare const E_SPARK_AREA_CHART_WITHOUT_X: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_STAT_CURRENCY_WITHOUT_CODE

```ts title="@backlit/sdk"
declare const E_STAT_CURRENCY_WITHOUT_CODE: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_STAT_FIELD_NOT_NUMBER

```ts title="@backlit/sdk"
declare const E_STAT_FIELD_NOT_NUMBER: new (args: [
    name: string,
    kind: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_TABS_DUPLICATE_TAB

```ts title="@backlit/sdk"
declare const E_TABS_DUPLICATE_TAB: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_TABS_EMPTY

```ts title="@backlit/sdk"
declare const E_TABS_EMPTY: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_TABS_UNKNOWN_INITIAL

```ts title="@backlit/sdk"
declare const E_TABS_UNKNOWN_INITIAL: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_TARGET_ARG_UNDEFINED

```ts title="@backlit/sdk"
declare const E_TARGET_ARG_UNDEFINED: new (args: [
    resource: string,
    target: string,
    position: number
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_TIMELINE_POSITION_OVERFULL

```ts title="@backlit/sdk"
declare const E_TIMELINE_POSITION_OVERFULL: new (args: [
    position: string,
    limit: number
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_TIMELINE_WITHOUT_TIME

```ts title="@backlit/sdk"
declare const E_TIMELINE_WITHOUT_TIME: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_TIMELINE_WITHOUT_TITLE

```ts title="@backlit/sdk"
declare const E_TIMELINE_WITHOUT_TITLE: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_UNKNOWN_FIELD

```ts title="@backlit/sdk"
declare const E_UNKNOWN_FIELD: new (args: [
    name: string,
    resource: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_UNKNOWN_FIELD_REMAPPER_ROLE

```ts title="@backlit/sdk"
declare const E_UNKNOWN_FIELD_REMAPPER_ROLE: new (args: [
    role: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_UNKNOWN_FILTER

```ts title="@backlit/sdk"
declare const E_UNKNOWN_FILTER: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_UNKNOWN_FOOTER_FIELD

```ts title="@backlit/sdk"
declare const E_UNKNOWN_FOOTER_FIELD: new (args: [
    label: string,
    field: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_UNKNOWN_NAVIGATION_RESOURCE

```ts title="@backlit/sdk"
declare const E_UNKNOWN_NAVIGATION_RESOURCE: new (args: [
    label: string,
    resource: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_UNKNOWN_RESOURCE

```ts title="@backlit/sdk"
declare const E_UNKNOWN_RESOURCE: new (args: [
    name: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_VIEW_TARGET_ARGS_MISMATCH

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare const E_VIEW_TARGET_FILTER_UNKNOWN: new (args: [
    resource: string,
    view: string,
    filter: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_WIDGET_EMPTY

```ts title="@backlit/sdk"
declare const E_WIDGET_EMPTY: new (args?: any, options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## E_ZONE_STATE_COLLISION

```ts title="@backlit/sdk"
declare const E_ZONE_STATE_COLLISION: new (args: [
    name: string,
    keyword: string
], options?: ErrorOptions) => import("@poppinss/exception").Exception;
```

## EnumFieldBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare class ErrorResponseBuilder extends BaseResponseBuilder implements Respondable<ErrorResponse> {
    constructor(status: HttpErrorStatusCode, code: string);
    setErrors(errors: ValidationError[]): this;
    [TO_RESPONSE](): ErrorResponse;
}
```

## ExtensionManager

```ts title="@backlit/sdk"
declare class ExtensionManager {
    install(extension: BacklitExtension): void;
    list(): ManifestExtension[];
}
```

## ExtractNumberFormat

```ts title="@backlit/sdk"
type ExtractNumberFormat<Options> = Options extends {
    format: infer Format extends NumberFormat;
} ? Format : undefined;
```

## FieldRemappers

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare const fields: FieldsFactory;
```

## FieldsFactory

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare const filters: FiltersFactory;
```

## FiltersFactory

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare function form<Schema extends StandardSchemaV1<Record<string, unknown>, unknown>>(action: ActionDefinition<string, string, Schema, ParamNames>): FormBuilder<StandardSchemaV1.InferInput<Schema>>;
```

## FormBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type GetRefFieldCardinalityFor<Options, Fallback extends Cardinality = 'one'> = Options extends {
    cardinality: infer Card extends Cardinality;
} ? Card : Fallback;
```

## GetRefFieldValueFor

```ts title="@backlit/sdk"
type GetRefFieldValueFor<Options, Fallback = never> = Options extends {
    inputVariant: SearchInputVariant<infer Value>;
} ? Value : Options extends {
    inputVariant: OptionsInputVariant<infer Value>;
} ? Value : Fallback;
```

## group

```ts title="@backlit/sdk"
declare function group(content: Producer[]): GroupBuilder;
```

## GroupBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type GroupFieldOptions<Row = unknown> = Prettify<ConditionableOptions<Partial<Omit<GroupField, 'kind' | 'name' | 'fields' | 'link'>>> & {
    link?: LinkTarget<Linkable, Row>;
}>;
```

## HasFieldBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type LineChartFieldsInput<Row> = {
    x: FieldBuilderContract<string, unknown, Row>;
    series: NumberFieldBuilder<string, Row> | readonly NumberFieldBuilder<string, Row>[];
};
```

## LinkTarget

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare class LookupTarget implements Nodeable<LookupTarget$1> {
    constructor(source: () => LookupDefinition<string, string, readonly FieldBuilderContract<string>[], ParamNames>, args: GetLookupArgsFor<ParamNames>);
    [TO_NODE](): LookupTarget$1;
}
```

## lookupVia

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type NumberFieldFormatOptions = ({
    format?: undefined;
    decimals?: NumberDecimals;
} & {
    [Key in Exclude<FormatOptionKeys, 'decimals'>]?: never;
}) | {
    [Format in NumberFormat]: ExclusiveFormatOptions<Format>;
}[NumberFormat];
```

## NumberFieldOptions

```ts title="@backlit/sdk"
type NumberFieldOptions<Row = unknown> = Prettify<NumberFieldCommonOptions<Row> & NumberFieldFormatOptions>;
```

## NumberPerRecordOptions

```ts title="@backlit/sdk"
type NumberPerRecordOptions<Format> = Format extends NumberFormat ? Partial<Omit<ExclusiveFormatOptions<Format>, 'format' | 'decimals'>> & {
    decimals?: never;
} : {
    [Key in FormatOptionKeys]?: never;
};
```

## NumberRangeFilterBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type NumberRangeOptions = {
    min: number;
    max: number;
    step?: number;
};
```

## OptionsInputVariant

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare function panel(content: Producer[]): PanelBuilder;
```

## PanelBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare function parseSearchParams(queryString: string): SearchParams;
```

## PeriodFilterBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type RecordListFieldsInput<Row> = {
    leading?: PositionInput$3<Row>;
    title: PositionInput$3<Row>;
    description?: PositionInput$3<Row>;
    meta?: PositionInput$3<Row>;
    trailing?: PositionInput$3<Row>;
};
```

## RecordTimelineBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare class RedirectResponseBuilder extends BaseResponseBuilder implements Respondable<RedirectResponse> {
    constructor(resource: string, view: string, args?: readonly (string | number)[]);
    [TO_RESPONSE](): RedirectResponse;
}
```

## Ref

```ts title="@backlit/sdk"
declare class Ref<Scope, Value> {
    readonly path: string;
    constructor(path: string);
}
```

## RefFieldBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare class RefreshResponseBuilder extends BaseResponseBuilder implements Respondable<RefreshResponse> {
    constructor(zones: string[]);
    [TO_RESPONSE](): RefreshResponse;
}
```

## remappers

```ts title="@backlit/sdk"
declare const remappers: FieldRemappers;
```

## RequestContext

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare function section(title?: string): SectionBuilder;
```

## SectionBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type SegmentableFilters = readonly [
    FilterBuilderContract<string, string>
];
```

## segments

```ts title="@backlit/sdk"
declare function segments<const Filters extends SegmentableFilters>(binding: StateBinding<FilterBar<Filters>>, options?: SegmentsOptions<ExtractFilterValue<Filters[0]> & string>): SegmentsBuilder<Filters>;
```

## SegmentsBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type SegmentsOptions<Value extends string> = {
    counts?: Partial<Record<Value | 'all', number>>;
    tones?: Partial<Record<Value | 'all', Tone>>;
    labels?: Partial<Record<Value | 'all', string>>;
};
```

## SelectFilterBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type SparkAreaChartFieldsInput<Row> = {
    x: FieldBuilderContract<string, unknown, Row>;
    series: NumberFieldBuilder<string, Row> | readonly NumberFieldBuilder<string, Row>[];
};
```

## StatInput

```ts title="@backlit/sdk"
type StatInput = {
    value: number;
    field: NumberFieldBuilder<string, never>;
    prior?: number;
    delta?: Stat['delta'];
    tone?: Tone;
    description?: string;
    descriptionIcon?: string;
};
```

## stringifySearchParams

```ts title="@backlit/sdk"
declare function stringifySearchParams(search: SearchParams): string;
```

## submitTo

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare class SuccessResponseBuilder extends BaseResponseBuilder implements Respondable<ValidActionResponse> {
    [TO_RESPONSE](): ValidActionResponse;
}
```

## tab

```ts title="@backlit/sdk"
declare function tab(name: string, title: string): TabBuilder;
```

## TabBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare function table<Row extends Record<string, unknown>>(data: Row[]): TableBuilder<Row>;
```

## TableBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare function tabs(items: TabBuilder[]): TabsBuilder;
```

## TabsBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
type TextFieldOptions<Row = unknown> = Prettify<ConditionableOptions<Partial<Omit<TextField, 'kind' | 'name' | 'link' | 'displayVariant' | 'inputVariant'>> & {
    link?: LinkTarget<Linkable, Row>;
    displayVariant?: TextDisplayVariant;
    inputVariant?: 'input' | 'textarea';
}>>;
```

## TextFilterBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare function toActionNodes(targets: VisitTarget<Linkable, never>[], ctx: RequestContext): VisitTarget$1[];
declare function toActionNodes(targets: TargetBuilderContract<never>[], ctx: RequestContext): Target[];
```

## toAgentInputSchema

```ts title="@backlit/sdk"
declare function toAgentInputSchema(keys: {
    name: string;
    description: string;
}[], payload?: Record<string, unknown>): Record<string, unknown>;
```

## toAgentParamKeys

```ts title="@backlit/sdk"
declare function toAgentParamKeys(params: readonly string[]): {
    name: string;
    description: string;
}[];
```

## toFiltersNode

```ts title="@backlit/sdk"
declare function toFiltersNode(binding: StateBinding<FilterBar>, ctx: RequestContext<'view' | 'zone'>): FiltersNode;
```

## ToggleFilterBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare function toSelectedOption(value: unknown, read: {
    value: string;
    label: string;
}, report: ReportDefect): unknown;
```

## toStateAddress

```ts title="@backlit/sdk"
declare function toStateAddress(binding: StateBinding<StateAtomContract>, ctx: RequestContext): {
    keyword: string;
    definesResult: boolean;
    dependsOnResult: boolean;
    zone?: string;
    args?: string[];
    resource: string;
    view: string;
};
```

## toZoneNode

```ts title="@backlit/sdk"
declare function toZoneNode(nodes: Producer[], ctx: RequestContext<'view' | 'zone'>, zoneId: string): Promise<ZoneNode | undefined>;
```

## view

```ts title="@backlit/sdk"
declare function view<Atoms extends StateAtoms = {}>(name: string, atoms?: Atoms): ViewBuilder<Atoms>;
```

## ViewBreadcrumbOptions

```ts title="@backlit/sdk"
type ViewBreadcrumbOptions<Row extends Record<string, unknown>> = {
    ancestors: VisitTarget$1<Linkable, never>[];
    fields?: FieldBuilderContract<string, unknown, Row>[];
};
```

## ViewBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare const warnOnDefect: DefectReporter;
```

## widget

```ts title="@backlit/sdk"
declare function widget(): WidgetBuilder;
```

## WidgetBuilder

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
declare const widgets: WidgetsFactory;
```

## WidgetsFactory

```ts title="@backlit/sdk"
declare class WidgetsFactory extends Macroable {
    group(widgets: Producer<Widget>[]): WidgetGroupBuilder;
}
```

## zone

```ts title="@backlit/sdk"
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

```ts title="@backlit/sdk"
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>;
}
```