@builder-builder/builder 0.0.9 → 0.0.10

package/dist/entities/bind.d.ts

@@ -0,0 +1,4 @@
+import type { BuilderParameters, BuilderReferences } from '../references';
+import type { BuilderGeneric } from './builder/index';
+import type { BuilderUIGeneric } from './ui/index';
+export declare function bind<Instance extends BuilderGeneric | BuilderUIGeneric>(instance: Instance, bindings: Record<string, unknown>, construct: (walked: Instance, walkedNonRefValues: ReadonlyArray<unknown>, remainingParameters: BuilderParameters, newReferences: BuilderReferences) => Instance): Instance;

package/dist/entities/bind.js

@@ -0,0 +1,44 @@
+import * as v from 'valibot';
+import { isParameter, isRef } from '../references.js';
+import { createWalkerBinding } from '../walker/index.js';
+import { BuilderSchema, BuilderSerialisedSchema } from './builder/index.js';
+import { BuilderUISchema, BuilderUISerialisedSchema } from './ui/index.js';
+export function bind(instance, bindings, construct) {
+    const bindingEntries = Object.entries(bindings);
+    const refBindings = bindingEntries.filter(([, value]) => isRef(value));
+    const partBindingNames = new Set(bindingEntries
+        .filter(([, value]) => v.is(BuilderSchema, value) || v.is(BuilderUISchema, value))
+        .map(([name]) => name));
+    const walk = createWalkerBinding({
+        lookupBinding: (parameter) => {
+            const binding = bindings[parameter.name];
+            if (binding == null || isRef(binding)) {
+                return null;
+            }
+            return binding;
+        }
+    });
+    const walked = walk(schemaOf(instance), instance);
+    const nonRefValues = bindingEntries
+        .filter(([, value]) => !isRef(value))
+        .map(([, value]) => value);
+    const walkedNonRefValues = nonRefValues.map((value) => walkBindable(value, walk));
+    const newReferences = refBindings.map(([name, refValue]) => ({
+        parameter: name,
+        id: refValue.id
+    }));
+    const remainingParameters = walked.parameters.filter((parameter) => !isParameter(parameter) || !partBindingNames.has(parameter.name));
+    return construct(walked, walkedNonRefValues, remainingParameters, newReferences);
+}
+function schemaOf(instance) {
+    return v.is(BuilderUISchema, instance) ? BuilderUISerialisedSchema : BuilderSerialisedSchema;
+}
+function walkBindable(value, walk) {
+    if (v.is(BuilderUISchema, value)) {
+        return walk(BuilderUISerialisedSchema, value);
+    }
+    if (v.is(BuilderSchema, value)) {
+        return walk(BuilderSerialisedSchema, value);
+    }
+    return value;
+}

package/dist/entities/builder/bind.d.ts

