@builder-builder/builder 0.0.9 → 0.0.11

package/dist/entities/ui/ui.js

@@ -1,53 +1,40 @@
 import * as v from 'valibot';
-import { BuilderRefsSerialisedSchema, isRef, refable } from '../../references.js';
+import { check } from '../../check.js';
+import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
-import { BuilderSerialisedSchema } from '../builder/index.js';
 import { BuilderExpectationsSerialisedSchema } from '../expectation.js';
-import { bindUI } from './parameter.js';
 import { BuilderUIDescribe } from './describe.js';
-import { BuilderUILabel } from './label.js';
 import { BuilderUIPage } from './page.js';
 import { BuilderUIItemsSerialisedSchema, BuilderUIPages } from './pages.js';
-import { validatePagesCollections } from './validate.js';
 export class BuilderUI {
-    builder;
-    references;
+    uis;
     items;
     expectations;
-    id = crypto.randomUUID();
-    constructor(builder, references, items, expectations) {
-        this.builder = builder;
-        this.references = references;
+    constructor(uis, items, expectations) {
+        this.uis = uis;
         this.items = items;
         this.expectations = expectations;
-        validatePagesCollections(builder, items);
     }
     expect(...expectations) {
-        return new BuilderUI(this.builder, this.references, this.items, [...this.expectations, ...expectations]
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- type narrowing cast, validated at merge time
-        );
+        return new BuilderUI(this.uis, this.items, [
+            ...this.expectations,
+            ...expectations
+        ]);
     }
     page(label, paths) {
-        return new BuilderUI(this.builder, this.references, [...this.items, new BuilderUIPage(this.#label(label), paths)], this.expectations);
+        return new BuilderUI(this.uis, [...this.items, new BuilderUIPage(label, paths)], this.expectations);
     }
     describe(label, paths) {
-        return new BuilderUI(this.builder, this.references, [...this.items, new BuilderUIDescribe(this.#label(label), paths)], this.expectations);
+        return new BuilderUI(this.uis, [...this.items, new BuilderUIDescribe(label, paths)], this.expectations);
     }
     pages(name, label, itemUI) {
-        const items = isRef(itemUI) ? itemUI : itemUI.items;
-        return new BuilderUI(this.builder, this.references, [...this.items, new BuilderUIPages(name, this.#label(label), items)], this.expectations);
-    }
-    bind(bindings) {
-        return bindUI(this, bindings);
-    }
-    #label(label) {
-        return isRef(label) ? label : new BuilderUILabel(label);
+        const items = check.is(BuilderUISchema, itemUI) ? itemUI.items : itemUI;
+        return new BuilderUI(this.uis, [...this.items, new BuilderUIPages(name, label, items)], this.expectations);
     }
 }
 export const BuilderUISchema = v.instance(BuilderUI);
-export const BuilderUISerialisedSchema = serialisable(BuilderUI, v.object({
-    builder: refable(v.lazy(() => BuilderSerialisedSchema)),
-    references: BuilderRefsSerialisedSchema,
+export const BuilderUISerialisedSchema = serialisable(v.object({
+    uis: v.pipe(v.array(paramable(v.lazy(() => BuilderUISerialisedSchema))), v.readonly()),
     items: BuilderUIItemsSerialisedSchema,
     expectations: BuilderExpectationsSerialisedSchema
 }));

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

@@ -1,10 +1,6 @@
-import type { BuilderGeneric } from '../builder/index';
-import type { BuilderUIReferences } from './ui';
-import { BuilderRef } from '../../references.js';
+import type { BuilderModelGeneric } from '../model/model';
+import type { BuilderUIs } from './ui';
 import { BuilderUI } from './ui.js';
-export declare function uis(): BuilderUI<BuilderRef>;
-export declare function uis<const BuilderType extends BuilderGeneric>(uiBuilder: BuilderType, ...parts: BuilderUIReferences): BuilderUI<BuilderType>;
-export declare function mergeUIParts(parts: ReadonlyArray<unknown>): {
-    references: BuilderRef[];
-    expectations: import("..").BuilderExpectation<string, unknown, "option" | "component" | "collection" | "detail">[];
-};
+export declare function uis(): BuilderUI<BuilderModelGeneric>;
+export declare function uis<const Model extends BuilderModelGeneric>(model: Model, ...parts: BuilderUIs): BuilderUI<Model>;
+export declare function uis(...parts: BuilderUIs): BuilderUI<BuilderModelGeneric>;

package/dist/entities/ui/uis.js

@@ -1,20 +1,13 @@
-import * as v from 'valibot';
-import { BuilderRef } from '../../references.js';
-import { BuilderUI, BuilderUISchema } from './ui.js';
-export function uis(uiBuilder, ...parts) {
-    const builder = uiBuilder ?? new BuilderRef('builder');
-    const merged = mergeUIParts(parts);
-    return new BuilderUI(builder, merged.references, parts.flatMap((part) => {
-        if (v.is(BuilderUISchema, part)) {
-            return [...part.items];
-        }
-        return [part];
-    }), merged.expectations);
-}
-export function mergeUIParts(parts) {
-    const instances = parts.filter((part) => v.is(BuilderUISchema, part));
-    return {
-        references: instances.flatMap((instance) => [...instance.references]),
-        expectations: instances.flatMap((instance) => [...instance.expectations])
-    };
+import { check } from '../../check.js';
+import { BuilderModelSchema } from '../model/model.js';
+import { BuilderUI } from './ui.js';
+export function uis(...args) {
+    const [first, ...rest] = args;
+    if (first === undefined) {
+        return new BuilderUI([], [], []);
+    }
+    if (check.is(BuilderModelSchema, first)) {
+        return new BuilderUI(rest, [], []);
+    }
+    return new BuilderUI(args, [], []);
 }

package/dist/entities/validated.d.ts

@@ -0,0 +1,35 @@
+import type { BuilderValidatedBrand } from '../validate/brand';
+import type { BuilderComponentVariants, BuilderInstance, BuilderInstances } from '../instance';
+import type { Prettify } from '../prettify';
+import type { BuilderParameter, BuilderParameterSerialised, BuilderRef, BuilderRefSerialised } from '../references';
+import type { BuilderSerialised } from './builder/index';
+import type { BuilderCollectionConfigSerialised, BuilderCollectionSerialised, BuilderCollectionsSerialised } from './collection/index';
+import type { BuilderComponentSerialised, BuilderComponentsSerialised } from './component/index';
+import type { BuilderModelSerialised } from './model/index';
+import type { BuilderOptionSerialised, BuilderOptionsSerialised } from './option/index';
+import type { BuilderUIDescribeSerialised, BuilderUIItemsSerialised, BuilderUIPageSerialised, BuilderUISerialised } from './ui/index';
+export type Validated<Input> = Input extends BuilderComponentVariants | BuilderInstance | BuilderModelSerialised | BuilderSerialised | BuilderUISerialised ? Prettify<Validate<Input> & BuilderValidatedBrand> : Validate<Input>;
+type Validate<Input> = Input extends BuilderParameter<string> | BuilderParameterSerialised | BuilderRef | BuilderRefSerialised ? never : Input extends ReadonlyArray<unknown> ? ValidatedTuple<Input> : Input extends object ? Prettify<{
+    readonly [Key in keyof Input]: Validated<Input[Key]>;
+}> : Input;
+type ValidatedTuple<Input extends ReadonlyArray<unknown>> = Input extends readonly [
+    infer Head,
+    ...infer Rest extends ReadonlyArray<unknown>
+] ? [Validated<Head>] extends [never] ? ValidatedTuple<Rest> : readonly [Validated<Head>, ...ValidatedTuple<Rest>] : Input extends readonly [] ? readonly [] : ReadonlyArray<Validated<Input[number]>>;
+export type BuilderValidated = Validated<BuilderSerialised>;
+export type BuilderModelValidated = Validated<BuilderModelSerialised>;
+export type BuilderUIValidated = Validated<BuilderUISerialised>;
+export type BuilderInstanceValidated = Validated<BuilderInstance>;
+export type BuilderInstancesValidated = Validated<BuilderInstances>;
+export type BuilderComponentVariantsValidated = Validated<BuilderComponentVariants>;
+export type BuilderOptionValidated = Validated<BuilderOptionSerialised>;
+export type BuilderOptionsValidated = Validated<BuilderOptionsSerialised>;
+export type BuilderComponentValidated = Validated<BuilderComponentSerialised>;
+export type BuilderComponentsValidated = Validated<BuilderComponentsSerialised>;
+export type BuilderCollectionValidated = Validated<BuilderCollectionSerialised>;
+export type BuilderCollectionsValidated = Validated<BuilderCollectionsSerialised>;
+export type BuilderCollectionConfigValidated = Validated<BuilderCollectionConfigSerialised>;
+export type BuilderUIItemsValidated = Validated<BuilderUIItemsSerialised>;
+export type BuilderUIPageValidated = Validated<BuilderUIPageSerialised>;
+export type BuilderUIDescribeValidated = Validated<BuilderUIDescribeSerialised>;
+export {};

package/dist/entities/validated.js

@@ -0,0 +1 @@
+export {};

package/dist/entities/when.d.ts

@@ -1,7 +1,7 @@
 import type { BuilderPath, BuilderPaths } from '../paths';
 import type { BuilderPrimitive, BuilderPrimitives } from '../primitive';
-import type { BuilderRef, BuilderRefSerialised, Refable } from '../references';
-import type { BuilderGeneric, BuilderState, BuilderStateOf } from './builder/index';
+import type { BuilderParameter, BuilderParameterSerialised, Paramable } from '../references';
+import type { BuilderModelGeneric, BuilderModelState, BuilderModelStateOf } from './model/index';
 import * as v from 'valibot';
 export type BuilderEnableConfig<Payload = unknown> = {
     readonly type: 'enable';
@@ -20,20 +20,20 @@ export type BuilderUnlessConfig<Payload = unknown, UnlessPath = BuilderPath> = {
     readonly payload: Payload;
 };
 export type BuilderWhen<Payload = unknown, MatchPath = BuilderPath, MatchSelectMap = Record<string, Payload | null>, UnlessPath = BuilderPath> = BuilderEnableConfig<Payload> | BuilderMatchConfig<Payload, MatchPath, MatchSelectMap> | BuilderUnlessConfig<Payload, UnlessPath>;
-export type WhenSerialised<Payload> = {
+export type BuilderWhenSerialised<Payload> = {
     readonly type: 'enable';
-    readonly payload: Payload | BuilderRefSerialised;
+    readonly payload: Payload | BuilderParameterSerialised;
 } | {
     readonly type: 'match';
-    readonly matchPath: BuilderRefSerialised | BuilderPath;
-    readonly selectMap: Record<string, (Payload | BuilderRefSerialised) | null> | BuilderRefSerialised;
+    readonly matchPath: BuilderParameterSerialised | BuilderPath;
+    readonly selectMap: Record<string, (Payload | BuilderParameterSerialised) | null> | BuilderParameterSerialised;
 } | {
     readonly type: 'unless';
-    readonly unlessPath: BuilderRefSerialised | BuilderPath;
+    readonly unlessPath: BuilderParameterSerialised | BuilderPath;
     readonly disabledValues: BuilderPrimitives;
-    readonly payload: Payload | BuilderRefSerialised;
+    readonly payload: Payload | BuilderParameterSerialised;
 };
-export type WhenConfigPayload<Config extends BuilderWhenConfig, Payload> = Config extends {
+export type WhenConfigPayload<Config extends BuilderWhenGeneric, Payload> = Config extends {
     readonly payload: infer Inner extends Payload;
 } ? Inner : Config extends BuilderMatchConfig ? NonNullable<Config['selectMap'][keyof Config['selectMap']]> & Payload : never;
 export declare const BuilderWhenEnableSchema: v.ObjectSchema<{
@@ -41,136 +41,145 @@ export declare const BuilderWhenEnableSchema: v.ObjectSchema<{
 }, undefined>;
 export declare const BuilderWhenMatchSchema: v.ObjectSchema<{
     readonly type: v.LiteralSchema<"match", undefined>;
-    readonly matchPath: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"ref", undefined>;
+    readonly matchPath: 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: "ref";
+        type: "parameter";
         id: string;
         name: string;
-    }>]>, v.InstanceSchema<typeof BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | BuilderRef | Readonly<{
+    }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
         type: "ref";
         id: string;
-        name: string;
-    }>, {
-        readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
-    }>]>;
+    }>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>;
 }, undefined>;
 export declare const BuilderWhenUnlessSchema: v.ObjectSchema<{
     readonly type: v.LiteralSchema<"unless", undefined>;
-    readonly unlessPath: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"ref", undefined>;
+    readonly unlessPath: 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: "ref";
+        type: "parameter";
         id: string;
         name: string;
-    }>]>, v.InstanceSchema<typeof BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | BuilderRef | Readonly<{
+    }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
         type: "ref";
         id: string;
-        name: string;
-    }>, {
-        readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
-    }>]>;
+    }>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>;
 }, undefined>;
 export declare const BuilderWhenConfigSchema: v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"enable", undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly type: v.LiteralSchema<"match", undefined>;
-    readonly matchPath: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"ref", undefined>;
+    readonly matchPath: 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: "ref";
+        type: "parameter";
         id: string;
         name: string;
-    }>]>, v.InstanceSchema<typeof BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | BuilderRef | Readonly<{
+    }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
         type: "ref";
         id: string;
-        name: string;
-    }>, {
-        readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
-    }>]>;
+    }>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly type: v.LiteralSchema<"unless", undefined>;
-    readonly unlessPath: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"ref", undefined>;
+    readonly unlessPath: 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: "ref";
+        type: "parameter";
         id: string;
         name: string;
-    }>]>, v.InstanceSchema<typeof BuilderRef, undefined>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>, v.MetadataAction<readonly (string | number)[] | BuilderRef | Readonly<{
+    }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
         type: "ref";
         id: string;
