@builder-builder/builder 0.0.19 → 0.0.20

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

@@ -1,8 +1,8 @@
 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 { BuilderComponentConfig, BuilderComponentWhen } from '../component/index';
+import type { BuilderOptionConfig, BuilderOptionWhen } from '../option/index';
 import type { BuilderValidPaths, BuilderWhenConstrained, WhenConfigPayload, WhenNullability } from '../when';
 import type { BuilderModel } from './model';
 import type { BuilderModelState, BuilderModelStateAppend } from './state';
@@ -10,19 +10,19 @@ 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>>;
+    <const Name extends string, const Payload extends Paramable<BuilderOptionConfig>>(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>>;
+    <const Name extends string, const Payload extends Paramable<BuilderComponentConfig>>(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 OptionWhenResolver<Name extends string, Payload extends Paramable<BuilderOptionWhen>> = Payload extends BuilderOptionWhen ? BuilderOption<Name, WhenConfigPayload<Payload, BuilderOptionConfig>> : BuilderOption<Name, BuilderParameter>;
+type ComponentWhenResolver<Name extends string, Payload extends Paramable<BuilderComponentWhen>> = Payload extends BuilderComponentWhen ? BuilderComponent<Name, WhenConfigPayload<Payload, BuilderComponentConfig>> : 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'] & {
@@ -45,10 +45,10 @@ type CollectionInstanceOf<Collection extends BuilderCollection> = [Collection['p
 ] ? 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)[])[]>>) & {
+export declare function builderOptionMethod(): ((name: string, payload: Paramable<BuilderOptionConfig>) => BuilderOption<string, Paramable<import("..").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("..").BuilderToggleConfig<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)[])[] | BuilderParameter<string> | import("../..").BuilderRef>;
 };
-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)[])[]>>) & {
+export declare function builderComponentMethod(): ((name: string, payload?: Paramable<BuilderComponentConfig>) => BuilderComponent<string, Paramable<BuilderComponentConfig<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)[])[] | BuilderParameter<string> | import("../..").BuilderRef>;
 };
 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)[])[]>>) & {

package/dist/entities/model/methods.js

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

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

@@ -35,5 +35,5 @@ type BuilderModelsInstanceMerge<Parts extends BuilderModels> = Parts extends rea
     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 declare function modelsMerge<Model extends BuilderModelSerialised | BuilderModelValidated>(model: Model): Model;
 export {};

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

@@ -0,0 +1,109 @@
+import * as v from 'valibot';
+export declare const BuilderOptionConfigSchema: v.UnionSchema<[v.InstanceSchema<typeof import("./select.js").BuilderSelectConfig, undefined>, v.InstanceSchema<typeof import("./toggle.js").BuilderToggleConfig, undefined>], undefined>;
+export type BuilderOptionConfig = v.InferOutput<typeof BuilderOptionConfigSchema>;
+export declare const BuilderOptionConfigSerialisedSchema: 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>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
+}, undefined>, v.ReadonlyAction<{
+    type: "select";
+    readonly options: readonly [string, ...string[]];
+    defaultValue: string | null;
+    isOptional: boolean;
+    optionLabels: {
+        [x: string]: string;
+    };
+    tags?: readonly string[] | undefined;
+}>]>, 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>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
+}, undefined>, v.ReadonlyAction<{
+    type: "toggle";
+    valueType: "string" | "number" | "boolean";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+    tags?: readonly string[] | undefined;
+}>]>], undefined>, v.ReadonlyAction<Readonly<{
+    type: "select";
+    readonly options: readonly [string, ...string[]];
+    defaultValue: string | null;
+    isOptional: boolean;
+    optionLabels: {
+        [x: string]: string;
+    };
+    tags?: readonly string[] | undefined;
+}> | Readonly<{
+    type: "toggle";
+    valueType: "string" | "number" | "boolean";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+    tags?: readonly string[] | undefined;
+}>>]>;
+export type BuilderOptionConfigSerialised = v.InferOutput<typeof BuilderOptionConfigSerialisedSchema>;
+export declare const BuilderOptionConfigsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<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>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
+}, undefined>, v.ReadonlyAction<{
+    type: "select";
+    readonly options: readonly [string, ...string[]];
+    defaultValue: string | null;
+    isOptional: boolean;
+    optionLabels: {
+        [x: string]: string;
+    };
+    tags?: readonly string[] | undefined;
+}>]>, 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>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
+}, undefined>, v.ReadonlyAction<{
+    type: "toggle";
+    valueType: "string" | "number" | "boolean";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+    tags?: readonly string[] | undefined;
+}>]>], undefined>, v.ReadonlyAction<Readonly<{
+    type: "select";
+    readonly options: readonly [string, ...string[]];
+    defaultValue: string | null;
+    isOptional: boolean;
+    optionLabels: {
+        [x: string]: string;
+    };
+    tags?: readonly string[] | undefined;
+}> | Readonly<{
+    type: "toggle";
+    valueType: "string" | "number" | "boolean";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+    tags?: readonly string[] | undefined;
+}>>]>, undefined>, v.ReadonlyAction<(Readonly<Readonly<{
+    type: "select";
+    readonly options: readonly [string, ...string[]];
+    defaultValue: string | null;
+    isOptional: boolean;
+    optionLabels: {
+        [x: string]: string;
+    };
+    tags?: readonly string[] | undefined;
+}>> | Readonly<Readonly<{
+    type: "toggle";
+    valueType: "string" | "number" | "boolean";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+    tags?: readonly string[] | undefined;
+}>>)[]>]>;
+export type BuilderOptionConfigsSerialised = v.InferOutput<typeof BuilderOptionConfigsSerialisedSchema>;
+export declare function optionValueSchema(payload: BuilderOptionConfigSerialised): v.GenericSchema;

