@builder-builder/builder 0.0.19 → 0.0.21

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 { BuilderOption, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionWhenSerialisedSchema, validateOptionSelectMap, validateOptionWhen } from './option.js';
+export { BuilderSelectConfig, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, select, validateSelect } from './select.js';
+export { BuilderToggleConfig, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, toggleBoolean, toggleNumber, toggleString, validateToggle } 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 { BuilderOption, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionWhenSerialisedSchema, validateOptionSelectMap, validateOptionWhen } from './option.js';
+export { BuilderSelectConfig, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, select, validateSelect } from './select.js';
+export { BuilderToggleConfig, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, toggleBoolean, toggleNumber, toggleString, validateToggle } 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

@@ -1,11 +1,11 @@
-import type { BuilderPaths } from '../../paths';
 import type { Paramable } from '../../references';
+import type { BuilderPaths } from '../paths';
 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;
@@ -185,14 +185,14 @@ export declare const BuilderOptionSerialisedSchema: v.SchemaWithPipe<readonly [v
         isOptional: boolean;
         tags?: readonly string[] | undefined;
     }>>>;
-    paths?: readonly (readonly (string | number)[])[] | Readonly<{
+    paths?: Readonly<{
         type: "parameter";
         id: string;
         name: string;
     }> | Readonly<{
         type: "ref";
         id: string;
-    }> | undefined;
+    }> | readonly (readonly (string | number)[])[] | undefined;
     tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderOptionSerialised = v.InferOutput<typeof BuilderOptionSerialisedSchema>;
@@ -327,14 +327,14 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         isOptional: boolean;
         tags?: readonly string[] | undefined;
     }>>>;
-    paths?: readonly (readonly (string | number)[])[] | Readonly<{
+    paths?: Readonly<{
         type: "parameter";
         id: string;
         name: string;
     }> | Readonly<{
         type: "ref";
         id: string;
-    }> | undefined;
+    }> | readonly (readonly (string | number)[])[] | undefined;
     tags?: readonly string[] | undefined;
 }>]>, undefined>, v.ReadonlyAction<Readonly<{
     name: string;
@@ -376,14 +376,92 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         isOptional: boolean;
         tags?: readonly string[] | undefined;
     }>>>;
-    paths?: readonly (readonly (string | number)[])[] | Readonly<{
+    paths?: Readonly<{
         type: "parameter";
         id: string;
         name: string;
     }> | Readonly<{
         type: "ref";
         id: string;
-    }> | undefined;
+    }> | readonly (readonly (string | number)[])[] | undefined;
     tags?: readonly string[] | undefined;
 }>[]>]>;
 export type BuilderOptionsSerialised = v.InferOutput<typeof BuilderOptionsSerialisedSchema>;