-        name: string;
-    }>, {
-        readonly refable: v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>;
-    }>]>;
+    }>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>], undefined>;
 }, undefined>], undefined>, v.ReadonlyAction<{
-    type: "enable";
-} | {
     type: "match";
-    matchPath: readonly (string | number)[] | BuilderRef | Readonly<{
-        type: "ref";
+    matchPath: readonly (string | number)[] | Readonly<{
+        type: "parameter";
         id: string;
         name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
     }>;
 } | {
     type: "unless";
-    unlessPath: readonly (string | number)[] | BuilderRef | Readonly<{
-        type: "ref";
+    unlessPath: readonly (string | number)[] | Readonly<{
+        type: "parameter";
         id: string;
         name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
     }>;
+} | {
+    type: "enable";
 }>]>;
 export type BuilderWhenConfig = v.InferOutput<typeof BuilderWhenConfigSchema>;
-export declare function createWhenSerialisedSchema(payloadSchema: v.GenericSchema): v.GenericSchema;
+export type BuilderWhenGeneric = BuilderWhen<unknown, unknown, unknown, unknown>;
+export declare const BuilderWhenSerialisedSchema: v.GenericSchema<BuilderWhenSerialised<unknown>>;
+export declare function createSelectMapSerialisedSchema<Payload extends v.GenericSchema>(payloadSchema: Payload): v.GenericSchema<BuilderMatchSelectMap<v.InferOutput<Payload> | BuilderParameterSerialised>>;
+export declare function createWhenSerialisedSchema<Payload extends v.GenericSchema>(payloadSchema: Payload): v.GenericSchema<BuilderWhenSerialised<v.InferOutput<Payload>>>;
 export declare function createWhenFactories<Payload>(): {
-    enable: <const Values extends Refable<Payload>>(values: Values) => BuilderEnableConfig<Values>;
-    match: <const MatchPayload extends Refable<Payload>, const MatchPath extends Refable<BuilderPath>, const SelectMap extends Refable<BuilderMatchSelectMap<Refable<Payload>>>>(matchPath: MatchPath, selectMap: SelectMap) => BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends Refable<Payload>, const UnlessPath extends Refable<BuilderPath>>(unlessPath: UnlessPath, disabledValues: BuilderPrimitives, values: Values) => BuilderUnlessConfig<Values, UnlessPath>;
+    enable: <const Values extends Paramable<Payload>>(values: Values) => BuilderEnableConfig<Values>;
+    match: <const MatchPayload extends Paramable<Payload>, const MatchPath extends Paramable<BuilderPath>, const SelectMap extends Paramable<BuilderMatchSelectMap<Paramable<Payload>>>>(matchPath: MatchPath, selectMap: SelectMap) => BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends Paramable<Payload>, const UnlessPath extends Paramable<BuilderPath>>(unlessPath: UnlessPath, disabledValues: BuilderPrimitives, values: Values) => BuilderUnlessConfig<Values, UnlessPath>;
 };
-export type BuilderValidPath<State extends BuilderState> = ModelValidPath<State['model']>;
-export type BuilderValidPaths<State extends BuilderState> = ReadonlyArray<BuilderValidPath<State>>;
-export type BuilderValidPathsOf<Input extends Refable<BuilderGeneric>> = BuilderValidPaths<BuilderStateOf<Input>>;
-export type BuilderWhenConstrained<State extends BuilderState, Config> = Config extends BuilderRef ? Config : Config extends {
+export type BuilderValidPath<State extends BuilderModelState> = InstanceValidPath<State['instance']>;
+export type BuilderValidPaths<State extends BuilderModelState> = ReadonlyArray<BuilderValidPath<State>>;
+export type BuilderValidPathsOf<Input extends Paramable<BuilderModelGeneric>> = BuilderValidPaths<BuilderModelStateOf<Input>>;
+export type BuilderWhenConstrained<State extends BuilderModelState, Config> = Config extends BuilderParameter ? Config : Config extends {
     readonly type: 'match';
     readonly matchPath: infer MatchPath extends BuilderPath;
     readonly selectMap: infer SelectMap;
 } ? Config & {
     readonly matchPath: [MatchPath] extends [Readonly<BuilderValidPath<State>>] ? MatchPath : Readonly<BuilderValidPath<State>>;
-    readonly selectMap: SelectMap extends BuilderRef ? SelectMap : Record<BuilderResolvePath<State['model'], MatchPath> & string, SelectMap[keyof SelectMap]>;
+    readonly selectMap: SelectMap extends BuilderParameter ? SelectMap : Record<BuilderResolvePath<State['instance'], MatchPath> & string, SelectMap[keyof SelectMap]>;
 } : Config extends {
     readonly type: 'unless';
     readonly unlessPath: infer UnlessPath extends BuilderPath;
 } ? Config & {
     readonly unlessPath: [UnlessPath] extends [Readonly<BuilderValidPath<State>>] ? UnlessPath : Readonly<BuilderValidPath<State>>;
 } : Config;
-export type WhenConfigNullable<Config extends BuilderWhenConfig> = Config extends {
+export type WhenConfigNullable<Config extends BuilderWhenGeneric> = Config extends {
     readonly type: 'unless';
 } ? null : Config extends {
     readonly type: 'match';
     readonly selectMap: infer SelectMap;
 } ? null extends SelectMap[keyof SelectMap] ? null : never : never;
-export type WhenNullability<State extends BuilderState, GatePaths extends Refable<BuilderPaths>, Config extends Refable<BuilderWhenConfig>> = [GatePaths] extends [BuilderRef] ? null : WhenNullabilityFromPaths<State['model'], Extract<GatePaths, BuilderValidPaths<State>>, Config>;
-type BuilderResolvePath<Model, Path extends BuilderPath> = Path extends readonly [
-    infer Head extends keyof Model & string
-] ? Model[Head] : Path extends readonly [
-    infer Head extends keyof Model & string,
+export type WhenNullability<State extends BuilderModelState, GatePaths extends Paramable<BuilderPaths>, Config extends Paramable<BuilderWhenGeneric>> = [GatePaths] extends [BuilderParameter] ? null : WhenNullabilityFromPaths<State['instance'], Extract<GatePaths, BuilderValidPaths<State>>, Config>;
+type BuilderResolvePath<Instance, Path extends BuilderPath> = Path extends readonly [
+    infer Head extends keyof Instance & string
+] ? Instance[Head] : Path extends readonly [
+    infer Head extends keyof Instance & string,
     ...infer Tail extends BuilderPath
-] ? Model[Head] extends ReadonlyArray<infer Item> ? Tail extends readonly [number, ...infer Rest extends BuilderPath] ? BuilderResolvePath<Item, Rest> : never : BuilderResolvePath<Model[Head], Tail> : never;
-type WhenNullabilityFromPaths<Model, GatePaths extends BuilderPaths, Config extends Refable<BuilderWhenConfig>> = Config extends BuilderRef ? WhenPathsNullable<Model, GatePaths> : Config extends BuilderWhenConfig ? WhenPathsNullable<Model, GatePaths> | WhenConfigNullable<Config> : never;
-type WhenPathsNullable<Model, GatePaths extends BuilderPaths> = GatePaths extends readonly [
+] ? Instance[Head] extends ReadonlyArray<infer Item> ? Tail extends readonly [number, ...infer Rest extends BuilderPath] ? BuilderResolvePath<Item, Rest> : never : BuilderResolvePath<Instance[Head], Tail> : never;
+type WhenNullabilityFromPaths<Instance, GatePaths extends BuilderPaths, Config extends Paramable<BuilderWhenGeneric>> = Config extends BuilderParameter ? WhenPathsNullable<Instance, GatePaths> : Config extends BuilderWhenGeneric ? WhenPathsNullable<Instance, GatePaths> | WhenConfigNullable<Config> : never;
+type WhenPathsNullable<Instance, GatePaths extends BuilderPaths> = GatePaths extends readonly [
     infer Head extends BuilderPath,
     ...infer Tail extends BuilderPaths
-] ? WhenPathNullable<Model, Head> | WhenPathsNullable<Model, Tail> : never;
-type WhenPathNullable<Model, Path extends BuilderPath> = null extends BuilderResolvePath<Model, Path> ? null : never;
-type ModelValidPath<Model, Depth extends ReadonlyArray<never> = []> = Depth['length'] extends 10 ? never : Model extends BuilderPrimitive | null ? never : Model extends ReadonlyArray<infer Item> ? [number] | [number, ...ModelValidPath<Item, [...Depth, never]>] : {
-    [Key in keyof Model & string]: [Key] | (Model[Key] extends BuilderPrimitive | null ? never : [Key, ...ModelValidPath<Model[Key], [...Depth, never]>]);
-}[keyof Model & string];
+] ? WhenPathNullable<Instance, Head> | WhenPathsNullable<Instance, Tail> : never;
+type WhenPathNullable<Instance, Path extends BuilderPath> = null extends BuilderResolvePath<Instance, Path> ? null : never;
+type InstanceValidPath<Instance, Depth extends ReadonlyArray<never> = []> = Depth['length'] extends 10 ? never : Instance extends BuilderPrimitive | null ? never : Instance extends ReadonlyArray<infer Item> ? [number] | [number, ...InstanceValidPath<Item, [...Depth, never]>] : {
+    [Key in keyof Instance & string]: [Key] | (Instance[Key] extends BuilderPrimitive | null ? never : [Key, ...InstanceValidPath<Instance[Key], [...Depth, never]>]);
+}[keyof Instance & string];
 export {};

package/dist/entities/when.js

@@ -1,34 +1,38 @@
 import * as v from 'valibot';
 import { BuilderPathSchema } from '../paths.js';
 import { BuilderPrimitivesSchema } from '../primitive.js';
-import { refable } from '../references.js';
+import { paramable } from '../references.js';
 export const BuilderWhenEnableSchema = v.object({
     type: v.literal('enable')
 });
 export const BuilderWhenMatchSchema = v.object({
     type: v.literal('match'),
-    matchPath: refable(BuilderPathSchema)
+    matchPath: paramable(BuilderPathSchema)
 });
 export const BuilderWhenUnlessSchema = v.object({
     type: v.literal('unless'),
-    unlessPath: refable(BuilderPathSchema)
+    unlessPath: paramable(BuilderPathSchema)
 });
 export const BuilderWhenConfigSchema = v.pipe(v.variant('type', [BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema]), v.readonly());
+export const BuilderWhenSerialisedSchema = createWhenSerialisedSchema(v.unknown());
+export function createSelectMapSerialisedSchema(payloadSchema) {
+    return v.pipe(v.record(v.string(), v.nullable(paramable(payloadSchema))), v.readonly());
+}
 export function createWhenSerialisedSchema(payloadSchema) {
-    const refablePayload = refable(payloadSchema);
+    const paramablePayload = paramable(payloadSchema);
     return v.pipe(v.variant('type', [
         v.object({
             ...BuilderWhenEnableSchema.entries,
-            payload: refablePayload
+            payload: paramablePayload
         }),
         v.object({
             ...BuilderWhenMatchSchema.entries,
-            selectMap: refable(v.record(v.string(), v.nullable(refablePayload)))
+            selectMap: paramable(createSelectMapSerialisedSchema(payloadSchema))
         }),
         v.object({
             ...BuilderWhenUnlessSchema.entries,
             disabledValues: BuilderPrimitivesSchema,
-            payload: refablePayload
+            payload: paramablePayload
         })
     ]), v.readonly());
 }

package/dist/environment.d.ts

@@ -0,0 +1,5 @@
+import type { BuilderErrors } from './exception';
+import * as v from 'valibot';
+export declare const BuilderEnvironmentSchema: v.PicklistSchema<["development", "staging", "production"], undefined>;
+export type BuilderEnvironment = v.InferOutput<typeof BuilderEnvironmentSchema>;
+export type BuilderEnvironmentResult<EntityType, Env extends BuilderEnvironment = 'production'> = Env extends 'production' ? EntityType : readonly [EntityType, BuilderErrors];

package/dist/environment.js

@@ -0,0 +1,2 @@
+import * as v from 'valibot';
+export const BuilderEnvironmentSchema = v.picklist(['development', 'staging', 'production']);

package/dist/exception.d.ts

@@ -1,6 +1,11 @@
-import type { BuilderErrorDuplicateName, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidGatePath, BuilderErrorPagesUnknownCollection, BuilderErrorUnboundParameter, BuilderErrorUnmetExpectation } from './entities/index';
-import type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail } from './mappers/index';
-export type BuilderError = BuilderErrorUnmetExpectation | BuilderErrorUnboundParameter | BuilderErrorInvalidGatePath | BuilderErrorDuplicateName | BuilderErrorInvalidCollectionBounds | BuilderErrorPagesUnknownCollection | BuilderErrorInvalidOption | BuilderErrorInvalidCollection | BuilderErrorMissingComponent | BuilderErrorUnexpectedComponent | BuilderErrorMissingVariant | BuilderErrorInvalidVariant | BuilderErrorMissingDetail | BuilderErrorUnexpectedDetail;
+import type { BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingReference, BuilderErrorMissingVariant, BuilderErrorUnboundParameter, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderErrorUnmetExpectation, BuilderErrorUnvalidated } from './validate/index';
+export type BuilderErrorLocation = ReadonlyArray<string | number>;
+export declare function builderError<Kind extends string>(kind: Kind, location: BuilderErrorLocation): {
+    kind: Kind;
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorBase = ReturnType<typeof builderError>;
+export type BuilderError = BuilderErrorUnmetExpectation | BuilderErrorUnboundParameter | BuilderErrorMissingReference | BuilderErrorInvalidPath | BuilderErrorInvalidSelectMapKey | BuilderErrorDuplicateName | BuilderErrorInvalidCollectionBounds | BuilderErrorInvalidOption | BuilderErrorInvalidCollection | BuilderErrorMissingComponent | BuilderErrorUnexpectedComponent | BuilderErrorMissingVariant | BuilderErrorInvalidVariant | BuilderErrorMissingDetail | BuilderErrorUnexpectedDetail | BuilderErrorInvalidDetail | BuilderErrorInvalidInput | BuilderErrorUnvalidated;
 export type BuilderErrors = ReadonlyArray<BuilderError>;
 export declare class BuilderException extends globalThis.Error {
     readonly errors: BuilderErrors;

package/dist/exception.js

@@ -1,3 +1,6 @@
+export function builderError(kind, location) {
+    return { kind, location };
+}
 export class BuilderException extends globalThis.Error {
     errors;
     constructor(errors, message = '') {

package/dist/index.d.ts

@@ -1,38 +1,35 @@
-export type { Builder, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderComponent, BuilderComponentDetails, BuilderComponentDetailsSerialised, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhen, BuilderComponentWhenSerialised, BuilderDescription, BuilderDescriptionItem, BuilderErrorDuplicateName, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidGatePath, BuilderErrorPagesUnknownCollection, BuilderErrorUnboundParameter, BuilderErrorUnmetExpectation, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderGeneric, BuilderInstanceOf, BuilderOption, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionValues, BuilderOptionValuesSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderReference, BuilderReferences, BuilderSelectType, BuilderSelectTypeLabels, BuilderSelectTypeSerialised, BuilderSelectTypeValues, BuilderSerialised, BuilderToggleType, BuilderToggleTypeSerialised, BuilderToggleValueType, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIGeneric, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUILabel, BuilderUILabelSerialised, BuilderUIPage, BuilderUIPageSerialised, BuilderUIPages, BuilderUIPagesSerialised, BuilderUIReference, BuilderUIReferences, BuilderUISerialised, BuilderUIValidated, BuilderValidated, BuilderWhenConfig } from './entities/index';
-export type { BuilderError, BuilderErrors } from './exception';
-export type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderOrder, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate } from './mappers/index';
-export type { BuilderData, BuilderModel, BuilderModelInput, BuilderModels, BuilderVariant, BuilderVariants } from './model';
+export type { BB, BBOptions } from './bb';
+export type { BuilderBindings, BuilderBindingsSerialised, BuilderCollection, BuilderCollectionConfig, BuilderCollectionConfigSerialised, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhen, BuilderCollectionWhenSerialised, BuilderComponent, BuilderComponentDetails, BuilderComponentDetailsSerialised, BuilderComponentField, BuilderComponentFields, BuilderComponentFieldSerialised, BuilderComponentFieldsSerialised, BuilderComponentFieldValueType, BuilderComponents, BuilderComponentSerialised, BuilderComponentsSerialised, BuilderComponentWhen, BuilderComponentWhenSerialised, BuilderDescription, BuilderDescriptionItem, BuilderEntityKind, BuilderEntitySerialised, BuilderExpectation, BuilderExpectationKind, BuilderExpectations, BuilderExpectationSerialised, BuilderExpectationsSerialised, BuilderInstanceOf, BuilderModel, BuilderModels, BuilderModelSerialised, BuilderModelValidated, BuilderOption, BuilderOptions, BuilderOptionSerialised, BuilderOptionsSerialised, BuilderOptionValues, BuilderOptionValuesSerialised, BuilderOptionWhen, BuilderOptionWhenSerialised, BuilderRefEntities, BuilderRefEntity, BuilderSelectType, BuilderSelectTypeLabels, BuilderSelectTypeSerialised, BuilderSelectTypeValues, BuilderSerialised, BuilderToggleType, BuilderToggleTypeSerialised, BuilderToggleValueType, BuilderUI, BuilderUIDescribe, BuilderUIDescribeSerialised, BuilderUIItem, BuilderUIItems, BuilderUIItemsSerialised, BuilderUIPage, BuilderUIPages, BuilderUIPageSerialised, BuilderUIPagesSerialised, BuilderUIs, BuilderUIsSerialised, BuilderUISerialised, BuilderUIValidated, BuilderValidated, BuilderEnableConfig, BuilderMatchConfig, BuilderMatchSelectMap, BuilderUnlessConfig, BuilderWhen, BuilderWhenConfig, BuilderWhenSerialised } from './entities/index';
+export type { BuilderEnvironment } from './environment';
+export type { BuilderError, BuilderErrorBase, BuilderErrorLocation, BuilderErrors } from './exception';
+export type { BuilderComponentVariantsValidationResult, BuilderErrorDuplicateName, BuilderErrorInvalidCollection, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidDetail, BuilderErrorInvalidInput, BuilderErrorInvalidOption, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidSelectMapKey, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingReference, BuilderErrorMissingVariant, BuilderErrorUnboundParameter, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderErrorUnmetExpectation, BuilderErrorUnvalidated, BuilderInstanceValidationResult, BuilderModelValidationResult, BuilderOrder, BuilderRenderOption, BuilderRenderOptions, BuilderRenderPage, BuilderRenderPages, BuilderRenderResult, BuilderRenderUpdate, BuilderUIValidationResult, BuilderValidationResult, BuilderVariantsValidationOptions } from './mappers/index';
+export type { BuilderComponentVariants, BuilderInstance, BuilderInstanceInput, BuilderInstances, BuilderVariant, BuilderVariants } from './instance';
 export type { BuilderPath, BuilderPaths } from './paths';
 export type { BuilderPrimitive, BuilderPrimitives } from './primitive';
-export type { BuilderRef, BuilderRefSerialised, Refable, RefableSerialised } from './references';
-import { builders, collectionConfig, collectionExpectation, componentDetails, componentExpectation, detailExpectation, optionExpectation, uis } from './entities/index.js';
-import { createInstance, createModels } from './mappers/index.js';
-export declare const builder: typeof builders;
+export type { BuilderParameter, BuilderParameterSerialised, BuilderRef, Paramable, ParamableSerialised } from './references';
+export { bb } from './bb.js';
+export { Builder, builder, detailBoolean, detailNumber, detailString, model, parameter, ref, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
+export { BuilderException } from './exception.js';
+export { ordinal } from './mappers/index.js';
+import { collectionConfig, collectionExpectation, componentDetails, componentExpectation, optionExpectation, uis } from './entities/index.js';
 export declare const collection: typeof collectionConfig & {
-    enable: <const Values extends import("./references").Refable<import(".").BuilderCollectionConfig<import("./references").Refable<import(".").BuilderGeneric>, import("./references").Refable<number>, import("./references").Refable<number>>>>(values: Values) => import("./entities/when").BuilderEnableConfig<Values>;
-    match: <const MatchPayload extends import("./references").Refable<import(".").BuilderCollectionConfig<import("./references").Refable<import(".").BuilderGeneric>, import("./references").Refable<number>, import("./references").Refable<number>>>, const MatchPath extends import("./references").Refable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Refable<import("./entities/when").BuilderMatchSelectMap<import("./references").Refable<import(".").BuilderCollectionConfig<import("./references").Refable<import(".").BuilderGeneric>, import("./references").Refable<number>, import("./references").Refable<number>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./entities/when").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends import("./references").Refable<import(".").BuilderCollectionConfig<import("./references").Refable<import(".").BuilderGeneric>, import("./references").Refable<number>, import("./references").Refable<number>>>, const UnlessPath extends import("./references").Refable<import("./paths").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import("./entities/when").BuilderUnlessConfig<Values, UnlessPath>;
+    enable: <const Values extends import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>(values: Values) => import(".").BuilderEnableConfig<Values>;
+    match: <const MatchPayload extends import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const MatchPath extends import("./references").Paramable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Paramable<import(".").BuilderMatchSelectMap<import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import(".").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends import("./references").Paramable<import(".").BuilderCollectionConfig<import("./references").Paramable<import("./entities/model").BuilderModelGeneric>, import("./references").Paramable<number>, import("./references").Paramable<number>>>, const UnlessPath extends import("./references").Paramable<import("./paths").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import(".").BuilderUnlessConfig<Values, UnlessPath>;
 };
 export declare const component: typeof componentDetails & {
-    enable: <const Payload extends import("./references").Refable<import(".").BuilderComponentDetails>>(payload?: Payload) => import("./entities/when").BuilderEnableConfig<Payload>;
-    match: <const Payload extends import("./references").Refable<import(".").BuilderComponentDetails>, const MatchPath extends import("./references").Refable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Refable<import("./entities/when").BuilderMatchSelectMap<import("./references").Refable<import(".").BuilderComponentDetails>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./entities/when").BuilderMatchConfig<Payload, MatchPath, SelectMap>;
-    unless: <const UnlessPath extends import("./references").Refable<import("./paths").BuilderPath>, const Payload extends import("./references").Refable<import(".").BuilderComponentDetails>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, payload?: Payload) => import("./entities/when").BuilderUnlessConfig<Payload, UnlessPath>;
+    enable: <const Payload extends import("./references").Paramable<import(".").BuilderComponentDetails>>(payload?: Payload) => import(".").BuilderEnableConfig<Payload>;
+    match: <const Payload extends import("./references").Paramable<import(".").BuilderComponentDetails>, const MatchPath extends import("./references").Paramable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Paramable<import(".").BuilderMatchSelectMap<import("./references").Paramable<import(".").BuilderComponentDetails>>>>(matchPath: MatchPath, selectMap: SelectMap) => import(".").BuilderMatchConfig<Payload, MatchPath, SelectMap>;
+    unless: <const UnlessPath extends import("./references").Paramable<import("./paths").BuilderPath>, const Payload extends import("./references").Paramable<import(".").BuilderComponentDetails>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, payload?: Payload) => import(".").BuilderUnlessConfig<Payload, UnlessPath>;
 };
 export declare const has: {
     collection: typeof collectionExpectation;
     component: typeof componentExpectation;
-    detail: typeof detailExpectation;
     option: typeof optionExpectation;
 };
-export declare const instance: typeof createInstance;
-export declare const models: typeof createModels;
 export declare const option: {
-    enable: <const Values extends import("./references").Refable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>>(values: Values) => import("./entities/when").BuilderEnableConfig<Values>;
-    match: <const MatchPayload extends import("./references").Refable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends import("./references").Refable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Refable<import("./entities/when").BuilderMatchSelectMap<import("./references").Refable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("./entities/when").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
-    unless: <const Values extends import("./references").Refable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends import("./references").Refable<import("./paths").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import("./entities/when").BuilderUnlessConfig<Values, UnlessPath>;
+    enable: <const Values extends import("./references").Paramable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>>(values: Values) => import(".").BuilderEnableConfig<Values>;
+    match: <const MatchPayload extends import("./references").Paramable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends import("./references").Paramable<import("./paths").BuilderPath>, const SelectMap extends import("./references").Paramable<import(".").BuilderMatchSelectMap<import("./references").Paramable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import(".").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends import("./references").Paramable<import(".").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import(".").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends import("./references").Paramable<import("./paths").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("./primitive").BuilderPrimitives, values: Values) => import(".").BuilderUnlessConfig<Values, UnlessPath>;
 };
 export declare const ui: typeof uis;
-export { BuilderException } from './exception.js';
-export { BuilderSerialisedSchema } from './entities/builder/index.js';
-export { deserialise, parameter, select, serialise, toggleBoolean, toggleNumber, toggleString } from './entities/index.js';
-export { order, ordinal, render } from './mappers/index.js';