package/dist/entities/option/config.js

@@ -0,0 +1,15 @@
+import * as v from 'valibot';
+import { BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, selectValueSchema } from './select.js';
+import { BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, toggleValueSchema } from './toggle.js';
+export const BuilderOptionConfigSchema = v.union([
+    BuilderSelectConfigSchema,
+    BuilderToggleConfigSchema
+]);
+export const BuilderOptionConfigSerialisedSchema = v.pipe(v.variant('type', [BuilderSelectConfigSerialisedSchema, BuilderToggleConfigSerialisedSchema]), v.readonly());
+export const BuilderOptionConfigsSerialisedSchema = v.pipe(v.array(BuilderOptionConfigSerialisedSchema), v.readonly());
+export function optionValueSchema(payload) {
+    if (payload.type === 'select') {
+        return selectValueSchema(payload.options, payload.isOptional);
+    }
+    return toggleValueSchema(payload.valueType, payload.isOptional);
+}

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

@@ -1,11 +1,11 @@
 export type { BuilderOptionPayload, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionWhenSerialised } from './option';
-export type { BuilderSelectTypeLabels, BuilderSelectTypeSerialised, BuilderSelectTypeValues } from './select';
-export type { BuilderToggleTypeSerialised, BuilderToggleValueType } from './toggle';
-export type { BuilderOptionValues, BuilderOptionValuesSerialised } from './values';
+export type { BuilderSelectConfigLabels, BuilderSelectConfigSerialised, BuilderSelectConfigValues } from './select';
+export type { BuilderToggleConfigSerialised, BuilderToggleValueType } from './toggle';
+export type { BuilderOptionConfig, BuilderOptionConfigSerialised, BuilderOptionConfigsSerialised } from './config';
 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, optionValueSchema } from './values.js';
+export { BuilderSelectConfig, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, select } from './select.js';
+export { BuilderToggleConfig, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, toggleBoolean, toggleNumber, toggleString } from './toggle.js';
+export { BuilderOptionConfigSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionConfigsSerialisedSchema, optionValueSchema } from './config.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, optionValueSchema } from './values.js';
+export { BuilderSelectConfig, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, select } from './select.js';
+export { BuilderToggleConfig, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, toggleBoolean, toggleNumber, toggleString } from './toggle.js';
+export { BuilderOptionConfigSchema, BuilderOptionConfigSerialisedSchema, BuilderOptionConfigsSerialisedSchema, optionValueSchema } from './config.js';
 export { optionExpectation } from './expectation.js';
 export { optionWhen } from './when.js';

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