+export declare const validateOptionWhen: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+    readonly type: "enable";
+    readonly payload: {
+        readonly type: "select";
+        readonly options: readonly [string, ...string[]];
+        readonly defaultValue: string | null;
+        readonly isOptional: boolean;
+        readonly optionLabels: {
+            readonly [x: string]: string;
+        } & import("../../validate").BuilderValidatedBrand;
+        readonly tags?: readonly string[] | undefined;
+    } | {
+        readonly type: "toggle";
+        readonly valueType: "string" | "number" | "boolean";
+        readonly defaultValue: string | number | boolean | null;
+        readonly isOptional: boolean;
+        readonly tags?: readonly string[] | undefined;
+    };
+} | {
+    readonly type: "match";
+    readonly matchPath: readonly (string | number)[];
+    readonly selectMap: {
+        readonly [x: string]: {
+            readonly type: "select";
+            readonly options: readonly [string, ...string[]];
+            readonly defaultValue: string | null;
+            readonly isOptional: boolean;
+            readonly optionLabels: {
+                readonly [x: string]: string;
+            } & import("../../validate").BuilderValidatedBrand;
+            readonly tags?: readonly string[] | undefined;
+        } | {
+            readonly type: "toggle";
+            readonly valueType: "string" | "number" | "boolean";
+            readonly defaultValue: string | number | boolean | null;
+            readonly isOptional: boolean;
+            readonly tags?: readonly string[] | undefined;
+        } | null;
+    };
+} | {
+    readonly type: "unless";
+    readonly unlessPath: readonly (string | number)[];
+    readonly disabledValues: readonly (string | number | boolean | null)[];
+    readonly payload: {
+        readonly type: "select";
+        readonly options: readonly [string, ...string[]];
+        readonly defaultValue: string | null;
+        readonly isOptional: boolean;
+        readonly optionLabels: {
+            readonly [x: string]: string;
+        } & import("../../validate").BuilderValidatedBrand;
+        readonly tags?: readonly string[] | undefined;
+    } | {
+        readonly type: "toggle";
+        readonly valueType: "string" | "number" | "boolean";
+        readonly defaultValue: string | number | boolean | null;
+        readonly isOptional: boolean;
+        readonly tags?: readonly string[] | undefined;
+    };
+}>;
+export declare const validateOptionSelectMap: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+    readonly [x: string]: {
+        readonly type: "select";
+        readonly options: readonly [string, ...string[]];
+        readonly defaultValue: string | null;
+        readonly isOptional: boolean;
+        readonly optionLabels: {
+            readonly [x: string]: string;
+        } & import("../../validate").BuilderValidatedBrand;
+        readonly tags?: readonly string[] | undefined;
+    } | {
+        readonly type: "toggle";
+        readonly valueType: "string" | "number" | "boolean";
+        readonly defaultValue: string | number | boolean | null;
+        readonly isOptional: boolean;
+        readonly tags?: readonly string[] | undefined;
+    } | null;
+}>;

package/dist/entities/option/option.js

@@ -1,10 +1,11 @@
 import * as v from 'valibot';
-import { BuilderPathsSchema } from '../../paths.js';
 import { paramable } from '../../references.js';
-import { serialisable } from '../../serialisable.js';
+import { createEntityValidator } from '../kind.js';
+import { BuilderPathsSchema } from '../paths.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,12 +22,14 @@ 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)
 }));
 export const BuilderOptionsSerialisedSchema = v.pipe(v.array(BuilderOptionSerialisedSchema), v.readonly());
+export const validateOptionWhen = createEntityValidator('optionWhen', BuilderOptionWhenSerialisedSchema);
+export const validateOptionSelectMap = createEntityValidator('optionSelectMap', BuilderOptionSelectMapSerialisedSchema);

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,16 @@ 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 declare const validateSelect: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+    readonly type: "select";
+    readonly options: readonly [string, ...string[]];
+    readonly defaultValue: string | null;
+    readonly isOptional: boolean;
+    readonly optionLabels: {
+        readonly [x: string]: string;
+    } & import("../../validate").BuilderValidatedBrand;
+    readonly tags?: readonly string[] | undefined;
+}>;
 export {};

package/dist/entities/option/select.js

@@ -1,7 +1,8 @@
 import * as v from 'valibot';
-import { serialisable } from '../../serialisable.js';
+import { createEntityValidator } from '../kind.js';
+import { serialisable } from '../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
-export class BuilderSelectType {
+export class BuilderSelectConfig {
     type = 'select';
     options;
     valueSchema;
@@ -18,7 +19,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 +38,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()),
@@ -52,3 +53,13 @@ export function selectValueSchema(options, optional) {
     const baseSchema = v.union(options.map((value) => v.literal(value)));
     return optional ? v.nullable(baseSchema) : baseSchema;
 }
+export const validateSelect = createEntityValidator('select', BuilderSelectConfigSerialisedSchema, (input, errors) => {
+    if (input.defaultValue != null && !input.options.includes(input.defaultValue)) {
+        errors.invalidSelectDefault(input.defaultValue);
+    }
+    Object.keys(input.optionLabels).forEach((key) => {
+        if (!input.options.includes(key)) {
+            errors.invalidSelectLabel(key);
+        }
+    });
+});

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,12 @@ 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;
+export declare const validateToggle: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../validate").BuilderValidateErrors) => import("..").ValidationResult<{
+    readonly type: "toggle";
+    readonly valueType: "string" | "number" | "boolean";
+    readonly defaultValue: string | number | boolean | null;
+    readonly isOptional: boolean;
+    readonly tags?: readonly string[] | undefined;
+}>;

