@builder-builder/builder 0.0.9 → 0.0.11

package/dist/bb.d.ts

@@ -0,0 +1,28 @@
+import type { BuilderComponentVariantsValidated, BuilderInstanceValidated, BuilderModelValidated, BuilderRefEntities, BuilderUIValidated, BuilderValidated } from './entities/index';
+import type { BuilderEnvironment, BuilderEnvironmentResult } from './environment';
+import type { BuilderOrder, BuilderRenderResult } from './mappers/index';
+import type { BuilderComponentVariants, BuilderInstance, BuilderInstanceInput } from './instance';
+export type BBOptions = {
+    readonly references?: BuilderRefEntities;
+};
+export type BB<Env extends BuilderEnvironment = 'production'> = {
+    readonly validate: {
+        builder(input: unknown): BuilderEnvironmentResult<BuilderValidated, Env>;
+        model(input: unknown): BuilderEnvironmentResult<BuilderModelValidated, Env>;
+        ui(input: unknown): BuilderEnvironmentResult<BuilderUIValidated, Env>;
+        instance(model: BuilderModelValidated, instance: BuilderInstance): BuilderEnvironmentResult<BuilderInstanceValidated, Env>;
+        variants(model: BuilderModelValidated, input: unknown, options?: {
+            readonly partial?: boolean;
+        }): BuilderEnvironmentResult<BuilderComponentVariantsValidated, Env>;
+    };
+    instance(entity: BuilderValidated | BuilderModelValidated, partial?: BuilderInstanceInput): BuilderInstance;
+    render(builder: BuilderValidated, instance: BuilderInstanceValidated): BuilderRenderResult;
+    order(model: BuilderModelValidated, instance: BuilderInstanceValidated, variants: BuilderComponentVariantsValidated): BuilderOrder;
+    variants(entity: BuilderValidated | BuilderModelValidated): BuilderComponentVariants;
+};
+export declare const bb: typeof bbProd & {
+    dev: typeof bbDev;
+};
+declare function bbProd(options?: BBOptions): BB<'production'>;
+declare function bbDev(options?: BBOptions): BB<'development'>;
+export {};

package/dist/bb.js

@@ -0,0 +1,49 @@
+import { BuilderException } from './exception.js';
+import { assertValidated, createInstance, createVariants, order, render, validateBuilder, validateInstance, validateModel, validateUI, validateVariants } from './mappers/index.js';
+export const bb = Object.assign(bbProd, {
+    dev: bbDev
+});
+function bbProd(options = {}) {
+    return bbFactory('production', options.references);
+}
+function bbDev(options = {}) {
+    return bbFactory('development', options.references);
+}
+function bbFactory(environment, references = []) {
+    return {
+        validate: {
+            builder: (input) => throwInProd(validateBuilder(input, references)),
+            model: (input) => throwInProd(validateModel(input, references)),
+            ui: (input) => throwInProd(validateUI(input, references)),
+            instance: (model, instance) => throwInProd(validateInstance(model, instance)),
+            variants: (model, input, variantOptions) => throwInProd(validateVariants(model, input, variantOptions))
+        },
+        instance: (entity, partial) => {
+            assertValidated(entity);
+            return createInstance(entity, partial, references);
+        },
+        render: (builder, instance) => {
+            assertValidated(builder);
+            assertValidated(instance);
+            return render(builder, instance, references);
+        },
+        order: (model, instance, variants) => {
+            assertValidated(model);
+            assertValidated(instance);
+            assertValidated(variants);
+            return order(model, instance, variants, references);
+        },
+        variants: (entity) => {
+            assertValidated(entity);
+            return createVariants(entity);
+        }
+    };
+    function throwInProd(result) {
+        const [entity, errors] = result;
+        const isDev = environment === 'development';
+        if (!isDev && errors.length > 0) {
+            throw new BuilderException(errors);
+        }
+        return (isDev ? result : entity);
+    }
+}

package/dist/check.d.ts

@@ -3,7 +3,7 @@ declare class Check {
     truthy<Input>(input: Input, message?: `${string}! ❌`): asserts input is Exclude<Input, null | undefined | '' | 0 | false>;
     falsy(input: unknown, message?: `${string}! ❌`): void;
     is<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown): input is v.InferInput<Schema>;
