@builder-builder/builder 0.0.10 → 0.0.11

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

@@ -0,0 +1,83 @@
+import type { BuilderPaths } from '../../paths';
+import type { BuilderParameter, BuilderRef, Paramable } from '../../references';
+import type { BuilderCollectionConfig, BuilderCollectionPayload } from '../collection/index';
+import type { BuilderComponentPayload } from '../component/index';
+import type { BuilderOptionPayload } from '../option/index';
+import type { BuilderWhenConstrained, BuilderWhenGeneric, WhenConfigNullable } from '../when';
+import type { BuilderModelGeneric } from './model';
+import type { BuilderModels } from './models';
+import type { BuilderModelState, BuilderModelStateAppend } from './state';
+export type BuilderModelBindings<State extends BuilderModelState> = {
+    readonly [Name in BuilderModelPartsNamesOf<State['models']> | ParameterNamesOf<State['options']> | ParameterNamesOf<State['collections']> | ParameterNamesOf<State['components']> | CollectionConfigParameterNamesOf<State['collections']>]?: BuilderWhenConstrained<State, PayloadForParameter<State, Name>> | BuilderRef;
+};
+export type BuilderModelBoundState<State extends BuilderModelState, Bindings extends BuilderModelBindings<State>> = BuilderModelStateAppend<State, {
+    options: EntryBound<State['options'], Bindings>;
+    collections: EntryBound<State['collections'], Bindings>;
+    components: EntryBound<State['components'], Bindings>;
+    instance: Omit<State['instance'], keyof Bindings> & {
+        [Key in Extract<keyof Bindings, string>]: BoundInstance<Bindings[Key]>;
+    };
+}>;
+type BoundInstance<Binding> = Binding extends BuilderRef ? unknown : BoundValue<Binding> | BoundConfigNullable<Binding>;
+type BoundValue<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 BoundConfigNullable<Binding> = Binding extends BuilderWhenGeneric ? WhenConfigNullable<Binding> : never;
+type EntryLike = {
+    readonly name: string;
+    readonly payload: unknown;
+    readonly paths?: 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> = ParameterInfo<Payload> | (Payload extends {
+    readonly type: 'match';
+    readonly selectMap: infer SelectMap;
+} ? ParameterInfo<SelectMap[keyof SelectMap]> : never) | (Payload extends {
+    readonly type: 'enable' | 'unless';
+    readonly payload: infer Inner;
+} ? ParameterInfo<Inner> : never);
+type ParameterInfo<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 BuilderModelState, Name extends string> = Name extends BuilderModelPartsNamesOf<State['models']> ? BuilderModelGeneric : 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 BuilderModelPartsNamesOf<Parts extends BuilderModels> = Extract<Parts[number], BuilderParameter>['name'];
+type CollectionConfigOf<Payload> = Payload extends BuilderCollectionConfig<infer Model, infer Min, infer Max> ? BuilderCollectionConfig<Model, 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 Model, infer Min, infer Max> ? CollectionConfigParameterInfo<Model, BuilderModelGeneric> | 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/model/expectation.d.ts

@@ -0,0 +1,16 @@
+import type { Prettify } from '../../prettify';
+import type { CollectionsAsserted } from '../collection/index';
+import type { ComponentAsserted } from '../component/index';
+import type { BuilderExpectation, BuilderExpectations } from '../expectation';
+import type { BuilderModelState, BuilderModelStateAppend } from './state';
+export type BuilderModelStateAsserted<State extends BuilderModelState, Expectations extends BuilderExpectations> = BuilderModelStateAppend<State, {
+    instance: InstanceAsserted<State, Expectations>;
+    components: ComponentAsserted<State, Expectations>;
+    collections: CollectionsAsserted<State, Expectations>;
+}>;
+type InstanceAsserted<State extends BuilderModelState, Expectations extends BuilderExpectations, Current extends State['instance'] = State['instance'], Asserted extends InstanceExpected<Expectations> = InstanceExpected<Expectations>> = unknown extends Current ? Prettify<Asserted> : Prettify<Current & Asserted>;
+type InstanceExpected<Expectations extends BuilderExpectations> = Expectations extends readonly [
+    infer Head,
+    ...infer Tail extends BuilderExpectations
+] ? (Head extends BuilderExpectation<infer Name, infer Value, 'option'> ? Record<Name, Value> : Head extends BuilderExpectation<infer Name, any, 'collection'> ? Record<Name, ReadonlyArray<unknown>> : unknown) & InstanceExpected<Tail> : unknown;
+export {};

package/dist/entities/model/index.d.ts

@@ -0,0 +1,7 @@
+export type { BuilderModelGeneric, BuilderInstanceOf, BuilderModelSerialised, BuilderModelStateOf } from './model';
+export type { BuilderModels } from './models';
+export type { BuilderModelStateAsserted } from './expectation';
+export type { BuilderModelBindings } from './bind';
+export type { BuilderModelState, BuilderModelStateEmpty } from './state';
+export { BuilderModel, BuilderModelSchema, BuilderModelSerialisedSchema, model } from './model.js';
+export { modelsMerge } from './models.js';

package/dist/entities/model/index.js

@@ -0,0 +1,2 @@
+export { BuilderModel, BuilderModelSchema, BuilderModelSerialisedSchema, model } from './model.js';
+export { modelsMerge } from './models.js';

package/dist/entities/model/methods.d.ts

@@ -0,0 +1,57 @@
+import type { BuilderPaths } from '../../paths';
+import type { BuilderParameter, Paramable } from '../../references';
+import type { BuilderCollectionConfig, BuilderCollectionWhen } from '../collection/index';
+import type { BuilderComponentDetails, BuilderComponentWhen } from '../component/index';
+import type { BuilderOptionValues, BuilderOptionWhen } from '../option/index';
+import type { BuilderValidPaths, BuilderWhenConstrained, WhenConfigPayload, WhenNullability } from '../when';
+import type { BuilderModel } from './model';
+import type { BuilderModelState, BuilderModelStateAppend } from './state';
+import { BuilderCollection } from '../collection/index.js';
+import { BuilderComponent } from '../component/index.js';
+import { BuilderOption } from '../option/index.js';
+export type BuilderOptionMethod<State extends BuilderModelState> = {
+    <const Name extends string, const Payload extends Paramable<BuilderOptionValues>>(name: Name, payload: Payload): OptionStateAppend<State, BuilderOption<Name, Payload>>;
+    when: <const Paths extends Paramable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Paramable<BuilderOptionWhen>>(paths: Paths, name: Name, payload: Payload & BuilderWhenConstrained<State, Payload>) => OptionStateAppend<State, OptionWhenResolver<Name, Payload>, OptionInstanceOf<OptionWhenResolver<Name, Payload>> | WhenNullability<State, Paths, Payload>>;
+};
+export type BuilderComponentMethod<State extends BuilderModelState> = {
+    <const Name extends string, const Payload extends Paramable<BuilderComponentDetails>>(name: Name, payload?: Payload): ComponentStateAppend<State, BuilderComponent<Name, Payload>>;
+    when: <const Paths extends Paramable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Paramable<BuilderComponentWhen>>(paths: Paths, name: Name, payload?: Payload & BuilderWhenConstrained<State, Payload>) => ComponentStateAppend<State, ComponentWhenResolver<Name, Payload>>;
+};
+export type BuilderCollectionMethod<State extends BuilderModelState> = {
+    <const Name extends string, const Payload extends Paramable<BuilderCollectionConfig>>(name: Name, payload: Payload): CollectionStateAppend<State, BuilderCollection<Name, Payload>>;
+    when: <const Paths extends Paramable<BuilderValidPaths<State>>, const Name extends string, const Payload extends Paramable<BuilderCollectionWhen>>(paths: Paths, name: Name, payload: Payload & BuilderWhenConstrained<State, Payload>) => CollectionStateAppend<State, CollectionWhenResolver<Name, Payload>, CollectionInstanceOf<CollectionWhenResolver<Name, Payload>> | WhenNullability<State, Paths, Payload>>;
+};
+type OptionWhenResolver<Name extends string, Payload extends Paramable<BuilderOptionWhen>> = Payload extends BuilderOptionWhen ? BuilderOption<Name, WhenConfigPayload<Payload, BuilderOptionValues>> : BuilderOption<Name, BuilderParameter>;
+type ComponentWhenResolver<Name extends string, Payload extends Paramable<BuilderComponentWhen>> = Payload extends BuilderComponentWhen ? BuilderComponent<Name, WhenConfigPayload<Payload, BuilderComponentDetails>> : BuilderComponent<Name, BuilderParameter>;
+type CollectionWhenResolver<Name extends string, Payload extends Paramable<BuilderCollectionWhen>> = Payload extends BuilderCollectionWhen ? BuilderCollection<Name, WhenConfigPayload<Payload, BuilderCollectionConfig>> : BuilderCollection<Name, BuilderParameter>;
+type OptionStateAppend<State extends BuilderModelState, Option extends BuilderOption, InstanceType = OptionInstanceOf<Option>> = BuilderModel<BuilderModelStateAppend<State, {
+    instance: State['instance'] & {
+        [K in Option['name']]: InstanceType;
+    };
+    options: [...State['options'], Option];
+}>>;
+type ComponentStateAppend<State extends BuilderModelState, Component extends BuilderComponent> = BuilderModel<BuilderModelStateAppend<State, {
+    components: [...State['components'], Component];
+}>>;
+type CollectionStateAppend<State extends BuilderModelState, Collection extends BuilderCollection, InstanceType = CollectionInstanceOf<Collection>> = BuilderModel<BuilderModelStateAppend<State, {
+    instance: State['instance'] & Record<Collection['name'], InstanceType>;
+    collections: [...State['collections'], Collection];
+}>>;
+type OptionInstanceOf<Option extends BuilderOption> = Option['payload'] extends BuilderParameter ? string : Option['payload'] extends {
+    readonly value: infer Value;
+} ? Value : never;
+type CollectionInstanceOf<Collection extends BuilderCollection> = [Collection['payload']] extends [
+    never
+] ? null : Collection['payload'] extends BuilderCollectionConfig ? Collection['payload']['model'] extends BuilderModel<infer State extends BuilderModelState> ? CollectionShape<Collection, State['instance']> : ReadonlyArray<unknown> : ReadonlyArray<unknown>;
+type CollectionShape<Collection extends BuilderCollection, Item> = Collection['payload'] extends BuilderCollectionConfig ? Collection['payload']['min'] extends number ? Collection['payload']['max'] extends number ? number extends Collection['payload']['min'] ? ReadonlyArray<Item> : number extends Collection['payload']['max'] ? ReadonlyArray<Item> : Collection['payload']['min'] extends Collection['payload']['max'] ? CollectionTuple<Item, Collection['payload']['min']> : ReadonlyArray<Item> : ReadonlyArray<Item> : ReadonlyArray<Item> : ReadonlyArray<Item>;
+type CollectionTuple<Item, Length extends number, Result extends ReadonlyArray<Item> = []> = Result['length'] extends Length ? Result : CollectionTuple<Item, Length, [...Result, Item]>;
+export declare function builderOptionMethod(): ((name: string, payload: Paramable<BuilderOptionValues>) => BuilderOption<string, Paramable<import("..").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("..").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, Paramable<readonly (readonly (string | number)[])[]>>) & {
+    when(paths: Paramable<BuilderPaths>, name: string, payload: Paramable<BuilderOptionWhen>): BuilderOption<string, Paramable<BuilderOptionWhen>, readonly (readonly (string | number)[])[] | import("../..").BuilderRef | BuilderParameter<string>>;
+};
+export declare function builderComponentMethod(): ((name: string, payload?: Paramable<BuilderComponentDetails>) => BuilderComponent<string, Paramable<BuilderComponentDetails<Paramable<readonly import("..").BuilderComponentField<string, import("valibot").GenericSchema<string | number | boolean | null>>[]>>>, Paramable<readonly (readonly (string | number)[])[]>>) & {
+    when(paths: Paramable<BuilderPaths>, name: string, payload?: Paramable<BuilderComponentWhen>): BuilderComponent<string, Paramable<BuilderComponentWhen>, readonly (readonly (string | number)[])[] | import("../..").BuilderRef | BuilderParameter<string>>;
+};
+export declare function builderCollectionMethod(): ((name: string, payload: Paramable<BuilderCollectionConfig>) => BuilderCollection<string, Paramable<BuilderCollectionConfig<Paramable<import("./model").BuilderModelGeneric>, Paramable<number>, Paramable<number>>>, Paramable<readonly (readonly (string | number)[])[]>>) & {
+    when(paths: Paramable<BuilderPaths>, name: string, payload: Paramable<BuilderCollectionWhen>): BuilderCollection<string, Paramable<BuilderCollectionWhen>, readonly (readonly (string | number)[])[] | import("../..").BuilderRef | BuilderParameter<string>>;
+};
+export {};

package/dist/entities/{builder → model}/methods.js

@@ -1,21 +1,21 @@
 import { BuilderCollection } from '../collection/index.js';
-import { BuilderComponent, componentWhen } from '../component/index.js';
+import { BuilderComponent, componentDetails, componentWhen } from '../component/index.js';
 import { BuilderOption } from '../option/index.js';
 export function builderOptionMethod() {
     return Object.assign((name, payload) => {
         return new BuilderOption(name, payload);
     }, {
-        when(gatePaths, name, payload) {
-            return new BuilderOption(name, payload, gatePaths);
+        when(paths, name, payload) {
+            return new BuilderOption(name, payload, paths);
         }
     });
 }
 export function builderComponentMethod() {
     return Object.assign((name, payload) => {
-        return new BuilderComponent(name, payload ?? componentWhen.enable());
+        return new BuilderComponent(name, payload ?? componentDetails());
     }, {
-        when(gatePaths, name, payload) {
-            return new BuilderComponent(name, payload ?? componentWhen.enable(), gatePaths);
+        when(paths, name, payload) {
+            return new BuilderComponent(name, payload ?? componentWhen.enable(), paths);
         }
     });
 }
@@ -23,8 +23,8 @@ export function builderCollectionMethod() {
     return Object.assign((name, payload) => {
         return new BuilderCollection(name, payload);
     }, {
-        when(gatePaths, name, payload) {
-            return new BuilderCollection(name, payload, gatePaths);
+        when(paths, name, payload) {
+            return new BuilderCollection(name, payload, paths);
         }
     });
 }

package/dist/entities/model/model.d.ts

@@ -0,0 +1,39 @@
+import type { Prettify } from '../../prettify';
+import type { Paramable } from '../../references';
+import type { Builder } from '../builder/index';
+import type { BuilderCollections, BuilderCollectionsSerialised } from '../collection/index';
+import type { BuilderComponents, BuilderComponentsSerialised } from '../component/index';
+import type { BuilderExpectation, BuilderExpectations, BuilderExpectationsSerialised } from '../expectation';
+import type { BuilderOptions, BuilderOptionsSerialised } from '../option/index';
+import type { BuilderModelStateAsserted } from './expectation';
+import type { BuilderCollectionMethod, BuilderComponentMethod, BuilderOptionMethod } from './methods';
+import type { BuilderModels, BuilderModelsMerge, BuilderModelsSerialised } from './models';
+import type { BuilderModelState, BuilderModelStateEmpty } from './state';
+import * as v from 'valibot';
+export declare class BuilderModel<State extends BuilderModelState = BuilderModelStateEmpty> {
+    #private;
+    readonly type: 'model';
+    readonly models: State['models'];
+    readonly options: State['options'];
+    readonly components: State['components'];
+    readonly collections: State['collections'];
+    readonly expectations: BuilderExpectations;
+    constructor(models?: BuilderModels, 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): BuilderModel<BuilderModelStateAsserted<State, Expectations>>;
+}
+export declare function model<const Parts extends BuilderModels>(...parts: Parts): BuilderModel<BuilderModelsMerge<Parts>>;
+export type BuilderModelGeneric = BuilderModel<BuilderModelState>;
+export declare const BuilderModelSchema: v.InstanceSchema<typeof BuilderModel, undefined>;
+export interface BuilderModelSerialised {
+    readonly models: BuilderModelsSerialised;
+    readonly options: BuilderOptionsSerialised;
+    readonly components: BuilderComponentsSerialised;
+    readonly collections: BuilderCollectionsSerialised;
+    readonly expectations: BuilderExpectationsSerialised;
+}
+export declare const BuilderModelSerialisedSchema: v.GenericSchema<BuilderModelSerialised>;
+export type BuilderModelStateOf<Input extends Paramable<BuilderModelGeneric>> = Input extends BuilderModel<infer State extends BuilderModelState> ? State : BuilderModelStateEmpty;
+export type BuilderInstanceOf<Input> = Input extends BuilderModel<infer State extends BuilderModelState> ? Prettify<State['instance']> : Input extends Builder<infer State extends BuilderModelState> ? Prettify<State['instance']> : never;

package/dist/entities/model/model.js

@@ -0,0 +1,73 @@
+import * as v from 'valibot';
+import { serialisable } from '../../serialisable.js';
+import { BuilderCollectionsSerialisedSchema } from '../collection/index.js';
+import { BuilderComponentsSerialisedSchema } from '../component/index.js';
+import { BuilderExpectationsSerialisedSchema } from '../expectation.js';
+import { BuilderOptionsSerialisedSchema } from '../option/index.js';
+import { builderCollectionMethod, builderComponentMethod, builderOptionMethod } from './methods.js';
+import { BuilderModelsSerialisedSchema } from './models.js';
+export class BuilderModel {
+    models;
+    options;
+    components;
+    collections;
+    expectations;
+    constructor(models = [], options = [], components = [], collections = [], expectations = []) {
+        this.models = models;
+        this.options = options;
+        this.components = components;
+        this.collections = collections;
+        this.expectations = expectations;
+    }
+    get option() {
+        const method = builderOptionMethod();
+        const add = (name, payload) => {
+            return this.#next({ options: [...this.options, method(name, payload)] });
+        };
+        const when = (paths, name, config) => {
+            return this.#next({ options: [...this.options, method.when(paths, name, config)] });
+        };
+        return Object.assign(add, { when });
+    }
+    get component() {
+        const method = builderComponentMethod();
+        const add = (name, details) => {
+            return this.#next({ components: [...this.components, method(name, details)] });
+        };
+        const when = (paths, name, config) => {
+            return this.#next({
+                components: [...this.components, method.when(paths, name, config)]
+            });
+        };
+        return Object.assign(add, { when });
+    }
+    get collection() {
+        const method = builderCollectionMethod();
+        const add = (name, payload) => {
+            return this.#next({ collections: [...this.collections, method(name, payload)] });
+        };
+        const when = (paths, name, config) => {
+            return this.#next({
+                collections: [...this.collections, method.when(paths, name, config)]
+            });
+        };
+        return Object.assign(add, { when });
+    }
+    expect(...expectations) {
+        return this.#next({ expectations: [...this.expectations, ...expectations] });
+    }
+    #next(patch) {
+        return new BuilderModel(this.models, patch.options ?? this.options, patch.components ?? this.components, patch.collections ?? this.collections, patch.expectations ?? this.expectations);
+    }
+}
+export function model(...parts) {
+    return new BuilderModel(parts, [], [], [], []);
+}
+export const BuilderModelSchema = v.instance(BuilderModel);
+export const BuilderModelSerialisedSchema = serialisable(v.object({
+    models: BuilderModelsSerialisedSchema,
+    options: BuilderOptionsSerialisedSchema,
+    components: BuilderComponentsSerialisedSchema,
+    collections: BuilderCollectionsSerialisedSchema,
+    expectations: BuilderExpectationsSerialisedSchema
+}));

