@builder-builder/builder 0.0.28 → 0.0.29

package/dist/entities/option/select.d.ts

@@ -1,55 +1,28 @@
 import type { BuilderTags } from '../tags';
 import * as v from 'valibot';
-export type BuilderSelectConfigLabels<Values extends BuilderSelectConfigValues> = Partial<Record<Values[number], string>>;
-export type BuilderSelectConfigValues = readonly [string, ...ReadonlyArray<string>];
-export declare class BuilderSelectConfig<const Values extends BuilderSelectConfigValues = BuilderSelectConfigValues, const ValueSchema extends v.GenericSchema<string | null> = v.GenericSchema<string | null>> {
+export type BuilderValueOptions = readonly [string, ...ReadonlyArray<string>];
+export type BuilderValueOptionLabels<Options extends BuilderValueOptions> = Partial<Record<Options[number], string>>;
+export declare class BuilderSelectConfig<const Options extends BuilderValueOptions = BuilderValueOptions, const ValueSchema extends v.GenericSchema<string | null> = v.GenericSchema<string | null>> {
     #private;
     readonly value: v.InferOutput<ValueSchema>;
-    readonly type: "select";
-    readonly options: Values;
+    readonly type: "value";
+    readonly kind: "select";
+    readonly options: Options;
     readonly valueSchema: ValueSchema;
     readonly defaultValue: v.InferOutput<ValueSchema>;
     readonly isOptional: boolean;
-    readonly optionLabels: BuilderSelectConfigLabels<Values>;
+    readonly optionLabels: BuilderValueOptionLabels<Options>;
     readonly tags?: BuilderTags;
-    constructor(values: Values, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, optionLabels?: BuilderSelectConfigLabels<Values>, tags?: BuilderTags);
-    default(newDefault: v.InferOutput<ValueSchema>): BuilderSelectConfig<Values, ValueSchema>;
-    optional(): BuilderSelectConfig<Values, v.NullableSchema<ValueSchema, undefined>>;
-    labels(optionLabels: BuilderSelectConfigLabels<Values>): BuilderSelectConfig<Values, ValueSchema>;
-    tag(...tags: Array<string>): BuilderSelectConfig<Values, ValueSchema>;
+    constructor(options: Options, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, optionLabels?: BuilderValueOptionLabels<Options>, tags?: BuilderTags);
+    default(newDefault: v.InferOutput<ValueSchema>): BuilderSelectConfig<Options, ValueSchema>;
+    optional(): BuilderSelectConfig<Options, v.NullableSchema<ValueSchema, undefined>>;
+    labels(optionLabels: BuilderValueOptionLabels<Options>): BuilderSelectConfig<Options, ValueSchema>;
+    tag(...tags: Array<string>): BuilderSelectConfig<Options, ValueSchema>;
 }
-type SelectSchema<Values extends BuilderSelectConfigValues> = v.UnionSchema<{
-    [K in keyof Values]: v.LiteralSchema<Values[K], undefined>;
-}, undefined>;
-export declare function select<const Values extends BuilderSelectConfigValues>(values: Values): BuilderSelectConfig<Values, SelectSchema<Values>>;
+export declare function valueSelect<const Options extends BuilderValueOptions>(options: Options): BuilderSelectConfig<Options, SelectSchema<Options>>;
 export declare const BuilderSelectConfigSchema: v.InstanceSchema<typeof BuilderSelectConfig, undefined>;
-export declare const BuilderSelectConfigSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"select", undefined>;
-    readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
-    readonly defaultValue: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-    readonly isOptional: v.BooleanSchema<undefined>;
-    readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
-    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
-}, undefined>, v.ReadonlyAction<{
-    type: "select";
-    readonly options: readonly [string, ...string[]];
-    defaultValue: string | null;
-    isOptional: boolean;
-    optionLabels: {
-        [x: string]: string;
-    };
-    tags?: readonly string[] | undefined;
-}>]>;
-export type BuilderSelectConfigSerialised = v.InferOutput<typeof BuilderSelectConfigSerialisedSchema>;
 export declare function selectValueSchema(options: ReadonlyArray<string>, optional: boolean): v.GenericSchema<string | null>;