@@ -2,10 +2,10 @@ import type { BuilderPaths } from '../../paths';
 import type { Paramable } from '../../references';
 import type { BuilderTags } from '../tags';
 import type { BuilderWhenSerialised } from '../when';
-import type { BuilderOptionValues, BuilderOptionValuesSerialised } from './values';
+import type { BuilderOptionConfig, BuilderOptionConfigSerialised } from './config';
 import type { BuilderOptionWhen } from './when';
 import * as v from 'valibot';
-export type BuilderOptionPayload = BuilderOptionValues | BuilderOptionWhen;
+export type BuilderOptionPayload = BuilderOptionConfig | BuilderOptionWhen;
 export declare class BuilderOption<const Name extends string = string, const Payload extends Paramable<BuilderOptionPayload> = Paramable<BuilderOptionPayload>, const Paths extends Paramable<BuilderPaths> = Paramable<BuilderPaths>> {
     readonly type: 'option';
     readonly name: Name;
@@ -33,7 +33,7 @@ export declare const BuilderOptionWhenSerialisedSchema: v.GenericSchema<BuilderW
     isOptional: boolean;
     tags?: readonly string[] | undefined;
 }>>>>;
-export type BuilderOptionWhenSerialised = BuilderWhenSerialised<BuilderOptionValuesSerialised>;
+export type BuilderOptionWhenSerialised = BuilderWhenSerialised<BuilderOptionConfigSerialised>;
 export declare const BuilderOptionSelectMapSerialisedSchema: v.GenericSchema<import("..").BuilderMatchSelectMap<Readonly<{
     type: "parameter";
     id: string;

package/dist/entities/option/option.js

@@ -4,7 +4,7 @@ import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
 import { createSelectMapSerialisedSchema, createWhenSerialisedSchema } from '../when.js';
-import { BuilderOptionValuesSerialisedSchema } from './values.js';
+import { BuilderOptionConfigSerialisedSchema } from './config.js';
 export class BuilderOption {
     name;
     payload;
@@ -21,11 +21,11 @@ export class BuilderOption {
     }
 }
 export const BuilderOptionSchema = v.instance(BuilderOption);
-export const BuilderOptionWhenSerialisedSchema = createWhenSerialisedSchema(BuilderOptionValuesSerialisedSchema);
-export const BuilderOptionSelectMapSerialisedSchema = createSelectMapSerialisedSchema(BuilderOptionValuesSerialisedSchema);
+export const BuilderOptionWhenSerialisedSchema = createWhenSerialisedSchema(BuilderOptionConfigSerialisedSchema);
+export const BuilderOptionSelectMapSerialisedSchema = createSelectMapSerialisedSchema(BuilderOptionConfigSerialisedSchema);
 export const BuilderOptionSerialisedSchema = serialisable(v.object({
     name: v.string(),
-    payload: paramable(v.union([BuilderOptionValuesSerialisedSchema, BuilderOptionWhenSerialisedSchema])),
+    payload: paramable(v.union([BuilderOptionConfigSerialisedSchema, BuilderOptionWhenSerialisedSchema])),
     paths: v.optional(paramable(BuilderPathsSchema)),
     tags: v.optional(BuilderTagsSchema)
 }));

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

@@ -1,8 +1,8 @@
 import type { BuilderTags } from '../tags';
 import * as v from 'valibot';
-export type BuilderSelectTypeLabels<Values extends BuilderSelectTypeValues> = Partial<Record<Values[number], string>>;
-export type BuilderSelectTypeValues = readonly [string, ...ReadonlyArray<string>];
-export declare class BuilderSelectType<const Values extends BuilderSelectTypeValues = BuilderSelectTypeValues, const ValueSchema extends v.GenericSchema<string | null> = v.GenericSchema<string | null>> {
+export type BuilderSelectConfigLabels<Values extends BuilderSelectConfigValues> = Partial<Record<Values[number], string>>;
+export type BuilderSelectConfigValues = readonly [string, ...ReadonlyArray<string>];
+export declare class BuilderSelectConfig<const Values extends BuilderSelectConfigValues = BuilderSelectConfigValues, const ValueSchema extends v.GenericSchema<string | null> = v.GenericSchema<string | null>> {
     #private;
     readonly value: v.InferOutput<ValueSchema>;
     readonly type: "select";
@@ -10,20 +10,20 @@ export declare class BuilderSelectType<const Values extends BuilderSelectTypeVal
     readonly valueSchema: ValueSchema;
     readonly defaultValue: v.InferOutput<ValueSchema>;
     readonly isOptional: boolean;
-    readonly optionLabels: BuilderSelectTypeLabels<Values>;
+    readonly optionLabels: BuilderSelectConfigLabels<Values>;
     readonly tags?: BuilderTags;
-    constructor(values: Values, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, optionLabels?: BuilderSelectTypeLabels<Values>, tags?: BuilderTags);
-    default(newDefault: v.InferOutput<ValueSchema>): BuilderSelectType<Values, ValueSchema>;
-    optional(): BuilderSelectType<Values, v.NullableSchema<ValueSchema, undefined>>;
-    labels(optionLabels: BuilderSelectTypeLabels<Values>): BuilderSelectType<Values, ValueSchema>;
-    tag(...tags: Array<string>): BuilderSelectType<Values, ValueSchema>;
+    constructor(values: Values, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, optionLabels?: BuilderSelectConfigLabels<Values>, tags?: BuilderTags);
+    default(newDefault: v.InferOutput<ValueSchema>): BuilderSelectConfig<Values, ValueSchema>;
+    optional(): BuilderSelectConfig<Values, v.NullableSchema<ValueSchema, undefined>>;
+    labels(optionLabels: BuilderSelectConfigLabels<Values>): BuilderSelectConfig<Values, ValueSchema>;
+    tag(...tags: Array<string>): BuilderSelectConfig<Values, ValueSchema>;
 }
-type SelectSchema<Values extends BuilderSelectTypeValues> = v.UnionSchema<{
+type SelectSchema<Values extends BuilderSelectConfigValues> = v.UnionSchema<{
     [K in keyof Values]: v.LiteralSchema<Values[K], undefined>;
 }, undefined>;
-export declare function select<const Values extends BuilderSelectTypeValues>(values: Values): BuilderSelectType<Values, SelectSchema<Values>>;
-export declare const BuilderSelectTypeSchema: v.InstanceSchema<typeof BuilderSelectType, undefined>;
-export declare const BuilderSelectTypeSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+export declare function select<const Values extends BuilderSelectConfigValues>(values: Values): BuilderSelectConfig<Values, SelectSchema<Values>>;
+export declare const BuilderSelectConfigSchema: v.InstanceSchema<typeof BuilderSelectConfig, undefined>;
+export declare const BuilderSelectConfigSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"select", undefined>;
     readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
     readonly defaultValue: v.NullableSchema<v.StringSchema<undefined>, undefined>;
@@ -40,6 +40,6 @@ export declare const BuilderSelectTypeSerialisedSchema: v.SchemaWithPipe<readonl
     };
     tags?: readonly string[] | undefined;
 }>]>;