package/dist/entities/model/models.d.ts

@@ -0,0 +1,39 @@
+import type { Paramable, ParamableSerialised } from '../../references';
+import type { BuilderModelValidated } from '../validated';
+import type { BuilderModelGeneric, BuilderModelSerialised, BuilderModelStateOf } from './model';
+import type { BuilderModelStateAppend, BuilderModelStateEmpty } from './state';
+import * as v from 'valibot';
+export type BuilderModels = ReadonlyArray<Paramable<BuilderModelGeneric>>;
+export type BuilderModelsSerialised = ReadonlyArray<ParamableSerialised<BuilderModelSerialised>>;
+export declare const BuilderModelsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[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: "parameter";
+    id: string;
+    name: string;
+}>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"ref", undefined>;
+    readonly id: v.StringSchema<undefined>;
+}, undefined>, v.ReadonlyAction<{
+    type: "ref";
+    id: string;
+}>]>, v.LazySchema<v.GenericSchema<BuilderModelSerialised>>], undefined>, undefined>, v.ReadonlyAction<(Readonly<{
+    type: "parameter";
+    id: string;
+    name: string;
+}> | Readonly<{
+    type: "ref";
+    id: string;
+}> | BuilderModelSerialised)[]>]>;
+export type BuilderModelsMerge<Parts extends BuilderModels> = BuilderModelStateAppend<BuilderModelStateEmpty, {
+    instance: BuilderModelsInstanceMerge<Parts>;
+    models: Parts;
+}>;
+type BuilderModelsInstanceMerge<Parts extends BuilderModels> = Parts extends readonly [
+    infer Head,
+    ...infer Tail extends BuilderModels
+] ? Head extends BuilderModelGeneric ? BuilderModelStateOf<Head>['instance'] & BuilderModelsInstanceMerge<Tail> : BuilderModelsInstanceMerge<Tail> : unknown;
+export declare function modelsMerge(model: BuilderModelValidated): BuilderModelValidated;
+export {};