@@ -0,0 +1,85 @@
+import type { BuilderPaths } from '../../paths';
+import type { BuilderParameter, BuilderParameters, BuilderRef, Paramable } from '../../references';
+import type { BuilderCollectionConfig } from '../collection/config';
+import type { BuilderCollectionPayload } from '../collection/index';
+import type { BuilderComponentPayload } from '../component/index';
+import type { BuilderOptionPayload } from '../option/index';
+import type { BuilderWhenConfig, BuilderWhenConstrained, WhenConfigNullable } from '../when';
+import type { BuilderGeneric } from './builder';
+import type { BuilderState, BuilderStateAppend } from './state';
+import { Builder } from './builder.js';
+export type BuilderBindings<State extends BuilderState> = {
+    readonly [Name in BuilderParametersNamesOf<State['parameters']> | ParameterNamesOf<State['options']> | ParameterNamesOf<State['collections']> | ParameterNamesOf<State['components']> | CollectionConfigParameterNamesOf<State['collections']>]?: BuilderWhenConstrained<State, PayloadForParameter<State, Name>> | BuilderRef;
+};
+export declare function bindBuilder<State extends BuilderState, Bindings extends BuilderBindings<State>>(builder: Builder<State>, bindings: Bindings): Builder<BuilderBoundState<State, Bindings>>;
+export type BuilderBoundState<State extends BuilderState, Bindings extends BuilderBindings<State>> = BuilderStateAppend<State, {
+    options: EntryBound<State['options'], Bindings>;
+    collections: EntryBound<State['collections'], Bindings>;
+    components: EntryBound<State['components'], Bindings>;
+    model: Omit<State['model'], keyof Bindings> & {
+        [K in Extract<keyof Bindings, string>]: BindingModelType<Bindings[K]>;
+    };
+}>;
+export type BindingModelType<Binding> = Binding extends BuilderRef ? unknown : BindingValueType<Binding> | BindingConfigNullable<Binding>;
+type BindingValueType<Binding> = Binding extends {
+    readonly type: 'match';
+    readonly selectMap: infer SelectMap extends Record<string, unknown>;
+} ? NonNullable<SelectMap[keyof SelectMap]> extends {
+    readonly value: infer Value;
+} ? Value : string : Binding extends {
+    readonly payload: {
+        readonly value: infer Value;
+    };
+} ? Value : Binding extends {
+    readonly value: infer Value;
+} ? Value : string;
+type BindingConfigNullable<Binding> = Binding extends BuilderWhenConfig ? WhenConfigNullable<Binding> : never;
+type EntryLike = {
+    readonly name: string;
+    readonly payload: unknown;
+    readonly gatePaths?: Paramable<BuilderPaths>;
+};
+type EntryBound<Entries extends ReadonlyArray<EntryLike>, Bindings> = Entries extends readonly [
+    infer Head extends EntryLike,
+    ...infer Tail extends ReadonlyArray<EntryLike>
+] ? Head extends {
+    readonly payload: infer Payload;
+} ? Payload extends BuilderParameter ? Head['name'] extends keyof Bindings ? Bindings[Head['name']] extends BuilderRef ? [Head, ...EntryBound<Tail, Bindings>] : [...EntryBound<Tail, Bindings>] : [Head, ...EntryBound<Tail, Bindings>] : [Head, ...EntryBound<Tail, Bindings>] : [Head, ...EntryBound<Tail, Bindings>] : [];
+type EntryParameters<Entries extends ReadonlyArray<EntryLike>> = Entries[number] extends infer Entry ? Entry extends {
+    readonly payload: infer Payload;
+} ? PayloadParameters<Payload> : never : never;
+type PayloadParameters<Payload> = ParameterOf<Payload> | (Payload extends {
+    readonly type: 'match';
+    readonly selectMap: infer SelectMap;
+} ? ParameterOf<SelectMap[keyof SelectMap]> : never) | (Payload extends {
+    readonly type: 'enable' | 'unless';
+    readonly payload: infer Inner;
+} ? ParameterOf<Inner> : never);
+type ParameterOf<Value> = Extract<Value, BuilderParameter> extends infer Parameter extends BuilderParameter ? {
+    readonly name: Parameter['name'];
+    readonly payload: Parameter;
+} : never;
+type ParameterNamesOf<Entries extends ReadonlyArray<EntryLike>> = EntryParameters<Entries>['name'];
+type PayloadForParameter<State extends BuilderState, Name extends string> = Name extends BuilderParametersNamesOf<State['parameters']> ? BuilderGeneric : Name extends ParameterNamesOf<State['options']> ? BuilderOptionPayload : Name extends ParameterNamesOf<State['collections']> ? BuilderCollectionPayload : Name extends ParameterNamesOf<State['components']> ? BuilderComponentPayload : Name extends CollectionConfigParameterNamesOf<State['collections']> ? CollectionConfigExpectedOf<State['collections'], Name> : never;
+type BuilderParametersNamesOf<Parameters extends BuilderParameters> = Extract<Parameters[number], BuilderParameter>['name'];
+type CollectionConfigOf<Payload> = Payload extends BuilderCollectionConfig<infer Builder, infer Min, infer Max> ? BuilderCollectionConfig<Builder, Min, Max> : Payload extends {
+    readonly type: 'enable' | 'unless';
+    readonly payload: infer Inner;
+} ? CollectionConfigOf<Inner> : Payload extends {
+    readonly type: 'match';
+    readonly selectMap: infer SelectMap;
+} ? CollectionConfigOf<NonNullable<SelectMap[keyof SelectMap]>> : never;
+type CollectionConfigParameterInfo<Value, Expected> = Value extends BuilderParameter ? {
+    readonly name: Value['name'];
+    readonly payload: Value;
+    readonly expected: Expected;
+} : never;
+type CollectionConfigParameters<Payload> = [CollectionConfigOf<Payload>] extends [never] ? never : CollectionConfigOf<Payload> extends BuilderCollectionConfig<infer Builder, infer Min, infer Max> ? CollectionConfigParameterInfo<Builder, BuilderGeneric> | CollectionConfigParameterInfo<Min, number> | CollectionConfigParameterInfo<Max, number> : never;
+type CollectionConfigParametersOfEntries<Entries extends ReadonlyArray<EntryLike>> = Entries[number] extends infer Entry ? Entry extends {
+    readonly payload: infer Payload;
+} ? CollectionConfigParameters<Payload> : never : never;
+type CollectionConfigParameterNamesOf<Entries extends ReadonlyArray<EntryLike>> = CollectionConfigParametersOfEntries<Entries>['name'];
+type CollectionConfigExpectedOf<Entries extends ReadonlyArray<EntryLike>, Name extends string> = Extract<CollectionConfigParametersOfEntries<Entries>, {
+    readonly name: Name;
+}>['expected'];
+export {};