-    assert<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown): asserts input is v.InferInput<Schema>;
+    assert<const Schema extends v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>>(schema: Schema, input: unknown, message?: `${string}! ❌`): asserts input is v.InferInput<Schema>;
 }
 export declare const check: Check;
 export {};

package/dist/check.js

@@ -15,8 +15,10 @@ class Check {
     is(schema, input) {
         return v.is(schema, input);
     }
-    assert(schema, input) {
-        v.assert(schema, input);
+    assert(schema, input, message = DEFAULT_MESSAGE) {
+        if (!v.is(schema, input)) {
+            throw new BuilderException([], message);
+        }
     }
 }
 export const check = new Check();

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

@@ -0,0 +1,4 @@
+import type { BuilderEntitySerialised } from '../kind';
+import type { BuilderRefSerialised } from '../../references';
+export type BuilderBindings = Readonly<Record<string, unknown>>;
+export type BuilderBindingsSerialised = Readonly<Record<string, BuilderEntitySerialised | BuilderRefSerialised>>;

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

@@ -1,494 +1,21 @@
-import type { Prettify } from '../../prettify';
-import type { BuilderRefs, Refable } from '../../references';
-import type { BuilderCollections } from '../collection/index';
-import type { BuilderComponentDetails, BuilderComponents } from '../component/index';
-import type { BuilderExpectation, BuilderExpectations } from '../expectation';
-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 { BuilderState, BuilderStateEmpty } from './state';
+import type { BuilderModelBindings, BuilderModelBoundState } from '../model/bind';
+import type { BuilderModelState } from '../model/state';
+import type { BuilderBindings, BuilderBindingsSerialised } from './bind';
 import * as v from 'valibot';
-export declare class Builder<State extends BuilderState = BuilderStateEmpty> {
-    #private;
+import { BuilderModel, BuilderModelSerialisedSchema } from '../model/index.js';
+import { BuilderUI, BuilderUISerialisedSchema } from '../ui/index.js';
+export declare class Builder<State extends BuilderModelState = BuilderModelState> {
     readonly type: 'builder';
-    readonly references: State['references'];
-    readonly options: State['options'];
-    readonly components: State['components'];
-    readonly collections: State['collections'];
-    readonly expectations: BuilderExpectations;
-    readonly id: `${string}-${string}-${string}-${string}-${string}`;
-    constructor(references?: BuilderRefs, options?: BuilderOptions, components?: BuilderComponents, collections?: BuilderCollections, expectations?: BuilderExpectations);
-    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>>;
+    readonly model: BuilderModel<State>;
+    readonly ui: BuilderUI;
+    readonly bindings: BuilderBindings;
+    constructor(model?: BuilderModel<State>, ui?: BuilderUI<import("..").BuilderModelGeneric>, bindings?: BuilderBindings);
+    bind<const Bindings extends BuilderBindings>(extra: Bindings): Bindings extends BuilderModelBindings<State> ? Builder<BuilderModelBoundState<State, Bindings>> : Builder<State>;
 }
-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 id: v.StringSchema<undefined>;
-        readonly name: v.StringSchema<undefined>;
-    }, undefined>, v.ReadonlyAction<{
-        type: "ref";
-        id: string;
-        name: string;
-    }>]>, undefined>, v.ReadonlyAction<Readonly<{
-        type: "ref";
-        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 id: v.StringSchema<undefined>;
-            readonly name: v.StringSchema<undefined>;
-        }, undefined>, v.ReadonlyAction<{
-            type: "ref";
-            id: string;
-            name: string;
-        }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, 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>;
-            readonly isOptional: v.BooleanSchema<undefined>;
-            readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
-        }, undefined>, v.MetadataAction<{
-            type: "select";
-            readonly options: readonly [string, ...string[]];
-            defaultValue: string | null;
-            isOptional: boolean;
-            optionLabels: {
-                [x: string]: string;
-            };
-        }, {
-            readonly serialisable: typeof import("..").BuilderSelectType;
-            readonly instance: v.InstanceSchema<typeof import("..").BuilderSelectType, undefined>;
-        }>, v.ReadonlyAction<{
-            type: "select";
-            readonly options: readonly [string, ...string[]];
-            defaultValue: string | null;
-            isOptional: boolean;
-            optionLabels: {
-                [x: string]: string;
-            };
-        }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
-            readonly type: v.LiteralSchema<"toggle", undefined>;
-            readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
-            readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
-            readonly isOptional: v.BooleanSchema<undefined>;
-        }, undefined>, v.MetadataAction<{
-            type: "toggle";
-            valueType: "string" | "number" | "boolean";
-            defaultValue: string | number | boolean | null;
-            isOptional: boolean;
-        }, {
-            readonly serialisable: typeof import("..").BuilderToggleType;
-            readonly instance: v.InstanceSchema<typeof import("..").BuilderToggleType, undefined>;
-        }>, v.ReadonlyAction<{
-            type: "toggle";
-            valueType: "string" | "number" | "boolean";
-            defaultValue: string | number | boolean | null;
-            isOptional: boolean;
-        }>]>], undefined>, v.ReadonlyAction<Readonly<{
-            type: "select";
-            readonly options: readonly [string, ...string[]];
-            defaultValue: string | null;
-            isOptional: boolean;
-            optionLabels: {
-                [x: string]: string;
-            };
-        }> | Readonly<{
-            type: "toggle";
-            valueType: "string" | "number" | "boolean";
-            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 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>;
-            }, undefined>, v.MetadataAction<{
-                type: "select";
-                readonly options: readonly [string, ...string[]];
-                defaultValue: string | null;
-                isOptional: boolean;
-                optionLabels: {
-                    [x: string]: string;
-                };
-            }, {
-                readonly serialisable: typeof import("..").BuilderSelectType;
-                readonly instance: v.InstanceSchema<typeof import("..").BuilderSelectType, undefined>;
-            }>, v.ReadonlyAction<{
-                type: "select";
-                readonly options: readonly [string, ...string[]];
-                defaultValue: string | null;
-                isOptional: boolean;
-                optionLabels: {
-                    [x: string]: string;
-                };
-            }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
-                readonly type: v.LiteralSchema<"toggle", undefined>;
-                readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
-                readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
-                readonly isOptional: v.BooleanSchema<undefined>;
-            }, undefined>, v.MetadataAction<{
-                type: "toggle";
-                valueType: "string" | "number" | "boolean";
-                defaultValue: string | number | boolean | null;
-                isOptional: boolean;
-            }, {
-                readonly serialisable: typeof import("..").BuilderToggleType;
-                readonly instance: v.InstanceSchema<typeof import("..").BuilderToggleType, undefined>;
-            }>, v.ReadonlyAction<{
-                type: "toggle";
-                valueType: "string" | "number" | "boolean";
-                defaultValue: string | number | boolean | null;
-                isOptional: boolean;
-            }>]>], undefined>, v.ReadonlyAction<Readonly<{
-                type: "select";
-                readonly options: readonly [string, ...string[]];
-                defaultValue: string | null;
-                isOptional: boolean;
-                optionLabels: {
-                    [x: string]: string;
-                };
-            }> | Readonly<{
-                type: "toggle";
-                valueType: "string" | "number" | "boolean";
-                defaultValue: string | number | boolean | null;
-                isOptional: boolean;
-            }>>]>, v.GenericSchema], undefined>;
-        }>]>;
-        readonly gatePaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-            readonly type: v.LiteralSchema<"ref", undefined>;
-            readonly id: v.StringSchema<undefined>;
-            readonly name: v.StringSchema<undefined>;
-        }, undefined>, v.ReadonlyAction<{
-            type: "ref";
-            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";
-            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)[])[]>]>;
-        }>]>, undefined>;
-    }, undefined>, v.MetadataAction<{
-        name: string;
-        payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
-            id: string;
-            name: 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";
-            id: string;
-            name: string;
-        }> | undefined;
-    }>]>, undefined>, v.ReadonlyAction<Readonly<{
-        name: string;
-        payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
-            id: string;
-            name: 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 id: v.StringSchema<undefined>;
-            readonly name: v.StringSchema<undefined>;
-        }, undefined>, v.ReadonlyAction<{
-            type: "ref";
-            id: string;
-            name: string;
-        }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, 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 id: v.StringSchema<undefined>;
-                readonly name: v.StringSchema<undefined>;
-            }, undefined>, v.ReadonlyAction<{
-                type: "ref";
-                id: string;
-                name: string;
-            }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, 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<{
-                name: string;
-                kind: "option" | "component" | "collection" | "detail";
-            }, {
-                readonly serialisable: typeof BuilderExpectation;
-                readonly instance: v.InstanceSchema<typeof BuilderExpectation, undefined>;
-            }>, v.ReadonlyAction<{
-                name: string;
-                kind: "option" | "component" | "collection" | "detail";
-            }>]>, undefined>, v.ReadonlyAction<Readonly<{
-                name: string;
-                kind: "option" | "component" | "collection" | "detail";
-            }>[]>]>], undefined>, v.MetadataAction<import("../..").BuilderRef | Readonly<{
-                type: "ref";
-                id: string;
-                name: string;
-            }> | readonly Readonly<{
-                name: string;
-                kind: "option" | "component" | "collection" | "detail";
-            }>[], {
-                readonly refable: 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<{
-                    name: string;
-                    kind: "option" | "component" | "collection" | "detail";
-                }, {
-                    readonly serialisable: typeof BuilderExpectation;
-                    readonly instance: v.InstanceSchema<typeof BuilderExpectation, undefined>;
-                }>, v.ReadonlyAction<{
-                    name: string;
-                    kind: "option" | "component" | "collection" | "detail";
-                }>]>, undefined>, v.ReadonlyAction<Readonly<{
-                    name: string;
-                    kind: "option" | "component" | "collection" | "detail";
-                }>[]>]>;
-            }>]>;
-        }, undefined>, v.MetadataAction<{
-            expectations: import("../..").BuilderRef | Readonly<{
-                type: "ref";
-                id: string;
-                name: string;
-            }> | readonly Readonly<{
-                name: string;
-                kind: "option" | "component" | "collection" | "detail";
-            }>[];
-        }, {
-            readonly serialisable: typeof BuilderComponentDetails;
-            readonly instance: v.InstanceSchema<typeof BuilderComponentDetails, undefined>;
-        }>, v.ReadonlyAction<{
-            expectations: import("../..").BuilderRef | Readonly<{
-                type: "ref";
-                id: string;
-                name: 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 expectations: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-                    readonly type: v.LiteralSchema<"ref", undefined>;
-                    readonly id: v.StringSchema<undefined>;
-                    readonly name: v.StringSchema<undefined>;
-                }, undefined>, v.ReadonlyAction<{
-                    type: "ref";
-                    id: string;
-                    name: string;
-                }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, 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<{
-                    name: string;
-                    kind: "option" | "component" | "collection" | "detail";
-                }, {
-                    readonly serialisable: typeof BuilderExpectation;
-                    readonly instance: v.InstanceSchema<typeof BuilderExpectation, undefined>;
-                }>, v.ReadonlyAction<{
-                    name: string;
-                    kind: "option" | "component" | "collection" | "detail";
-                }>]>, undefined>, v.ReadonlyAction<Readonly<{
-                    name: string;
-                    kind: "option" | "component" | "collection" | "detail";
-                }>[]>]>], undefined>, v.MetadataAction<import("../..").BuilderRef | Readonly<{
-                    type: "ref";
-                    id: string;
-                    name: string;
-                }> | readonly Readonly<{
-                    name: string;
-                    kind: "option" | "component" | "collection" | "detail";
-                }>[], {
-                    readonly refable: 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<{
-                        name: string;
-                        kind: "option" | "component" | "collection" | "detail";
-                    }, {
-                        readonly serialisable: typeof BuilderExpectation;
-                        readonly instance: v.InstanceSchema<typeof BuilderExpectation, undefined>;
-                    }>, v.ReadonlyAction<{
-                        name: string;
-                        kind: "option" | "component" | "collection" | "detail";
-                    }>]>, undefined>, v.ReadonlyAction<Readonly<{
-                        name: string;
-                        kind: "option" | "component" | "collection" | "detail";
-                    }>[]>]>;
-                }>]>;
-            }, undefined>, v.MetadataAction<{
-                expectations: import("../..").BuilderRef | Readonly<{
-                    type: "ref";
-                    id: string;
-                    name: string;
-                }> | readonly Readonly<{
-                    name: string;
-                    kind: "option" | "component" | "collection" | "detail";
-                }>[];
-            }, {
-                readonly serialisable: typeof BuilderComponentDetails;
-                readonly instance: v.InstanceSchema<typeof BuilderComponentDetails, undefined>;
-            }>, v.ReadonlyAction<{
-                expectations: import("../..").BuilderRef | Readonly<{
-                    type: "ref";
-                    id: string;
-                    name: 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 id: v.StringSchema<undefined>;
-            readonly name: v.StringSchema<undefined>;
-        }, undefined>, v.ReadonlyAction<{
-            type: "ref";
-            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";
-            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)[])[]>]>;
-        }>]>, undefined>;
-    }, undefined>, v.MetadataAction<{
-        name: string;
-        payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
-            id: string;
-            name: 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";
-            id: string;
-            name: string;
-        }> | undefined;
-    }>]>, undefined>, v.ReadonlyAction<Readonly<{
-        name: string;
-        payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
-            id: string;
-            name: 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<{
-        readonly name: v.StringSchema<undefined>;
-        readonly kind: v.PicklistSchema<["option", "component", "collection", "detail"], undefined>;
-    }, undefined>, v.MetadataAction<{
-        name: string;
-        kind: "option" | "component" | "collection" | "detail";
-    }, {
-        readonly serialisable: typeof BuilderExpectation;
-        readonly instance: v.InstanceSchema<typeof BuilderExpectation, undefined>;
-    }>, v.ReadonlyAction<{
-        name: string;
-        kind: "option" | "component" | "collection" | "detail";
-    }>]>, undefined>, v.ReadonlyAction<Readonly<{
-        name: string;
-        kind: "option" | "component" | "collection" | "detail";
-    }>[]>]>;
-}, undefined>, v.MetadataAction<{
-    readonly references: readonly Readonly<{
-        type: "ref";
-        id: string;
-        name: string;
-    }>[];
-    readonly options: readonly Readonly<{
-        name: string;
-        payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
-            id: string;
-            name: string;
-        }> | undefined;
-    }>[];
-    readonly components: readonly Readonly<{
-        name: string;
-        payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
-            id: string;
-            name: string;
-        }> | undefined;
-    }>[];
-    readonly collections: readonly import("..").BuilderCollectionSerialised[];
-    readonly expectations: readonly Readonly<{
-        name: string;
-        kind: "option" | "component" | "collection" | "detail";
-    }>[];
-}, {
-    readonly serialisable: typeof Builder;
-    readonly instance: v.InstanceSchema<typeof Builder, undefined>;
-}>, v.ReadonlyAction<{
-    readonly references: readonly Readonly<{
-        type: "ref";
-        id: string;
-        name: string;
-    }>[];
-    readonly options: readonly Readonly<{
-        name: string;
-        payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
-            id: string;
-            name: string;
-        }> | undefined;
-    }>[];
-    readonly components: readonly Readonly<{
-        name: string;
-        payload: unknown;
-        gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-            type: "ref";
-            id: string;
-            name: string;
-        }> | undefined;
-    }>[];
-    readonly collections: readonly import("..").BuilderCollectionSerialised[];
-    readonly expectations: readonly Readonly<{
-        name: string;
-        kind: "option" | "component" | "collection" | "detail";
-    }>[];
-}>]>;
-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 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 interface BuilderSerialised {
+    readonly model: v.InferOutput<typeof BuilderModelSerialisedSchema>;
+    readonly ui: v.InferOutput<typeof BuilderUISerialisedSchema>;
+    readonly bindings: BuilderBindingsSerialised;
+}
+export declare const BuilderSerialisedSchema: v.GenericSchema<BuilderSerialised>;