-export type BuilderSelectTypeSerialised = v.InferOutput<typeof BuilderSelectTypeSerialisedSchema>;
+export type BuilderSelectConfigSerialised = v.InferOutput<typeof BuilderSelectConfigSerialisedSchema>;
 export declare function selectValueSchema(options: ReadonlyArray<string>, optional: boolean): v.GenericSchema<string | null>;
 export {};

package/dist/entities/option/select.js

@@ -1,7 +1,7 @@
 import * as v from 'valibot';
 import { serialisable } from '../../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
-export class BuilderSelectType {
+export class BuilderSelectConfig {
     type = 'select';
     options;
     valueSchema;
@@ -18,7 +18,7 @@ export class BuilderSelectType {
         this.tags = tags;
     }
     #next(patch) {
-        return new BuilderSelectType(this.options, 'defaultValue' in patch
+        return new BuilderSelectConfig(this.options, 'defaultValue' in patch
             ? patch.defaultValue
             : this.defaultValue, patch.optional ?? this.isOptional, patch.optionLabels ?? this.optionLabels, patch.tags ?? this.tags);
     }
@@ -37,10 +37,10 @@ export class BuilderSelectType {
 }
 export function select(values) {
     const [defaultValue] = values;
-    return new BuilderSelectType(values, defaultValue, false);
+    return new BuilderSelectConfig(values, defaultValue, false);
 }
-export const BuilderSelectTypeSchema = v.instance(BuilderSelectType);
-export const BuilderSelectTypeSerialisedSchema = serialisable(v.object({
+export const BuilderSelectConfigSchema = v.instance(BuilderSelectConfig);
+export const BuilderSelectConfigSerialisedSchema = serialisable(v.object({
     type: v.literal('select'),
     options: v.pipe(v.tupleWithRest([v.string()], v.string()), v.readonly()),
     defaultValue: v.nullable(v.string()),

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

@@ -3,7 +3,7 @@ import type { BuilderTags } from '../tags';
 import * as v from 'valibot';
 export declare const BuilderToggleValueTypeSchema: v.PicklistSchema<["string", "boolean", "number"], undefined>;
 export type BuilderToggleValueType = v.InferOutput<typeof BuilderToggleValueTypeSchema>;
-export declare class BuilderToggleType<const ValueSchema extends v.GenericSchema<BuilderPrimitive> = v.GenericSchema<BuilderPrimitive>> {
+export declare class BuilderToggleConfig<const ValueSchema extends v.GenericSchema<BuilderPrimitive> = v.GenericSchema<BuilderPrimitive>> {
     #private;
     readonly value: v.InferOutput<ValueSchema>;
     readonly type: "toggle";
@@ -13,15 +13,15 @@ export declare class BuilderToggleType<const ValueSchema extends v.GenericSchema
     readonly isOptional: boolean;
     readonly tags?: BuilderTags;
     constructor(valueType: BuilderToggleValueType, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, tags?: BuilderTags);
-    default(newDefault: v.InferOutput<ValueSchema>): BuilderToggleType<ValueSchema>;
-    optional(): BuilderToggleType<v.NullableSchema<ValueSchema, undefined>>;
-    tag(...tags: Array<string>): BuilderToggleType<ValueSchema>;
+    default(newDefault: v.InferOutput<ValueSchema>): BuilderToggleConfig<ValueSchema>;
+    optional(): BuilderToggleConfig<v.NullableSchema<ValueSchema, undefined>>;
+    tag(...tags: Array<string>): BuilderToggleConfig<ValueSchema>;
 }
-export declare function toggleString(): BuilderToggleType<v.StringSchema<undefined>>;
-export declare function toggleBoolean(): BuilderToggleType<v.BooleanSchema<undefined>>;
-export declare function toggleNumber(): BuilderToggleType<v.NumberSchema<undefined>>;
-export declare const BuilderToggleTypeSchema: v.InstanceSchema<typeof BuilderToggleType, undefined>;
-export declare const BuilderToggleTypeSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+export declare function toggleString(): BuilderToggleConfig<v.StringSchema<undefined>>;
+export declare function toggleBoolean(): BuilderToggleConfig<v.BooleanSchema<undefined>>;
+export declare function toggleNumber(): BuilderToggleConfig<v.NumberSchema<undefined>>;
+export declare const BuilderToggleConfigSchema: v.InstanceSchema<typeof BuilderToggleConfig, undefined>;
+export declare const BuilderToggleConfigSerialisedSchema: 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>;
@@ -34,5 +34,5 @@ export declare const BuilderToggleTypeSerialisedSchema: v.SchemaWithPipe<readonl
     isOptional: boolean;
     tags?: readonly string[] | undefined;
 }>]>;
-export type BuilderToggleTypeSerialised = v.InferOutput<typeof BuilderToggleTypeSerialisedSchema>;
+export type BuilderToggleConfigSerialised = v.InferOutput<typeof BuilderToggleConfigSerialisedSchema>;
 export declare function toggleValueSchema(valueType: BuilderToggleValueType, optional: boolean): v.GenericSchema;

package/dist/entities/option/toggle.js

@@ -2,7 +2,7 @@ import * as v from 'valibot';
 import { serialisable } from '../../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
 export const BuilderToggleValueTypeSchema = v.picklist(['string', 'boolean', 'number']);
-export class BuilderToggleType {
+export class BuilderToggleConfig {
     type = 'toggle';
     valueType;
     valueSchema;
@@ -17,7 +17,7 @@ export class BuilderToggleType {
         this.tags = tags;
     }
     #next(patch) {
-        return new BuilderToggleType(this.valueType, 'defaultValue' in patch
+        return new BuilderToggleConfig(this.valueType, 'defaultValue' in patch
             ? patch.defaultValue
             : this.defaultValue, patch.optional ?? this.isOptional, patch.tags ?? this.tags);
     }
@@ -32,16 +32,16 @@ export class BuilderToggleType {
     }
 }
 export function toggleString() {
-    return new BuilderToggleType('string', '');
+    return new BuilderToggleConfig('string', '');
 }
 export function toggleBoolean() {
-    return new BuilderToggleType('boolean', false);
+    return new BuilderToggleConfig('boolean', false);
 }
 export function toggleNumber() {
-    return new BuilderToggleType('number', 0);
+    return new BuilderToggleConfig('number', 0);
 }
-export const BuilderToggleTypeSchema = v.instance(BuilderToggleType);
-export const BuilderToggleTypeSerialisedSchema = serialisable(v.object({
+export const BuilderToggleConfigSchema = v.instance(BuilderToggleConfig);
+export const BuilderToggleConfigSerialisedSchema = serialisable(v.object({
     type: v.literal('toggle'),
     valueType: BuilderToggleValueTypeSchema,
     defaultValue: v.nullable(v.union([v.boolean(), v.string(), v.number()])),

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

@@ -1,10 +1,10 @@
 import type { BuilderPath } from '../../paths';
 import type { Paramable } from '../../references';
 import type { BuilderWhen } from '../when';
-import type { BuilderOptionValues } from './values';
-export type BuilderOptionWhen = BuilderWhen<Paramable<BuilderOptionValues>, Paramable<BuilderPath>, Paramable<Record<string, Paramable<BuilderOptionValues> | null>>, Paramable<BuilderPath>>;
+import type { BuilderOptionConfig } from './config';
+export type BuilderOptionWhen = BuilderWhen<Paramable<BuilderOptionConfig>, Paramable<BuilderPath>, Paramable<Record<string, Paramable<BuilderOptionConfig> | null>>, Paramable<BuilderPath>>;
 export declare const optionWhen: {
-    enable: <const Values extends Paramable<import("./select").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>>(values: Values) => import("..").BuilderEnableConfig<Values>;
-    match: <const MatchPayload extends Paramable<import("./select").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends Paramable<BuilderPath>, const SelectMap extends Paramable<import("..").BuilderMatchSelectMap<Paramable<import("./select").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("..").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends Paramable<import("./select").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends Paramable<BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("../..").BuilderPrimitives, values: Values) => import("..").BuilderUnlessConfig<Values, UnlessPath>;
+    enable: <const Values extends Paramable<import("./select").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>(values: Values) => import("..").BuilderEnableConfig<Values>;
+    match: <const MatchPayload extends Paramable<import("./select").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends Paramable<BuilderPath>, const SelectMap extends Paramable<import("..").BuilderMatchSelectMap<Paramable<import("./select").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("..").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends Paramable<import("./select").BuilderSelectConfig<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleConfig<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends Paramable<BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("../..").BuilderPrimitives, values: Values) => import("..").BuilderUnlessConfig<Values, UnlessPath>;
 };

package/dist/entities/{refs.d.ts → references.d.ts}

@@ -1,6 +1,6 @@
 import type { BuilderEntitySerialised } from './kind.js';
-export type BuilderRefEntity = {
+export type BuilderReference = {
     readonly id: string;
     readonly serialised: BuilderEntitySerialised;
 };
-export type BuilderRefEntities = ReadonlyArray<BuilderRefEntity>;
+export type BuilderReferences = ReadonlyArray<BuilderReference>;

package/dist/entities/serialise.d.ts

@@ -9,7 +9,7 @@ export declare const entitiesMap: {
         readonly serialised: v.GenericSchema<import("./index.js").BuilderModelSerialised>;
     };
     readonly select: {
-        readonly runtime: v.InstanceSchema<typeof import("./index.js").BuilderSelectType, undefined>;
+        readonly runtime: v.InstanceSchema<typeof import("./index.js").BuilderSelectConfig, undefined>;
         readonly serialised: v.SchemaWithPipe<readonly [v.ObjectSchema<{
             readonly type: v.LiteralSchema<"select", undefined>;
             readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
@@ -29,7 +29,7 @@ export declare const entitiesMap: {
         }>]>;
     };
     readonly toggle: {
-        readonly runtime: v.InstanceSchema<typeof import("./index.js").BuilderToggleType, undefined>;
+        readonly runtime: v.InstanceSchema<typeof import("./index.js").BuilderToggleConfig, undefined>;
         readonly serialised: v.SchemaWithPipe<readonly [v.ObjectSchema<{
             readonly type: v.LiteralSchema<"toggle", undefined>;
             readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
@@ -120,8 +120,8 @@ export declare const entitiesMap: {
             tags?: readonly string[] | undefined;
         }>>>>;
     };
-    readonly componentDetails: {
-        readonly runtime: v.InstanceSchema<typeof import("./index.js").BuilderComponentDetails, undefined>;
+    readonly componentConfig: {
+        readonly runtime: v.InstanceSchema<typeof import("./index.js").BuilderComponentConfig, undefined>;
         readonly serialised: v.SchemaWithPipe<readonly [v.ObjectSchema<{
             readonly fields: v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
                 readonly type: v.LiteralSchema<"parameter", undefined>;

package/dist/entities/serialise.js

@@ -4,17 +4,17 @@ import { BuilderPathSchema, BuilderPathsSchema } from '../paths.js';
 import { BuilderParameterSchema, BuilderRefSchema, isParamable } from '../references.js';
 import { BuilderSchema, BuilderSerialisedSchema } from './builder/index.js';
 import { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionWhenSerialisedSchema } from './collection/index.js';
-import { BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentWhenSerialisedSchema } from './component/index.js';
+import { BuilderComponentConfigSchema, BuilderComponentConfigSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentWhenSerialisedSchema } from './component/index.js';
 import { BuilderExpectationSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema } from './expectation.js';
 import { BuilderModelSchema, BuilderModelSerialisedSchema } from './model/index.js';
-import { BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema } from './option/index.js';
+import { BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema } from './option/index.js';
 import { BuilderPricingSchema, BuilderPricingSerialisedSchema, BuilderRatesSchema } from './pricing/index.js';
 import { BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIInputSchema, BuilderUIInputSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema } from './ui/index.js';
 export const entitiesMap = {
     builder: { runtime: BuilderSchema, serialised: BuilderSerialisedSchema },
     model: { runtime: BuilderModelSchema, serialised: BuilderModelSerialisedSchema },
-    select: { runtime: BuilderSelectTypeSchema, serialised: BuilderSelectTypeSerialisedSchema },
-    toggle: { runtime: BuilderToggleTypeSchema, serialised: BuilderToggleTypeSerialisedSchema },
+    select: { runtime: BuilderSelectConfigSchema, serialised: BuilderSelectConfigSerialisedSchema },
+    toggle: { runtime: BuilderToggleConfigSchema, serialised: BuilderToggleConfigSerialisedSchema },
     optionSelectMap: {
         runtime: BuilderOptionSelectMapSerialisedSchema,
         serialised: BuilderOptionSelectMapSerialisedSchema
@@ -23,9 +23,9 @@ export const entitiesMap = {
         runtime: BuilderOptionWhenSerialisedSchema,
         serialised: BuilderOptionWhenSerialisedSchema
     },
-    componentDetails: {
-        runtime: BuilderComponentDetailsSchema,
-        serialised: BuilderComponentDetailsSerialisedSchema
+    componentConfig: {
+        runtime: BuilderComponentConfigSchema,
+        serialised: BuilderComponentConfigSerialisedSchema
     },
     componentSelectMap: {
         runtime: BuilderComponentSelectMapSerialisedSchema,
@@ -141,7 +141,7 @@ const serialiserMap = [
     serialiser(BuilderOptionSchema, serialiseNamedEntry),
     serialiser(BuilderComponentSchema, serialiseNamedEntry),
     serialiser(BuilderCollectionSchema, serialiseNamedEntry),
-    serialiser(BuilderComponentDetailsSchema, (value) => ({
+    serialiser(BuilderComponentConfigSchema, (value) => ({
         fields: serialiseValue(value.fields),
         tags: value.tags
     })),
@@ -158,7 +158,7 @@ const serialiserMap = [
         max: serialiseValue(value.max),
         tags: value.tags
     })),
-    serialiser(BuilderSelectTypeSchema, (value) => ({
+    serialiser(BuilderSelectConfigSchema, (value) => ({
         type: 'select',
         options: value.options,
         defaultValue: value.defaultValue,
@@ -166,7 +166,7 @@ const serialiserMap = [
         optionLabels: value.optionLabels,
         tags: value.tags
     })),
-    serialiser(BuilderToggleTypeSchema, (value) => ({
+    serialiser(BuilderToggleConfigSchema, (value) => ({
         type: 'toggle',
         valueType: value.valueType,
         defaultValue: value.defaultValue,

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

@@ -1,7 +1,6 @@
 import type { BuilderPath } from '../../paths';
 import type { Paramable, ParamableSerialised } from '../../references';
-import type { BuilderModelGeneric, BuilderModelStateOf } from '../model/model';
-import type { BuilderModelState } from '../model/state';
+import type { BuilderModelGeneric, BuilderModelState, BuilderModelStateOf } from '../model/index';
 import type { BuilderTags } from '../tags';
 import type { BuilderValidPath } from '../when';
 import * as v from 'valibot';

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

@@ -1,8 +1,7 @@
 import type { Paramable, ParamableSerialised } from '../../references';
 import type { BuilderExpectation, BuilderExpectations, BuilderExpectationsSerialised } from '../expectation';
 import type { CollectionNamesOf } from '../collection/index';
-import type { BuilderModel, BuilderModelGeneric, BuilderModelStateOf } from '../model/model';
-import type { BuilderModelStateAsserted } from '../model/expectation';
+import type { BuilderModel, BuilderModelGeneric, BuilderModelStateAsserted, BuilderModelStateOf } from '../model/index';
 import type { BuilderTags } from '../tags';
 import type { BuilderUIValidInputsOf } from './input';
 import type { BuilderUIItems, BuilderUIItemsSerialised } from './pages';

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

@@ -1,4 +1,4 @@
-import type { BuilderModelGeneric } from '../model/model';
+import type { BuilderModelGeneric } from '../model/index';
 import type { BuilderUIs } from './ui';
 import { BuilderUI } from './ui.js';
 export declare function uis(): BuilderUI<BuilderModelGeneric>;