package/dist/entities/builder/bind.js

@@ -0,0 +1,9 @@
+import { bind } from '../bind.js';
+import { Builder } from './builder.js';
+import { mergeBuilderParts } from './builders.js';
+export function bindBuilder(builder, bindings) {
+    return bind(builder, bindings, (walked, walkedNonRefValues, remainingParameters, newReferences) => {
+        const merged = mergeBuilderParts(walkedNonRefValues);
+        return new Builder([...remainingParameters, ...merged.parameters], [...walked.options, ...merged.options], [...walked.components, ...merged.components], [...walked.collections, ...merged.collections], [...walked.expectations, ...merged.expectations], [...walked.references, ...newReferences, ...merged.references]);
+    });
+}

package/dist/entities/builder/builder.d.ts

@@ -1,5 +1,5 @@
 import type { Prettify } from '../../prettify';
-import type { BuilderRefs, Refable } from '../../references';
+import type { BuilderParameters, BuilderReferences, Paramable } from '../../references';
 import type { BuilderCollections } from '../collection/index';
 import type { BuilderComponentDetails, BuilderComponents } from '../component/index';
 import type { BuilderExpectation, BuilderExpectations } from '../expectation';
@@ -7,54 +7,55 @@ import type { BuilderOptions } from '../option/index';
 import type { BuilderWhenConstrained } from '../when';
 import type { BuilderStateAsserted } from './expectation';
 import type { BuilderCollectionMethod, BuilderComponentMethod, BuilderOptionMethod } from './methods';
-import type { BuilderBindings, BuilderBoundState } from './parameter';
+import type { BuilderBindings, BuilderBoundState } from './bind';
 import type { BuilderState, BuilderStateEmpty } from './state';
 import * as v from 'valibot';
 export declare class Builder<State extends BuilderState = BuilderStateEmpty> {
     #private;
     readonly type: 'builder';
-    readonly references: State['references'];
+    readonly parameters: State['parameters'];
     readonly options: State['options'];
     readonly components: State['components'];
     readonly collections: State['collections'];
     readonly expectations: BuilderExpectations;
+    readonly references: BuilderReferences;
     readonly id: `${string}-${string}-${string}-${string}-${string}`;
-    constructor(references?: BuilderRefs, options?: BuilderOptions, components?: BuilderComponents, collections?: BuilderCollections, expectations?: BuilderExpectations);
+    constructor(parameters?: BuilderParameters, options?: BuilderOptions, components?: BuilderComponents, collections?: BuilderCollections, expectations?: BuilderExpectations, references?: BuilderReferences);
     get option(): BuilderOptionMethod<State>;
     get component(): BuilderComponentMethod<State>;
     get collection(): BuilderCollectionMethod<State>;
     expect<const Expectations extends readonly [BuilderExpectation, ...ReadonlyArray<BuilderExpectation>]>(...expectations: Expectations): Builder<BuilderStateAsserted<State, Expectations>>;
     bind<const Bindings extends BuilderBindings<State>>(bindings: Bindings & {
         readonly [Key in keyof Bindings]: BuilderWhenConstrained<State, Bindings[Key]>;
-    }): Builder<BuilderBoundState<State, Bindings>>;
+    }): Builder<Prettify<BuilderBoundState<State, Bindings>>>;
 }
 export type BuilderGeneric = Builder<BuilderState>;
 export declare const BuilderSchema: v.InstanceSchema<typeof Builder, undefined>;
 export declare const BuilderSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly references: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"ref", undefined>;