-export declare const validateSelect: (input: unknown, references?: import("..").BuilderReferences, issues?: import("../../errors").BuilderIssuesScope) => import("..").ValidationResult<{
-    readonly type: "select";
-    readonly options: readonly [string, ...string[]];
-    readonly defaultValue: string | null;
-    readonly isOptional: boolean;
-    readonly optionLabels: {
-        readonly [x: string]: string;
-    } & import("../../validate").BuilderValidatedBrand;
-    readonly tags?: readonly string[] | undefined;
-}>;
+type SelectSchema<Options extends BuilderValueOptions> = v.UnionSchema<{
+    [K in keyof Options]: v.LiteralSchema<Options[K], undefined>;
+}, undefined>;
 export {};

package/dist/entities/option/select.js

@@ -1,19 +1,16 @@
 import * as v from 'valibot';
-import { BooleanSchema, StringSchema } from '../../primitive.js';
-import { createEntityValidator } from '../kind.js';
-import { serialisable } from '../serialisable.js';
-import { BuilderTagsSchema } from '../tags.js';
 export class BuilderSelectConfig {
-    type = 'select';
+    type = 'value';
+    kind = 'select';
     options;
     valueSchema;
     defaultValue;
     isOptional;
     optionLabels;
     tags;
-    constructor(values, defaultValue, optional = false, optionLabels = {}, tags) {
-        this.options = values;
-        this.valueSchema = selectValueSchema(values, optional);
+    constructor(options, defaultValue, optional = false, optionLabels = {}, tags) {
+        this.options = options;
+        this.valueSchema = selectValueSchema(options, optional);
         this.defaultValue = defaultValue;
         this.isOptional = optional;
         this.optionLabels = optionLabels;
@@ -37,32 +34,12 @@ export class BuilderSelectConfig {
         return this.#next({ tags });
     }
 }
-export function select(values) {
-    const [defaultValue] = values;
-    return new BuilderSelectConfig(values, defaultValue, false);
+export function valueSelect(options) {
+    const [defaultValue] = options;
+    return new BuilderSelectConfig(options, defaultValue, false);
 }
 export const BuilderSelectConfigSchema = v.instance(BuilderSelectConfig);
-export const BuilderSelectConfigSerialisedSchema = serialisable(v.object({
-    type: v.literal('select'),
-    options: v.pipe(v.tupleWithRest([StringSchema], StringSchema), v.readonly()),
-    defaultValue: v.nullable(StringSchema),
-    isOptional: BooleanSchema,
-    optionLabels: v.record(StringSchema, StringSchema),
-    tags: v.optional(BuilderTagsSchema)
-}));
 export function selectValueSchema(options, optional) {
     const baseSchema = v.union(options.map((value) => v.literal(value)));
     return optional ? v.nullable(baseSchema) : baseSchema;
 }
-export const validateSelect = createEntityValidator('select', BuilderSelectConfigSerialisedSchema, (input, errors) => {
-    if (input.defaultValue != null && !input.options.includes(input.defaultValue)) {
-        errors.scope('defaultValue', () => errors.entityInvalidSelectDefault());
-    }
-    errors.scope('optionLabels', () => {
-        Object.keys(input.optionLabels).forEach((key) => {
-            if (!input.options.includes(key)) {
-                errors.scope(key, () => errors.entityInvalidSelectLabel());
-            }
-        });
-    });
-});

package/dist/entities/option/value.d.ts

@@ -0,0 +1,73 @@
+import type { BuilderPrimitive } from '../../primitive';
+import type { BuilderTags } from '../tags';
+import * as v from 'valibot';
+export declare const BuilderValueKindSchema: v.PicklistSchema<["string", "boolean", "number", "select"], undefined>;
+export type BuilderValueKind = v.InferOutput<typeof BuilderValueKindSchema>;
+export declare class BuilderValueConfig<const ValueSchema extends v.GenericSchema<BuilderPrimitive> = v.GenericSchema<BuilderPrimitive>> {
+    #private;
+    readonly value: v.InferOutput<ValueSchema>;
+    readonly type: "value";
+    readonly kind: 'string' | 'boolean' | 'number';
+    readonly valueSchema: ValueSchema;
+    readonly defaultValue: v.InferOutput<ValueSchema>;
+    readonly isOptional: boolean;
+    readonly tags?: BuilderTags;
+    constructor(kind: 'string' | 'boolean' | 'number', defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, tags?: BuilderTags);
+    default(newDefault: v.InferOutput<ValueSchema>): BuilderValueConfig<ValueSchema>;
+    optional(): BuilderValueConfig<v.NullableSchema<ValueSchema, undefined>>;
+    tag(...tags: Array<string>): BuilderValueConfig<ValueSchema>;
+}
+export declare function valueString(): BuilderValueConfig<v.StringSchema<undefined>>;
+export declare function valueBoolean(): BuilderValueConfig<v.BooleanSchema<undefined>>;
+export declare function valueNumber(): BuilderValueConfig<v.NumberSchema<undefined>>;
+export declare const BuilderValueConfigSchema: v.InstanceSchema<typeof BuilderValueConfig, undefined>;
+export declare const BuilderValueConfigSerialisedSchema: v.SchemaWithPipe<readonly [v.VariantSchema<"kind", [v.StrictObjectSchema<{
+    readonly kind: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+    readonly type: v.LiteralSchema<"value", undefined>;
+    readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+    readonly isOptional: v.BooleanSchema<undefined>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly kind: v.LiteralSchema<"select", undefined>;
+    readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
+    readonly optionLabels: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+    readonly type: v.LiteralSchema<"value", undefined>;
+    readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+    readonly isOptional: v.BooleanSchema<undefined>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
+}, undefined>], undefined>, v.ReadonlyAction<{
+    kind: "string" | "number" | "boolean";
+    type: "value";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+    tags?: readonly string[] | undefined;
+} | {
+    kind: "select";
+    readonly options: readonly [string, ...string[]];
+    optionLabels?: {
+        [x: string]: string;
+    } | undefined;
+    type: "value";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+    tags?: readonly string[] | undefined;
+}>]>;
+export type BuilderValueConfigSerialised = v.InferOutput<typeof BuilderValueConfigSerialisedSchema>;
+export declare function valueKindSchema(kind: 'string' | 'boolean' | 'number', optional: boolean): v.GenericSchema;
+export declare const validateValue: (input: unknown, references?: import("..").BuilderReferences, issues?: import("../../errors/errors").BuilderIssuesScope) => import("..").ValidationResult<{
+    readonly kind: "string" | "number" | "boolean";
+    readonly type: "value";
+    readonly defaultValue: string | number | boolean | null;
+    readonly isOptional: boolean;
+    readonly tags?: readonly string[] | undefined;
+} | {
+    readonly kind: "select";
+    readonly options: readonly [string, ...string[]];
+    readonly optionLabels?: ({
+        readonly [x: string]: string;
+    } & import("../../validate").BuilderValidatedBrand) | undefined;
+    readonly type: "value";
+    readonly defaultValue: string | number | boolean | null;
+    readonly isOptional: boolean;
+    readonly tags?: readonly string[] | undefined;
+}>;

package/dist/entities/option/value.js

@@ -0,0 +1,99 @@
+import * as v from 'valibot';
+import { check } from '../../errors/index.js';
+import { BooleanSchema, NumberSchema, StringSchema } from '../../primitive.js';
+import { createEntityValidator } from '../kind.js';
+import { serialisable } from '../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
+export const BuilderValueKindSchema = v.picklist(['string', 'boolean', 'number', 'select']);
+export class BuilderValueConfig {
+    type = 'value';
+    kind;
+    valueSchema;
+    defaultValue;
+    isOptional;
+    tags;
+    constructor(kind, defaultValue, optional, tags) {
+        this.kind = kind;
+        this.valueSchema = valueKindSchema(kind, optional || false);
+        this.defaultValue = defaultValue;
+        this.isOptional = optional || false;
+        this.tags = tags;
+    }
+    #next(patch) {
+        return new BuilderValueConfig(this.kind, 'defaultValue' in patch
+            ? patch.defaultValue
+            : this.defaultValue, patch.optional ?? this.isOptional, patch.tags ?? this.tags);
+    }
+    default(newDefault) {
+        return this.#next({ defaultValue: newDefault });
+    }
+    optional() {
+        return this.#next({ optional: true });
+    }
+    tag(...tags) {
+        return this.#next({ tags });
+    }
+}
+export function valueString() {
+    return new BuilderValueConfig('string', '');
+}
+export function valueBoolean() {
+    return new BuilderValueConfig('boolean', false);
+}
+export function valueNumber() {
+    return new BuilderValueConfig('number', 0);
+}
+export const BuilderValueConfigSchema = v.instance(BuilderValueConfig);
+const valueConfigSerialisedFields = {
+    type: v.literal('value'),
+    defaultValue: v.nullable(v.union([BooleanSchema, StringSchema, NumberSchema])),
+    isOptional: BooleanSchema,
+    tags: v.optional(BuilderTagsSchema)
+};
+// The wire shape mirrors the authoring split: `options`/`optionLabels` live only on a `select`, and
+// a `select` must carry `options`. So a hand-built object can't put options on a plain value, nor omit
+// them from a select — the same guarantee the two config classes give, enforced at validation too.
+export const BuilderValueConfigSerialisedSchema = serialisable(v.variant('kind', [
+    v.strictObject({
+        ...valueConfigSerialisedFields,
+        kind: v.picklist(['string', 'boolean', 'number'])
+    }),
+    v.strictObject({
+        ...valueConfigSerialisedFields,
+        kind: v.literal('select'),
+        options: v.pipe(v.tupleWithRest([StringSchema], StringSchema), v.readonly()),
+        optionLabels: v.optional(v.record(StringSchema, StringSchema))
+    })
+]));
+export function valueKindSchema(kind, optional) {
+    const kindSchemas = {
+        string: StringSchema,
+        boolean: BooleanSchema,
+        number: NumberSchema
+    };
+    const baseSchema = kindSchemas[kind];
+    return optional ? v.nullable(baseSchema) : baseSchema;
+}
+export const validateValue = createEntityValidator('value', BuilderValueConfigSerialisedSchema, (input, errors) => {
+    if (input.kind === 'select') {
+        const options = input.options;
+        if (input.defaultValue != null && !options.includes(`${input.defaultValue}`)) {
+            errors.scope('defaultValue', () => errors.entityInvalidSelectDefault());
+        }
+        errors.scope('optionLabels', () => {
+            Object.keys(input.optionLabels ?? {}).forEach((key) => {
+                if (!options.includes(key)) {
+                    errors.scope(key, () => errors.entityInvalidSelectLabel());
+                }
+            });
+        });
+        return;
+    }
+    if (input.defaultValue == null) {
+        return;
+    }
+    const valueSchema = valueKindSchema(input.kind, input.isOptional);
+    if (!check.is(valueSchema, input.defaultValue)) {
+        errors.scope('defaultValue', () => errors.entityInvalidValueDefault());
+    }
+});

package/dist/entities/references.d.ts

@@ -2,55 +2,58 @@ import * as v from 'valibot';
 export declare const BuilderReferenceSchema: v.ObjectSchema<{
     readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
     readonly serialised: v.GenericSchema<string | number | boolean | readonly (string | number)[] | readonly (readonly (string | number)[])[] | import("./index.js").BuilderSerialised | import("./index.js").BuilderModelSerialised | Readonly<{
-        type: "select";
-        readonly options: readonly [string, ...string[]];
-        defaultValue: string | null;
+        kind: "string" | "number" | "boolean";
+        type: "value";
+        defaultValue: string | number | boolean | null;
         isOptional: boolean;
-        optionLabels: {
-            [x: string]: string;
-        };
         tags?: readonly string[] | undefined;
     }> | Readonly<{
-        type: "toggle";
-        kind: "string" | "number" | "boolean";
+        kind: "select";
+        readonly options: readonly [string, ...string[]];
+        optionLabels?: {
+            [x: string]: string;
+        } | undefined;
+        type: "value";
         defaultValue: string | number | boolean | null;
         isOptional: boolean;
         tags?: readonly string[] | undefined;
-    }> | import("./when.js").BuilderMatchSelectMap<Readonly<{
+    }> | import("./condition.js").BuilderMatchSelectMap<Readonly<{
         type: "parameter";
         id: string;
         name: string;
-    }> | Readonly<Readonly<{
-        type: "select";
-        readonly options: readonly [string, ...string[]];
-        defaultValue: string | null;
+    }> | Readonly<{
+        kind: "string" | "number" | "boolean";
+        type: "value";
+        defaultValue: string | number | boolean | null;
         isOptional: boolean;
-        optionLabels: {
+        tags?: readonly string[] | undefined;
+    }> | Readonly<{
+        kind: "select";
+        readonly options: readonly [string, ...string[]];
+        optionLabels?: {
             [x: string]: string;
-        };
+        } | undefined;
+        type: "value";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
         tags?: readonly string[] | undefined;
-    }>> | Readonly<Readonly<{
-        type: "toggle";
+    }>> | import("./condition.js").BuilderConditionSerialised<Readonly<{
         kind: "string" | "number" | "boolean";
+        type: "value";
         defaultValue: string | number | boolean | null;
         isOptional: boolean;
         tags?: readonly string[] | undefined;
-    }>>> | import("./when.js").BuilderWhenSerialised<Readonly<Readonly<{
-        type: "select";
+    }> | Readonly<{
+        kind: "select";
         readonly options: readonly [string, ...string[]];
-        defaultValue: string | null;
-        isOptional: boolean;
-        optionLabels: {
+        optionLabels?: {
             [x: string]: string;
-        };
-        tags?: readonly string[] | undefined;
-    }>> | Readonly<Readonly<{
-        type: "toggle";
-        kind: "string" | "number" | "boolean";
+        } | undefined;
+        type: "value";
         defaultValue: string | number | boolean | null;
         isOptional: boolean;
         tags?: readonly string[] | undefined;
-    }>>> | Readonly<{
+    }>> | Readonly<{
         details: Readonly<{
             type: "parameter";
             id: string;
@@ -66,7 +69,7 @@ export declare const BuilderReferenceSchema: v.ObjectSchema<{
             tags?: readonly string[] | undefined;
         }>[];
         tags?: readonly string[] | undefined;
-    }> | import("./when.js").BuilderMatchSelectMap<Readonly<{
+    }> | import("./condition.js").BuilderMatchSelectMap<Readonly<{
         type: "parameter";
         id: string;
         name: string;
@@ -86,7 +89,7 @@ export declare const BuilderReferenceSchema: v.ObjectSchema<{
             tags?: readonly string[] | undefined;
         }>[];
         tags?: readonly string[] | undefined;
-    }>> | import("./when.js").BuilderWhenSerialised<Readonly<{
+    }>> | import("./condition.js").BuilderConditionSerialised<Readonly<{
         details: Readonly<{
             type: "parameter";
             id: string;
@@ -128,7 +131,7 @@ export declare const BuilderReferenceSchema: v.ObjectSchema<{
             id: string;
         }>;
         tags?: readonly string[] | undefined;
-    }> | import("./when.js").BuilderMatchSelectMap<Readonly<{
+    }> | import("./condition.js").BuilderMatchSelectMap<Readonly<{
         type: "parameter";
         id: string;
         name: string;
@@ -158,7 +161,7 @@ export declare const BuilderReferenceSchema: v.ObjectSchema<{
             id: string;
         }>;
         tags?: readonly string[] | undefined;
-    }>> | import("./when.js").BuilderWhenSerialised<Readonly<{
+    }>> | import("./condition.js").BuilderConditionSerialised<Readonly<{
         model: Readonly<{
             type: "parameter";
             id: string;
@@ -381,61 +384,81 @@ export declare const BuilderReferenceSchema: v.ObjectSchema<{
     }> | import("./index.js").BuilderUIItemSerialised)[] | import("./index.js").BuilderPricingSerialised | import("./index.js").BuilderRates | readonly Readonly<{
         name: string;
         kind: "option" | "component" | "collection";
+        payload?: Readonly<{
+            kind: "string" | "number" | "boolean";
+            type: "value";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+            tags?: readonly string[] | undefined;
+        }> | Readonly<{
+            kind: "select";
+            readonly options: readonly [string, ...string[]];
+            optionLabels?: {
+                [x: string]: string;
+            } | undefined;
+            type: "value";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+            tags?: readonly string[] | undefined;
+        }> | undefined;
     }>[]>;
 }, undefined>;
 export type BuilderReference = v.InferOutput<typeof BuilderReferenceSchema>;
 export declare const BuilderReferencesSchema: v.ArraySchema<v.ObjectSchema<{
     readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
     readonly serialised: v.GenericSchema<string | number | boolean | readonly (string | number)[] | readonly (readonly (string | number)[])[] | import("./index.js").BuilderSerialised | import("./index.js").BuilderModelSerialised | Readonly<{
-        type: "select";
-        readonly options: readonly [string, ...string[]];
-        defaultValue: string | null;
+        kind: "string" | "number" | "boolean";
+        type: "value";
+        defaultValue: string | number | boolean | null;
         isOptional: boolean;
-        optionLabels: {
-            [x: string]: string;
-        };
         tags?: readonly string[] | undefined;
     }> | Readonly<{
-        type: "toggle";
-        kind: "string" | "number" | "boolean";
+        kind: "select";
+        readonly options: readonly [string, ...string[]];
+        optionLabels?: {
+            [x: string]: string;
+        } | undefined;
+        type: "value";
         defaultValue: string | number | boolean | null;
         isOptional: boolean;
         tags?: readonly string[] | undefined;
-    }> | import("./when.js").BuilderMatchSelectMap<Readonly<{
+    }> | import("./condition.js").BuilderMatchSelectMap<Readonly<{
         type: "parameter";
         id: string;
         name: string;
-    }> | Readonly<Readonly<{
-        type: "select";
-        readonly options: readonly [string, ...string[]];
-        defaultValue: string | null;
+    }> | Readonly<{
+        kind: "string" | "number" | "boolean";
+        type: "value";
+        defaultValue: string | number | boolean | null;
         isOptional: boolean;
-        optionLabels: {
+        tags?: readonly string[] | undefined;
+    }> | Readonly<{
+        kind: "select";
+        readonly options: readonly [string, ...string[]];
+        optionLabels?: {
             [x: string]: string;
-        };
+        } | undefined;
+        type: "value";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
         tags?: readonly string[] | undefined;
-    }>> | Readonly<Readonly<{
-        type: "toggle";
+    }>> | import("./condition.js").BuilderConditionSerialised<Readonly<{
         kind: "string" | "number" | "boolean";
+        type: "value";
         defaultValue: string | number | boolean | null;
         isOptional: boolean;
         tags?: readonly string[] | undefined;
-    }>>> | import("./when.js").BuilderWhenSerialised<Readonly<Readonly<{
-        type: "select";
+    }> | Readonly<{
+        kind: "select";
         readonly options: readonly [string, ...string[]];
-        defaultValue: string | null;
-        isOptional: boolean;
-        optionLabels: {
+        optionLabels?: {
             [x: string]: string;
-        };
-        tags?: readonly string[] | undefined;
-    }>> | Readonly<Readonly<{
-        type: "toggle";
-        kind: "string" | "number" | "boolean";
+        } | undefined;
+        type: "value";
         defaultValue: string | number | boolean | null;
         isOptional: boolean;
         tags?: readonly string[] | undefined;
-    }>>> | Readonly<{
+    }>> | Readonly<{
         details: Readonly<{
             type: "parameter";
             id: string;
@@ -451,7 +474,7 @@ export declare const BuilderReferencesSchema: v.ArraySchema<v.ObjectSchema<{
             tags?: readonly string[] | undefined;
         }>[];
         tags?: readonly string[] | undefined;
-    }> | import("./when.js").BuilderMatchSelectMap<Readonly<{
+    }> | import("./condition.js").BuilderMatchSelectMap<Readonly<{
         type: "parameter";
         id: string;
         name: string;
@@ -471,7 +494,7 @@ export declare const BuilderReferencesSchema: v.ArraySchema<v.ObjectSchema<{
             tags?: readonly string[] | undefined;
         }>[];
         tags?: readonly string[] | undefined;
-    }>> | import("./when.js").BuilderWhenSerialised<Readonly<{
+    }>> | import("./condition.js").BuilderConditionSerialised<Readonly<{
         details: Readonly<{
             type: "parameter";
             id: string;
@@ -513,7 +536,7 @@ export declare const BuilderReferencesSchema: v.ArraySchema<v.ObjectSchema<{
             id: string;
         }>;
         tags?: readonly string[] | undefined;
-    }> | import("./when.js").BuilderMatchSelectMap<Readonly<{
+    }> | import("./condition.js").BuilderMatchSelectMap<Readonly<{
         type: "parameter";
         id: string;
         name: string;
@@ -543,7 +566,7 @@ export declare const BuilderReferencesSchema: v.ArraySchema<v.ObjectSchema<{
             id: string;
         }>;
         tags?: readonly string[] | undefined;
-    }>> | import("./when.js").BuilderWhenSerialised<Readonly<{
+    }>> | import("./condition.js").BuilderConditionSerialised<Readonly<{
         model: Readonly<{
             type: "parameter";
             id: string;
@@ -766,6 +789,23 @@ export declare const BuilderReferencesSchema: v.ArraySchema<v.ObjectSchema<{
     }> | import("./index.js").BuilderUIItemSerialised)[] | import("./index.js").BuilderPricingSerialised | import("./index.js").BuilderRates | readonly Readonly<{
         name: string;
         kind: "option" | "component" | "collection";
+        payload?: Readonly<{
+            kind: "string" | "number" | "boolean";
+            type: "value";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+            tags?: readonly string[] | undefined;
+        }> | Readonly<{
+            kind: "select";
+            readonly options: readonly [string, ...string[]];
+            optionLabels?: {
+                [x: string]: string;
+            } | undefined;
+            type: "value";
+            defaultValue: string | number | boolean | null;
+            isOptional: boolean;
+            tags?: readonly string[] | undefined;
+        }> | undefined;
     }>[]>;
 }, undefined>, undefined>;
 export type BuilderReferences = v.InferOutput<typeof BuilderReferencesSchema>;