@builder-builder/builder 0.0.27 → 0.0.29

package/dist/entities/serialise.d.ts

@@ -9,122 +9,124 @@ export declare const entitiesMap: {
         readonly runtime: v.InstanceSchema<typeof import(".").BuilderModel, undefined>;
         readonly serialised: v.GenericSchema<import(".").BuilderModelSerialised>;
     };
-    readonly select: {
-        readonly runtime: v.InstanceSchema<typeof import(".").BuilderSelectConfig, undefined>;
-        readonly serialised: 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 value: {
+        readonly runtime: v.UnionSchema<[v.InstanceSchema<typeof import(".").BuilderValueConfig, undefined>, v.InstanceSchema<typeof import(".").BuilderSelectConfig, undefined>], undefined>;
+        readonly serialised: 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 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;
-        }>]>;
-    };
-    readonly toggle: {
-        readonly runtime: v.InstanceSchema<typeof import(".").BuilderToggleConfig, undefined>;
-        readonly serialised: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-            readonly type: v.LiteralSchema<"toggle", undefined>;
-            readonly valueType: v.PicklistSchema<["string", "boolean", "number"], 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>, v.ReadonlyAction<{
-            type: "toggle";
-            valueType: "string" | "number" | "boolean";
+        }, 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;
         }>]>;
     };
     readonly optionSelectMap: {
-        readonly runtime: v.GenericSchema<import("./when").BuilderMatchSelectMap<Readonly<{
+        readonly runtime: v.GenericSchema<import("./condition").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: {
-                [x: string]: string;
-            };
             tags?: readonly string[] | undefined;
-        }>> | Readonly<Readonly<{
-            type: "toggle";
-            valueType: "string" | "number" | "boolean";
+        }> | 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 serialised: v.GenericSchema<import("./when").BuilderMatchSelectMap<Readonly<{
+        }>>>;
+        readonly serialised: v.GenericSchema<import("./condition").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: {
-                [x: string]: string;
-            };
             tags?: readonly string[] | undefined;
-        }>> | Readonly<Readonly<{
-            type: "toggle";
-            valueType: "string" | "number" | "boolean";
+        }> | 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 optionWhen: {
-        readonly runtime: v.GenericSchema<import("./when").BuilderWhenSerialised<Readonly<Readonly<{
-            type: "select";
-            readonly options: readonly [string, ...string[]];
-            defaultValue: string | null;
+    readonly optionCondition: {
+        readonly runtime: v.GenericSchema<import("./condition").BuilderConditionSerialised<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";
-            valueType: "string" | "number" | "boolean";
+        }>>>;
+        readonly serialised: v.GenericSchema<import("./condition").BuilderConditionSerialised<Readonly<{
+            kind: "string" | "number" | "boolean";
+            type: "value";
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
             tags?: readonly string[] | undefined;
-        }>>>>;
-        readonly serialised: v.GenericSchema<import("./when").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";
-            valueType: "string" | "number" | "boolean";
+            } | undefined;
+            type: "value";
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
             tags?: readonly string[] | undefined;
-        }>>>>;
+        }>>>;
     };
     readonly componentConfig: {
         readonly runtime: v.InstanceSchema<typeof import(".").BuilderComponentConfig, undefined>;
         readonly serialised: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-            readonly fields: v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+            readonly details: v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
                 readonly type: v.LiteralSchema<"parameter", undefined>;
                 readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
                 readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
@@ -139,27 +141,27 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-                readonly type: v.LiteralSchema<"component-field", undefined>;
+                readonly type: v.LiteralSchema<"component-detail", undefined>;
                 readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
-                readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+                readonly kind: v.PicklistSchema<["string", "boolean", "number", "price", "image"], 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.ReadonlyAction<{
-                type: "component-field";
+                type: "component-detail";
                 name: string;
-                valueType: "string" | "number" | "boolean";
+                kind: "string" | "number" | "boolean" | "price" | "image";
                 isOptional: boolean;
                 tags?: readonly string[] | undefined;
             }>]>, undefined>, v.ReadonlyAction<Readonly<{
-                type: "component-field";
+                type: "component-detail";
                 name: string;
-                valueType: "string" | "number" | "boolean";
+                kind: "string" | "number" | "boolean" | "price" | "image";
                 isOptional: boolean;
                 tags?: readonly string[] | 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<{
-            fields: Readonly<{
+            details: Readonly<{
                 type: "parameter";
                 id: string;
                 name: string;
@@ -167,9 +169,9 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }> | readonly Readonly<{
-                type: "component-field";
+                type: "component-detail";
                 name: string;
-                valueType: "string" | "number" | "boolean";
+                kind: "string" | "number" | "boolean" | "price" | "image";
                 isOptional: boolean;
                 tags?: readonly string[] | undefined;
             }>[];
@@ -177,12 +179,12 @@ export declare const entitiesMap: {
         }>]>;
     };
     readonly componentSelectMap: {
-        readonly runtime: v.GenericSchema<import("./when").BuilderMatchSelectMap<Readonly<{
+        readonly runtime: v.GenericSchema<import("./condition").BuilderMatchSelectMap<Readonly<{
             type: "parameter";
             id: string;
             name: string;
         }> | Readonly<{
-            fields: Readonly<{
+            details: Readonly<{
                 type: "parameter";
                 id: string;
                 name: string;
@@ -190,20 +192,20 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }> | readonly Readonly<{
-                type: "component-field";
+                type: "component-detail";
                 name: string;
-                valueType: "string" | "number" | "boolean";
+                kind: "string" | "number" | "boolean" | "price" | "image";
                 isOptional: boolean;
                 tags?: readonly string[] | undefined;
             }>[];
             tags?: readonly string[] | undefined;
         }>>>;
-        readonly serialised: v.GenericSchema<import("./when").BuilderMatchSelectMap<Readonly<{
+        readonly serialised: v.GenericSchema<import("./condition").BuilderMatchSelectMap<Readonly<{
             type: "parameter";
             id: string;
             name: string;
         }> | Readonly<{
-            fields: Readonly<{
+            details: Readonly<{
                 type: "parameter";
                 id: string;
                 name: string;
@@ -211,18 +213,18 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }> | readonly Readonly<{
-                type: "component-field";
+                type: "component-detail";
                 name: string;
-                valueType: "string" | "number" | "boolean";
+                kind: "string" | "number" | "boolean" | "price" | "image";
                 isOptional: boolean;
                 tags?: readonly string[] | undefined;
             }>[];
             tags?: readonly string[] | undefined;
         }>>>;
     };
-    readonly componentWhen: {
-        readonly runtime: v.GenericSchema<import("./when").BuilderWhenSerialised<Readonly<{
-            fields: Readonly<{
+    readonly componentCondition: {
+        readonly runtime: v.GenericSchema<import("./condition").BuilderConditionSerialised<Readonly<{
+            details: Readonly<{
                 type: "parameter";
                 id: string;
                 name: string;
@@ -230,16 +232,16 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }> | readonly Readonly<{
-                type: "component-field";
+                type: "component-detail";
                 name: string;
-                valueType: "string" | "number" | "boolean";
+                kind: "string" | "number" | "boolean" | "price" | "image";
                 isOptional: boolean;
                 tags?: readonly string[] | undefined;
             }>[];
             tags?: readonly string[] | undefined;
         }>>>;
-        readonly serialised: v.GenericSchema<import("./when").BuilderWhenSerialised<Readonly<{
-            fields: Readonly<{
+        readonly serialised: v.GenericSchema<import("./condition").BuilderConditionSerialised<Readonly<{
+            details: Readonly<{
                 type: "parameter";
                 id: string;
                 name: string;
@@ -247,9 +249,9 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }> | readonly Readonly<{
-                type: "component-field";
+                type: "component-detail";
                 name: string;
-                valueType: "string" | "number" | "boolean";
+                kind: "string" | "number" | "boolean" | "price" | "image";
                 isOptional: boolean;
                 tags?: readonly string[] | undefined;
             }>[];
@@ -334,7 +336,7 @@ export declare const entitiesMap: {
         }>]>;
     };
     readonly collectionSelectMap: {
-        readonly runtime: v.GenericSchema<import("./when").BuilderMatchSelectMap<Readonly<{
+        readonly runtime: v.GenericSchema<import("./condition").BuilderMatchSelectMap<Readonly<{
             type: "parameter";
             id: string;
             name: string;
@@ -365,7 +367,7 @@ export declare const entitiesMap: {
             }>;
             tags?: readonly string[] | undefined;
         }>>>;
-        readonly serialised: v.GenericSchema<import("./when").BuilderMatchSelectMap<Readonly<{
+        readonly serialised: v.GenericSchema<import("./condition").BuilderMatchSelectMap<Readonly<{
             type: "parameter";
             id: string;
             name: string;
@@ -397,8 +399,8 @@ export declare const entitiesMap: {
             tags?: readonly string[] | undefined;
         }>>>;
     };
-    readonly collectionWhen: {
-        readonly runtime: v.GenericSchema<import("./when").BuilderWhenSerialised<Readonly<{
+    readonly collectionCondition: {
+        readonly runtime: v.GenericSchema<import("./condition").BuilderConditionSerialised<Readonly<{
             model: Readonly<{
                 type: "parameter";
                 id: string;
@@ -425,7 +427,7 @@ export declare const entitiesMap: {
             }>;
             tags?: readonly string[] | undefined;
         }>>>;
-        readonly serialised: v.GenericSchema<import("./when").BuilderWhenSerialised<Readonly<{
+        readonly serialised: v.GenericSchema<import("./condition").BuilderConditionSerialised<Readonly<{
             model: Readonly<{
                 type: "parameter";
                 id: string;
@@ -1393,12 +1395,77 @@ export declare const entitiesMap: {
         readonly serialised: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
             readonly name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
             readonly kind: v.PicklistSchema<["option", "component", "collection"], undefined>;
+            readonly payload: v.OptionalSchema<v.LazySchema<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;
+            }>]>>, undefined>;
         }, undefined>, v.ReadonlyAction<{
             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>, v.ReadonlyAction<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;
         }>[]>]>;
     };
     readonly paths: {
@@ -1422,16 +1489,15 @@ export declare const entitiesMap: {
         readonly serialised: v.BooleanSchema<undefined>;
     };
 };
-export declare const validateNumber: (input: unknown, references?: import("./references").BuilderReferences, errors?: import("../errors/errors").BuilderErrorsScope) => import("./validated").ValidationResult<number>;
-export declare const validateString: (input: unknown, references?: import("./references").BuilderReferences, errors?: import("../errors/errors").BuilderErrorsScope) => import("./validated").ValidationResult<string>;
-export declare const validateBoolean: (input: unknown, references?: import("./references").BuilderReferences, errors?: import("../errors/errors").BuilderErrorsScope) => import("./validated").ValidationResult<boolean>;
+export declare const validateNumber: (input: unknown, references?: import("./references").BuilderReferences, issues?: import("../errors/errors").BuilderIssuesScope) => import("./validated").ValidationResult<number>;
+export declare const validateString: (input: unknown, references?: import("./references").BuilderReferences, issues?: import("../errors/errors").BuilderIssuesScope) => import("./validated").ValidationResult<string>;
+export declare const validateBoolean: (input: unknown, references?: import("./references").BuilderReferences, issues?: import("../errors/errors").BuilderIssuesScope) => import("./validated").ValidationResult<boolean>;
 export type EntitiesMap = typeof entitiesMap;
 export type EntitiesSerialisedSchemas = EntitiesMap[BuilderEntityKind]['serialised'];
-export declare const BuilderEntityKindSchema: v.PicklistSchema<readonly ["builder", "model", "select", "toggle", "optionSelectMap", "optionWhen", "componentConfig", "componentSelectMap", "componentWhen", "collectionConfig", "collectionSelectMap", "collectionWhen", "ui", "uiDescribe", "uiItems", "uiPage", "uiPages", "uiInput", "pricing", "pricingRates", "expectations", "paths", "path", "number", "string", "boolean"], undefined>;
+export declare const BuilderEntityKindSchema: v.PicklistSchema<readonly ["builder", "model", "value", "optionSelectMap", "optionCondition", "componentConfig", "componentSelectMap", "componentCondition", "collectionConfig", "collectionSelectMap", "collectionCondition", "ui", "uiDescribe", "uiItems", "uiPage", "uiPages", "uiInput", "pricing", "pricingRates", "expectations", "paths", "path", "number", "string", "boolean"], undefined>;
 export declare const BuilderEntitySerialisedSchema: v.GenericSchema<{ [Kind in BuilderEntityKind]: v.InferOutput<EntitiesMap[Kind]["serialised"]>; }[BuilderEntityKind]>;
 type SerialiseMap = {
     readonly [EntityKind in keyof EntitiesMap]: (input: v.InferOutput<EntitiesMap[EntityKind]['runtime']>) => v.InferOutput<EntitiesMap[EntityKind]['serialised']>;
 };
 export declare const serialise: SerialiseMap;
-export declare function serialiseValue(value: unknown): unknown;
 export {};

package/dist/entities/serialise.js

@@ -3,27 +3,29 @@ import { check } from '../errors/index.js';
 import { BooleanSchema, NumberSchema, StringSchema } from '../primitive.js';
 import { BuilderParameterSchema, BuilderRefSchema, isParamable } from '../references.js';
 import { BuilderSchema, BuilderSerialisedSchema } from './builder/index.js';
-import { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionWhenSerialisedSchema } from './collection/index.js';
-import { BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentWhenSerialisedSchema } from './component/index.js';
+import { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionConditionSerialisedSchema } from './collection/index.js';
+import { BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentDetailSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentConditionSerialisedSchema } from './component/index.js';
 import { BuilderExpectationSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema } from './expectation.js';
 import { builderEntityKinds, createEntityValidator } from './kind.js';
 import { BuilderModelSchema, BuilderModelSerialisedSchema } from './model/index.js';
-import { BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema } from './option/index.js';
+import { BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionConditionSerialisedSchema, BuilderSelectConfigSchema, BuilderValueConfigSchema, BuilderValueConfigSerialisedSchema } from './option/index.js';
 import { BuilderPathSchema, BuilderPathsSchema } from './paths.js';
 import { BuilderPricingSchema, BuilderPricingSerialisedSchema, BuilderRatesSchema } from './pricing/index.js';
 import { BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIInputSchema, BuilderUIInputSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema } from './ui/index.js';
 export const entitiesMap = {
     builder: { runtime: BuilderSchema, serialised: BuilderSerialisedSchema },
     model: { runtime: BuilderModelSchema, serialised: BuilderModelSerialisedSchema },
-    select: { runtime: BuilderSelectConfigSchema, serialised: BuilderSelectConfigSerialisedSchema },
-    toggle: { runtime: BuilderToggleConfigSchema, serialised: BuilderToggleConfigSerialisedSchema },
+    value: {
+        runtime: v.union([BuilderValueConfigSchema, BuilderSelectConfigSchema]),
+        serialised: BuilderValueConfigSerialisedSchema
+    },
     optionSelectMap: {
         runtime: BuilderOptionSelectMapSerialisedSchema,
         serialised: BuilderOptionSelectMapSerialisedSchema
     },
-    optionWhen: {
-        runtime: BuilderOptionWhenSerialisedSchema,
-        serialised: BuilderOptionWhenSerialisedSchema
+    optionCondition: {
+        runtime: BuilderOptionConditionSerialisedSchema,
+        serialised: BuilderOptionConditionSerialisedSchema
     },
     componentConfig: {
         runtime: BuilderComponentConfigSchema,
@@ -33,9 +35,9 @@ export const entitiesMap = {
         runtime: BuilderComponentSelectMapSerialisedSchema,
         serialised: BuilderComponentSelectMapSerialisedSchema
     },
-    componentWhen: {
-        runtime: BuilderComponentWhenSerialisedSchema,
-        serialised: BuilderComponentWhenSerialisedSchema
+    componentCondition: {
+        runtime: BuilderComponentConditionSerialisedSchema,
+        serialised: BuilderComponentConditionSerialisedSchema
     },
     collectionConfig: {
         runtime: BuilderCollectionConfigSchema,
@@ -45,9 +47,9 @@ export const entitiesMap = {
         runtime: BuilderCollectionSelectMapSerialisedSchema,
         serialised: BuilderCollectionSelectMapSerialisedSchema
     },
-    collectionWhen: {
-        runtime: BuilderCollectionWhenSerialisedSchema,
-        serialised: BuilderCollectionWhenSerialisedSchema
+    collectionCondition: {
+        runtime: BuilderCollectionConditionSerialisedSchema,
+        serialised: BuilderCollectionConditionSerialisedSchema
     },
     ui: { runtime: BuilderUISchema, serialised: BuilderUISerialisedSchema },
     uiDescribe: { runtime: BuilderUIDescribeSchema, serialised: BuilderUIDescribeSerialisedSchema },
@@ -73,7 +75,7 @@ export const validateBoolean = createEntityValidator('boolean', entitiesMap.bool
 export const BuilderEntityKindSchema = v.picklist(builderEntityKinds);
 export const BuilderEntitySerialisedSchema = v.union(builderEntityKinds.map((kind) => entitiesMap[kind].serialised));
 export const serialise = Object.fromEntries(builderEntityKinds.map((kind) => [kind, serialiseValue]));
-export function serialiseValue(value) {
+function serialiseValue(value) {
     if (value == null || typeof value !== 'object') {
         return value;
     }
@@ -149,13 +151,13 @@ const serialiserMap = [
     serialiser(BuilderComponentSchema, serialiseNamedEntry),
     serialiser(BuilderCollectionSchema, serialiseNamedEntry),
     serialiser(BuilderComponentConfigSchema, (value) => ({
-        fields: serialiseValue(value.fields),
+        details: serialiseValue(value.details),
         tags: value.tags
     })),
-    serialiser(BuilderComponentFieldSchema, (value) => ({
-        type: 'component-field',
+    serialiser(BuilderComponentDetailSchema, (value) => ({
+        type: 'component-detail',
         name: value.name,
-        valueType: value.valueType,
+        kind: value.kind,
         isOptional: value.isOptional,
         tags: value.tags
     })),
@@ -165,22 +167,25 @@ const serialiserMap = [
         max: serialiseValue(value.max),
         tags: value.tags
     })),
-    serialiser(BuilderSelectConfigSchema, (value) => ({
-        type: 'select',
-        options: value.options,
+    serialiser(BuilderValueConfigSchema, (value) => ({
+        type: 'value',
+        kind: value.kind,
         defaultValue: value.defaultValue,
         isOptional: value.isOptional,
-        optionLabels: value.optionLabels,
         tags: value.tags
     })),
-    serialiser(BuilderToggleConfigSchema, (value) => ({
-        type: 'toggle',
-        valueType: value.valueType,
+    serialiser(BuilderSelectConfigSchema, (value) => ({
+        type: 'value',
+        kind: value.kind,
         defaultValue: value.defaultValue,
         isOptional: value.isOptional,
+        options: value.options,
+        optionLabels: value.optionLabels,
         tags: value.tags
     })),
-    serialiser(BuilderExpectationSchema, (value) => ({ name: value.name, kind: value.kind }))
+    serialiser(BuilderExpectationSchema, (value) => value.payload == null
+        ? { name: value.name, kind: value.kind }
+        : { name: value.name, kind: value.kind, payload: serialiseValue(value.payload) })
 ];
 function serialiseNamedEntry(value) {
     const entry = {

package/dist/entities/ui/describe.d.ts

@@ -378,7 +378,7 @@ export declare const BuilderUIDescribeSerialisedSchema: v.SchemaWithPipe<readonl
     tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderUIDescribeSerialised = v.InferOutput<typeof BuilderUIDescribeSerialisedSchema>;
-export declare const validateUIDescribe: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
+export declare const validateUIDescribe: (input: unknown, references?: import("..").BuilderReferences, issues?: import("../../errors").BuilderIssuesScope) => import("..").ValidationResult<{
     readonly type: "describe";
     readonly label: string;
     readonly inputs: readonly {

package/dist/entities/ui/input.d.ts

@@ -2,7 +2,7 @@ import type { Paramable, ParamableSerialised } from '../../references';
 import type { BuilderModelGeneric, BuilderModelState, BuilderModelStateOf } from '../model/index';
 import type { BuilderPath } from '../paths';
 import type { BuilderTags } from '../tags';
-import type { BuilderValidPath } from '../when';
+import type { BuilderValidPath } from '../condition';
 import * as v from 'valibot';
 export type BuilderUIInputMetadata = Paramable<Record<string, Paramable<unknown>>>;
 export type BuilderUIInputMetadataSerialised = ParamableSerialised<Record<string, ParamableSerialised<unknown>>>;
@@ -441,7 +441,7 @@ export declare const BuilderUIInputsSerialisedSchema: v.SchemaWithPipe<readonly
     tags?: readonly string[] | undefined;
 }>)[]>]>;
 export type BuilderUIInputsSerialised = v.InferOutput<typeof BuilderUIInputsSerialisedSchema>;
-export declare const validateUIInput: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderErrorsScope) => import("..").ValidationResult<{
+export declare const validateUIInput: (input: unknown, references?: import("..").BuilderReferences, issues?: import("../../errors").BuilderIssuesScope) => import("..").ValidationResult<{
     readonly type: "input";
     readonly path: readonly (string | number)[];
     readonly displayName?: string | undefined;