+    readonly parameters: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"parameter", undefined>;
         readonly id: v.StringSchema<undefined>;
         readonly name: v.StringSchema<undefined>;
     }, undefined>, v.ReadonlyAction<{
-        type: "ref";
+        type: "parameter";
         id: string;
         name: string;
     }>]>, undefined>, v.ReadonlyAction<Readonly<{
-        type: "ref";
+        type: "parameter";
         id: string;
         name: string;
     }>[]>]>;
     readonly options: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
         readonly name: v.StringSchema<undefined>;
         readonly payload: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-            readonly type: v.LiteralSchema<"ref", undefined>;
+            readonly type: v.LiteralSchema<"parameter", undefined>;
             readonly id: v.StringSchema<undefined>;
             readonly name: v.StringSchema<undefined>;
         }, undefined>, v.ReadonlyAction<{
-            type: "ref";
+            type: "parameter";
             id: string;
             name: string;
-        }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, undefined>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        }>]>, v.InstanceSchema<typeof import("../..").BuilderParameter, undefined>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.VariantSchema<"type", [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>;
@@ -111,7 +112,7 @@ export declare const BuilderSerialisedSchema: v.SchemaWithPipe<readonly [v.Objec
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
         }>>]>, v.GenericSchema], undefined>], undefined>, v.MetadataAction<unknown, {
-            readonly refable: v.UnionSchema<[v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.SchemaWithPipe<readonly [v.ObjectSchema<{
+            readonly paramable: v.UnionSchema<[v.SchemaWithPipe<readonly [v.VariantSchema<"type", [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>;
@@ -170,68 +171,68 @@ export declare const BuilderSerialisedSchema: v.SchemaWithPipe<readonly [v.Objec
             }>>]>, v.GenericSchema], undefined>;
         }>]>;
         readonly gatePaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-            readonly type: v.LiteralSchema<"ref", undefined>;
+            readonly type: v.LiteralSchema<"parameter", undefined>;
             readonly id: v.StringSchema<undefined>;
             readonly name: v.StringSchema<undefined>;
         }, undefined>, v.ReadonlyAction<{
-            type: "ref";
+            type: "parameter";
             id: string;
             name: string;
-        }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>], undefined>, v.MetadataAction<readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
+        }>]>, v.InstanceSchema<typeof import("../..").BuilderParameter, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>], undefined>, v.MetadataAction<readonly (readonly (string | number)[])[] | Readonly<{
+            type: "parameter";
             id: string;
             name: string;
-        }>, {
-            readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
+        }> | import("../..").BuilderParameter<string>, {
+            readonly paramable: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
         }>]>, undefined>;
     }, undefined>, v.MetadataAction<{
         name: string;
         payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
+        gatePaths?: readonly (readonly (string | number)[])[] | Readonly<{
+            type: "parameter";
             id: string;
             name: string;
-        }> | undefined;
+        }> | import("../..").BuilderParameter<string> | undefined;
     }, {
         readonly serialisable: typeof import("..").BuilderOption;
         readonly instance: v.InstanceSchema<typeof import("..").BuilderOption, undefined>;
     }>, v.ReadonlyAction<{
         name: string;
         payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
+        gatePaths?: readonly (readonly (string | number)[])[] | Readonly<{
+            type: "parameter";
             id: string;
             name: string;
-        }> | undefined;
+        }> | import("../..").BuilderParameter<string> | undefined;
     }>]>, undefined>, v.ReadonlyAction<Readonly<{
         name: string;
         payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
+        gatePaths?: readonly (readonly (string | number)[])[] | Readonly<{
+            type: "parameter";
             id: string;
             name: string;
-        }> | undefined;
+        }> | import("../..").BuilderParameter<string> | undefined;
     }>[]>]>;
     readonly components: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
         readonly name: v.StringSchema<undefined>;
         readonly payload: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-            readonly type: v.LiteralSchema<"ref", undefined>;