package/dist/entities/model/models.js

@@ -0,0 +1,14 @@
+import * as v from 'valibot';
+import { paramable } from '../../references.js';
+import { BuilderModelSerialisedSchema } from './model.js';
+export const BuilderModelsSerialisedSchema = v.pipe(v.array(paramable(v.lazy(() => BuilderModelSerialisedSchema))), v.readonly());
+export function modelsMerge(model) {
+    const merged = model.models.map(modelsMerge);
+    return {
+        models: [],
+        options: [...model.options, ...merged.flatMap((nested) => nested.options)],
+        components: [...model.components, ...merged.flatMap((nested) => nested.components)],
+        collections: [...model.collections, ...merged.flatMap((nested) => nested.collections)],
+        expectations: [...model.expectations, ...merged.flatMap((nested) => nested.expectations)]
+    };
+}

package/dist/entities/{builder → model}/state.d.ts

@@ -1,25 +1,25 @@
 import type { Prettify } from '../../prettify';
-import type { BuilderParameters } from '../../references';
 import type { BuilderCollections } from '../collection/index';
 import type { BuilderComponents } from '../component/index';
 import type { BuilderOptions } from '../option/index';
-export type BuilderState = {
-    model: unknown;
-    parameters: BuilderParameters;
+import type { BuilderModels } from './models';
+export type BuilderModelState = {
+    instance: unknown;
+    models: BuilderModels;
     options: BuilderOptions;
     components: BuilderComponents;
     collections: BuilderCollections;
 };
-export type BuilderStateEmpty = {
-    readonly model: unknown;
-    readonly parameters: [];
+export type BuilderModelStateEmpty = {
+    readonly instance: unknown;
+    readonly models: [];
     readonly options: [];
     readonly components: [];
     readonly collections: [];
 };
-export type BuilderStateAppend<State extends BuilderState, Patch extends Partial<BuilderState>> = {
-    model: Prettify<'model' extends keyof Patch ? Patch['model'] : State['model']>;
-    parameters: 'parameters' extends keyof Patch ? Extract<Patch['parameters'], BuilderParameters> : State['parameters'];
+export type BuilderModelStateAppend<State extends BuilderModelState, Patch extends Partial<BuilderModelState>> = {
+    instance: Prettify<'instance' extends keyof Patch ? Patch['instance'] : State['instance']>;
+    models: Extract<'models' extends keyof Patch ? Patch['models'] : State['models'], BuilderModels>;
     options: Extract<'options' extends keyof Patch ? Patch['options'] : State['options'], BuilderOptions>;
     components: Extract<'components' extends keyof Patch ? Patch['components'] : State['components'], BuilderComponents>;
     collections: Extract<'collections' extends keyof Patch ? Patch['collections'] : State['collections'], BuilderCollections>;

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

@@ -6,6 +6,6 @@ export type { BuilderOptionWhen } from './when';
 export { BuilderOption, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionWhenSerialisedSchema } from './option.js';
 export { BuilderSelectType, BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, select } from './select.js';
 export { BuilderToggleType, BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema, toggleBoolean, toggleNumber, toggleString } from './toggle.js';
-export { BuilderOptionValuesSchema, BuilderOptionValuesSerialisedSchema } from './values.js';
+export { BuilderOptionValuesSchema, BuilderOptionValuesSerialisedSchema, optionValueSchema } from './values.js';
 export { optionExpectation } from './expectation.js';
 export { optionWhen } from './when.js';

package/dist/entities/option/index.js

@@ -1,6 +1,6 @@
 export { BuilderOption, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionWhenSerialisedSchema } from './option.js';
 export { BuilderSelectType, BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, select } from './select.js';
 export { BuilderToggleType, BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema, toggleBoolean, toggleNumber, toggleString } from './toggle.js';
-export { BuilderOptionValuesSchema, BuilderOptionValuesSerialisedSchema } from './values.js';
+export { BuilderOptionValuesSchema, BuilderOptionValuesSerialisedSchema, optionValueSchema } from './values.js';
 export { optionExpectation } from './expectation.js';
 export { optionWhen } from './when.js';