package/dist/entities/option/toggle.js

@@ -1,8 +1,10 @@
 import * as v from 'valibot';
-import { serialisable } from '../../serialisable.js';
+import { check } from '../../errors/index.js';
+import { createEntityValidator } from '../kind.js';
+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 +19,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 +34,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()])),
@@ -52,3 +54,12 @@ export function toggleValueSchema(valueType, optional) {
     const baseSchema = valueType === 'string' ? v.string() : valueType === 'boolean' ? v.boolean() : v.number();
     return optional ? v.nullable(baseSchema) : baseSchema;
 }
+export const validateToggle = createEntityValidator('toggle', BuilderToggleConfigSerialisedSchema, (input, errors) => {
+    if (input.defaultValue == null) {
+        return;
+    }
+    const valueSchema = toggleValueSchema(input.valueType, input.isOptional);
+    if (!check.is(valueSchema, input.defaultValue)) {
+        errors.invalidToggleDefault(input.defaultValue, input.valueType);
+    }
+});

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

@@ -1,10 +1,10 @@
-import type { BuilderPath } from '../../paths';
 import type { Paramable } from '../../references';
+import type { BuilderPath } from '../paths';
 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/{paths.d.ts → entities/paths.d.ts}

@@ -3,3 +3,5 @@ export declare const BuilderPathSchema: v.SchemaWithPipe<readonly [v.ArraySchema
 export type BuilderPath = v.InferOutput<typeof BuilderPathSchema>;
 export declare const BuilderPathsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>;
 export type BuilderPaths = v.InferOutput<typeof BuilderPathsSchema>;
+export declare const validatePath: (input: unknown, references?: import("./references.js").BuilderReferences, errors?: import("../errors/errors.js").BuilderValidateErrors) => import("./validated.js").ValidationResult<readonly (string | number)[]>;
+export declare const validatePaths: (input: unknown, references?: import("./references.js").BuilderReferences, errors?: import("../errors/errors.js").BuilderValidateErrors) => import("./validated.js").ValidationResult<readonly (readonly (string | number)[])[]>;

package/dist/{paths.js → entities/paths.js}

@@ -1,3 +1,6 @@
 import * as v from 'valibot';
+import { createEntityValidator } from './kind.js';
 export const BuilderPathSchema = v.pipe(v.array(v.union([v.string(), v.number()])), v.readonly());
 export const BuilderPathsSchema = v.pipe(v.array(BuilderPathSchema), v.readonly());
+export const validatePath = createEntityValidator('path', BuilderPathSchema);
+export const validatePaths = createEntityValidator('paths', BuilderPathsSchema);

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

@@ -2,5 +2,5 @@ export type { BuilderPricingExpression, BuilderPricingLookupKey, BuilderPricingR
 export type { BuilderRates } from './rates';
 export type { BuilderPricingSerialised } from './pricing';
 export { BuilderPricingExpressionSchema, BuilderPricingLookupKeySchema, BuilderPricingReduceSchema } from './expression.js';
-export { BuilderRatesSchema } from './rates.js';
+export { BuilderRatesSchema, validatePricingRates } from './rates.js';
 export { BuilderPricing, BuilderPricingSchema, BuilderPricingSerialisedSchema, pricing } from './pricing.js';

package/dist/entities/pricing/index.js

@@ -1,3 +1,3 @@
 export { BuilderPricingExpressionSchema, BuilderPricingLookupKeySchema, BuilderPricingReduceSchema } from './expression.js';
-export { BuilderRatesSchema } from './rates.js';
+export { BuilderRatesSchema, validatePricingRates } from './rates.js';
 export { BuilderPricing, BuilderPricingSchema, BuilderPricingSerialisedSchema, pricing } from './pricing.js';

package/dist/entities/pricing/pricing.js

@@ -1,6 +1,6 @@
 import * as v from 'valibot';
 import { paramable } from '../../references.js';
-import { serialisable } from '../../serialisable.js';
+import { serialisable } from '../serialisable.js';
 import { BuilderPricingExpressionSchema } from './expression.js';
 import { BuilderRatesSchema } from './rates.js';
 export class BuilderPricing {