+            readonly type: v.LiteralSchema<"parameter", undefined>;
             readonly id: v.StringSchema<undefined>;
             readonly name: v.StringSchema<undefined>;
         }, undefined>, v.ReadonlyAction<{
-            type: "ref";
+            type: "parameter";
             id: string;
             name: string;
-        }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, undefined>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        }>]>, v.InstanceSchema<typeof import("../..").BuilderParameter, undefined>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
             readonly expectations: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-                readonly type: v.LiteralSchema<"ref", undefined>;
+                readonly type: v.LiteralSchema<"parameter", undefined>;
                 readonly id: v.StringSchema<undefined>;
                 readonly name: v.StringSchema<undefined>;
             }, undefined>, v.ReadonlyAction<{
-                type: "ref";
+                type: "parameter";
                 id: string;
                 name: string;
-            }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+            }>]>, v.InstanceSchema<typeof import("../..").BuilderParameter, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
                 readonly name: v.StringSchema<undefined>;
                 readonly kind: v.PicklistSchema<["option", "component", "collection", "detail"], undefined>;
             }, undefined>, v.MetadataAction<{
@@ -246,15 +247,15 @@ export declare const BuilderSerialisedSchema: v.SchemaWithPipe<readonly [v.Objec
             }>]>, undefined>, v.ReadonlyAction<Readonly<{
                 name: string;
                 kind: "option" | "component" | "collection" | "detail";
-            }>[]>]>], undefined>, v.MetadataAction<import("../..").BuilderRef | Readonly<{
-                type: "ref";
+            }>[]>]>], undefined>, v.MetadataAction<Readonly<{
+                type: "parameter";
                 id: string;
                 name: string;
-            }> | readonly Readonly<{
+            }> | import("../..").BuilderParameter<string> | readonly Readonly<{
                 name: string;
                 kind: "option" | "component" | "collection" | "detail";
             }>[], {
-                readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+                readonly paramable: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
                     readonly name: v.StringSchema<undefined>;
                     readonly kind: v.PicklistSchema<["option", "component", "collection", "detail"], undefined>;
                 }, undefined>, v.MetadataAction<{
@@ -272,11 +273,11 @@ export declare const BuilderSerialisedSchema: v.SchemaWithPipe<readonly [v.Objec
                 }>[]>]>;
             }>]>;
         }, undefined>, v.MetadataAction<{
-            expectations: import("../..").BuilderRef | Readonly<{
-                type: "ref";
+            expectations: Readonly<{
+                type: "parameter";
                 id: string;
                 name: string;
-            }> | readonly Readonly<{
+            }> | import("../..").BuilderParameter<string> | readonly Readonly<{
                 name: string;
                 kind: "option" | "component" | "collection" | "detail";
             }>[];
@@ -284,25 +285,25 @@ export declare const BuilderSerialisedSchema: v.SchemaWithPipe<readonly [v.Objec
             readonly serialisable: typeof BuilderComponentDetails;
             readonly instance: v.InstanceSchema<typeof BuilderComponentDetails, undefined>;
         }>, v.ReadonlyAction<{
-            expectations: import("../..").BuilderRef | Readonly<{
-                type: "ref";
+            expectations: Readonly<{
+                type: "parameter";
                 id: string;
                 name: string;
-            }> | readonly Readonly<{
+            }> | import("../..").BuilderParameter<string> | readonly Readonly<{
                 name: string;
                 kind: "option" | "component" | "collection" | "detail";
             }>[];
         }>]>, v.GenericSchema], undefined>], undefined>, v.MetadataAction<unknown, {
-            readonly refable: v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+            readonly paramable: v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
                 readonly expectations: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-                    readonly type: v.LiteralSchema<"ref", undefined>;
+                    readonly type: v.LiteralSchema<"parameter", undefined>;
                     readonly id: v.StringSchema<undefined>;
                     readonly name: v.StringSchema<undefined>;
                 }, undefined>, v.ReadonlyAction<{
-                    type: "ref";
+                    type: "parameter";
                     id: string;
                     name: string;
-                }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+                }>]>, v.InstanceSchema<typeof import("../..").BuilderParameter, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
                     readonly name: v.StringSchema<undefined>;
                     readonly kind: v.PicklistSchema<["option", "component", "collection", "detail"], undefined>;
                 }, undefined>, v.MetadataAction<{
@@ -317,15 +318,15 @@ export declare const BuilderSerialisedSchema: v.SchemaWithPipe<readonly [v.Objec
                 }>]>, undefined>, v.ReadonlyAction<Readonly<{
                     name: string;
                     kind: "option" | "component" | "collection" | "detail";
-                }>[]>]>], undefined>, v.MetadataAction<import("../..").BuilderRef | Readonly<{
-                    type: "ref";
+                }>[]>]>], undefined>, v.MetadataAction<Readonly<{
+                    type: "parameter";
                     id: string;
                     name: string;
-                }> | readonly Readonly<{
+                }> | import("../..").BuilderParameter<string> | readonly Readonly<{
                     name: string;
                     kind: "option" | "component" | "collection" | "detail";
                 }>[], {
-                    readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+                    readonly paramable: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
                         readonly name: v.StringSchema<undefined>;
                         readonly kind: v.PicklistSchema<["option", "component", "collection", "detail"], undefined>;
                     }, undefined>, v.MetadataAction<{
@@ -343,11 +344,11 @@ export declare const BuilderSerialisedSchema: v.SchemaWithPipe<readonly [v.Objec
                     }>[]>]>;
                 }>]>;
             }, undefined>, v.MetadataAction<{
-                expectations: import("../..").BuilderRef | Readonly<{
-                    type: "ref";
+                expectations: Readonly<{
+                    type: "parameter";
                     id: string;
                     name: string;
-                }> | readonly Readonly<{
+                }> | import("../..").BuilderParameter<string> | readonly Readonly<{
                     name: string;
                     kind: "option" | "component" | "collection" | "detail";
                 }>[];
@@ -355,58 +356,58 @@ export declare const BuilderSerialisedSchema: v.SchemaWithPipe<readonly [v.Objec
                 readonly serialisable: typeof BuilderComponentDetails;
                 readonly instance: v.InstanceSchema<typeof BuilderComponentDetails, undefined>;
             }>, v.ReadonlyAction<{
-                expectations: import("../..").BuilderRef | Readonly<{
-                    type: "ref";
+                expectations: Readonly<{
+                    type: "parameter";
                     id: string;
                     name: string;
-                }> | readonly Readonly<{
+                }> | import("../..").BuilderParameter<string> | readonly Readonly<{
                     name: string;
                     kind: "option" | "component" | "collection" | "detail";
                 }>[];
             }>]>, v.GenericSchema], undefined>;
         }>]>;
         readonly gatePaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-            readonly type: v.LiteralSchema<"ref", undefined>;
+            readonly type: v.LiteralSchema<"parameter", undefined>;
             readonly id: v.StringSchema<undefined>;
             readonly name: v.StringSchema<undefined>;
         }, undefined>, v.ReadonlyAction<{
-            type: "ref";
+            type: "parameter";
             id: string;
             name: string;
-        }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>], undefined>, v.MetadataAction<readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
+        }>]>, v.InstanceSchema<typeof import("../..").BuilderParameter, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>], undefined>, v.MetadataAction<readonly (readonly (string | number)[])[] | Readonly<{
+            type: "parameter";
             id: string;
             name: string;
-        }>, {
-            readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
+        }> | import("../..").BuilderParameter<string>, {
+            readonly paramable: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
         }>]>, undefined>;
     }, undefined>, v.MetadataAction<{
         name: string;
         payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
+        gatePaths?: readonly (readonly (string | number)[])[] | Readonly<{
+            type: "parameter";
             id: string;
             name: string;
-        }> | undefined;
+        }> | import("../..").BuilderParameter<string> | undefined;
     }, {
         readonly serialisable: typeof import("..").BuilderComponent;
         readonly instance: v.InstanceSchema<typeof import("..").BuilderComponent, undefined>;
     }>, v.ReadonlyAction<{
         name: string;
         payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
+        gatePaths?: readonly (readonly (string | number)[])[] | Readonly<{
+            type: "parameter";
             id: string;
             name: string;
-        }> | undefined;
+        }> | import("../..").BuilderParameter<string> | undefined;
     }>]>, undefined>, v.ReadonlyAction<Readonly<{
         name: string;
         payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
+        gatePaths?: readonly (readonly (string | number)[])[] | Readonly<{
+            type: "parameter";
             id: string;
             name: string;
-        }> | undefined;
+        }> | import("../..").BuilderParameter<string> | undefined;
     }>[]>]>;
     readonly collections: v.SchemaWithPipe<readonly [v.ArraySchema<v.GenericSchema<import("..").BuilderCollectionSerialised>, undefined>, v.ReadonlyAction<import("..").BuilderCollectionSerialised[]>]>;
     readonly expectations: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
@@ -425,70 +426,88 @@ export declare const BuilderSerialisedSchema: v.SchemaWithPipe<readonly [v.Objec
         name: string;
         kind: "option" | "component" | "collection" | "detail";
     }>[]>]>;
+    readonly references: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly parameter: v.StringSchema<undefined>;
+        readonly id: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        parameter: string;
+        id: string;
+    }>]>, undefined>, v.ReadonlyAction<Readonly<{
+        parameter: string;
+        id: string;
+    }>[]>]>;
 }, undefined>, v.MetadataAction<{
-    readonly references: readonly Readonly<{
-        type: "ref";
+    readonly parameters: readonly Readonly<{
+        type: "parameter";
         id: string;
         name: string;
     }>[];
     readonly options: readonly Readonly<{
         name: string;
         payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
+        gatePaths?: readonly (readonly (string | number)[])[] | Readonly<{
+            type: "parameter";
             id: string;
             name: string;
-        }> | undefined;
+        }> | import("../..").BuilderParameter<string> | undefined;
     }>[];
     readonly components: readonly Readonly<{
         name: string;
         payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
+        gatePaths?: readonly (readonly (string | number)[])[] | Readonly<{
+            type: "parameter";
             id: string;
             name: string;
-        }> | undefined;
+        }> | import("../..").BuilderParameter<string> | undefined;
     }>[];
     readonly collections: readonly import("..").BuilderCollectionSerialised[];
     readonly expectations: readonly Readonly<{
         name: string;
         kind: "option" | "component" | "collection" | "detail";
     }>[];
+    readonly references: readonly Readonly<{
+        parameter: string;
+        id: string;
+    }>[];
 }, {
     readonly serialisable: typeof Builder;
     readonly instance: v.InstanceSchema<typeof Builder, undefined>;
 }>, v.ReadonlyAction<{
-    readonly references: readonly Readonly<{
-        type: "ref";
+    readonly parameters: readonly Readonly<{
+        type: "parameter";
         id: string;
         name: string;
     }>[];
     readonly options: readonly Readonly<{
         name: string;
         payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
+        gatePaths?: readonly (readonly (string | number)[])[] | Readonly<{
+            type: "parameter";
             id: string;
             name: string;
-        }> | undefined;
+        }> | import("../..").BuilderParameter<string> | undefined;
     }>[];
     readonly components: readonly Readonly<{
         name: string;
         payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
+        gatePaths?: readonly (readonly (string | number)[])[] | Readonly<{
+            type: "parameter";
             id: string;
             name: string;
-        }> | undefined;
+        }> | import("../..").BuilderParameter<string> | undefined;
     }>[];
     readonly collections: readonly import("..").BuilderCollectionSerialised[];
     readonly expectations: readonly Readonly<{
         name: string;
         kind: "option" | "component" | "collection" | "detail";
     }>[];
+    readonly references: readonly Readonly<{
+        parameter: string;
+        id: string;
+    }>[];
 }>]>;
 export type BuilderSerialised = v.InferOutput<typeof BuilderSerialisedSchema>;
-export type BuilderStateOf<Input extends Refable<BuilderGeneric>> = Input extends Builder<infer State extends BuilderState> ? State : BuilderStateEmpty;
+export type BuilderStateOf<Input extends Paramable<BuilderGeneric>> = Input extends Builder<infer State extends BuilderState> ? State : BuilderStateEmpty;
 export type BuilderInstanceOf<Input extends BuilderGeneric> = Input extends Builder<infer State extends BuilderState> ? Prettify<State['model']> : never;
-export type BuilderReference = Refable<BuilderGeneric>;
-export type BuilderReferences = ReadonlyArray<Refable<BuilderGeneric>>;
+export type BuilderPart = Paramable<BuilderGeneric>;
+export type BuilderParts = ReadonlyArray<Paramable<BuilderGeneric>>;