@builder-builder/builder 0.0.20 → 0.0.22

package/dist/entities/kind.d.ts

@@ -1,9 +1,12 @@
+import type { BuilderReferences } from './references';
 import type { EntitiesMap } from './serialise';
-import * as v from 'valibot';
-import { entitiesMap } from './serialise.js';
-export type BuilderEntityKind = keyof typeof entitiesMap;
-export declare const BuilderEntityKindSchema: v.PicklistSchema<readonly ("string" | "number" | "boolean" | "builder" | "model" | "pricing" | "ui" | "select" | "toggle" | "path" | "optionSelectMap" | "optionWhen" | "componentConfig" | "componentSelectMap" | "componentWhen" | "collectionConfig" | "collectionSelectMap" | "collectionWhen" | "uiDescribe" | "uiItems" | "uiPage" | "uiPages" | "uiInput" | "pricingRates" | "expectations" | "paths")[], undefined>;
+import type { BuilderValidatedMap, ValidationResult } from './validated';
+import type * as v from 'valibot';
+import { BuilderValidateErrors } from '../errors/index.js';
+export declare const builderEntityKinds: readonly ["builder", "model", "select", "toggle", "optionSelectMap", "optionWhen", "componentConfig", "componentSelectMap", "componentWhen", "collectionConfig", "collectionSelectMap", "collectionWhen", "ui", "uiDescribe", "uiItems", "uiPage", "uiPages", "uiInput", "pricing", "pricingRates", "expectations", "paths", "path", "number", "string", "boolean"];
+export type BuilderEntityKind = (typeof builderEntityKinds)[number];
 export type BuilderEntitySerialised = {
-    [Kind in keyof EntitiesMap]: v.InferOutput<EntitiesMap[Kind]['serialised']>;
-}[keyof EntitiesMap];
-export declare const BuilderEntitySerialisedSchema: v.GenericSchema<BuilderEntitySerialised>;
+    [Kind in BuilderEntityKind]: v.InferOutput<EntitiesMap[Kind]['serialised']>;
+}[BuilderEntityKind];
+export type EntityValidate<Kind extends BuilderEntityKind> = (input: BuilderValidatedMap[Kind], errors: BuilderValidateErrors, references: BuilderReferences) => void;
+export declare function createEntityValidator<Kind extends BuilderEntityKind>(kind: Kind, schema: v.GenericSchema, validate?: EntityValidate<Kind>): (input: unknown, references?: BuilderReferences, errors?: BuilderValidateErrors) => ValidationResult<BuilderValidatedMap[Kind]>;

package/dist/entities/kind.js

@@ -1,5 +1,39 @@
-import * as v from 'valibot';
-import { entitiesMap } from './serialise.js';
-const builderEntityKinds = Object.keys(entitiesMap);
-export const BuilderEntityKindSchema = v.picklist(builderEntityKinds);
-export const BuilderEntitySerialisedSchema = v.union(builderEntityKinds.map((kind) => entitiesMap[kind].serialised));
+import { BuilderValidateErrors, check } from '../errors/index.js';
+export const builderEntityKinds = [
+    'builder',
+    'model',
+    'select',
+    'toggle',
+    'optionSelectMap',
+    'optionWhen',
+    'componentConfig',
+    'componentSelectMap',
+    'componentWhen',
+    'collectionConfig',
+    'collectionSelectMap',
+    'collectionWhen',
+    'ui',
+    'uiDescribe',
+    'uiItems',
+    'uiPage',
+    'uiPages',
+    'uiInput',
+    'pricing',
+    'pricingRates',
+    'expectations',
+    'paths',
+    'path',
+    'number',
+    'string',
+    'boolean'
+];
+export function createEntityValidator(kind, schema, validate) {
+    return (input, references = [], errors = new BuilderValidateErrors()) => {
+        if (!check.is(schema, input)) {
+            errors.invalidEntity(kind);
+            return [input, errors.errors];
+        }
+        validate?.(input, errors, references);
+        return [input, errors.errors];
+    };
+}

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

@@ -1,8 +1,8 @@
-import type { BuilderPaths } from '../../paths';
 import type { BuilderParameter, BuilderRef, Paramable } from '../../references';
 import type { BuilderCollectionConfig, BuilderCollectionPayload } from '../collection/index';
 import type { BuilderComponentPayload } from '../component/index';
 import type { BuilderOptionPayload } from '../option/index';
+import type { BuilderPaths } from '../paths';
 import type { BuilderWhenConstrained, BuilderWhenGeneric, WhenConfigNullable } from '../when';
 import type { BuilderModelGeneric } from './model';
 import type { BuilderModels } from './models';

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 { BuilderComponentConfig, BuilderComponentWhen } from '../component/index';
 import type { BuilderOptionConfig, BuilderOptionWhen } from '../option/index';
+import type { BuilderPaths } from '../paths';
 import type { BuilderValidPaths, BuilderWhenConstrained, WhenConfigPayload, WhenNullability } from '../when';
 import type { BuilderModel } from './model';
 import type { BuilderModelState, BuilderModelStateAppend } from './state';
@@ -46,12 +46,12 @@ type CollectionInstanceOf<Collection extends BuilderCollection> = [Collection['p
 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<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>;
+    when(paths: Paramable<BuilderPaths>, name: string, payload: Paramable<BuilderOptionWhen>): BuilderOption<string, Paramable<BuilderOptionWhen>, BuilderParameter<string> | import("../..").BuilderRef | 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>;
+    when(paths: Paramable<BuilderPaths>, name: string, payload?: Paramable<BuilderComponentWhen>): BuilderComponent<string, Paramable<BuilderComponentWhen>, BuilderParameter<string> | import("../..").BuilderRef | readonly (readonly (string | number)[])[]>;
 };
 export declare function builderCollectionMethod(): ((name: string, payload: Paramable<BuilderCollectionConfig>) => BuilderCollection<string, Paramable<BuilderCollectionConfig<Paramable<import("./model").BuilderModelGeneric>, Paramable<number>, Paramable<number>>>, Paramable<readonly (readonly (string | number)[])[]>>) & {
-    when(paths: Paramable<BuilderPaths>, name: string, payload: Paramable<BuilderCollectionWhen>): BuilderCollection<string, Paramable<BuilderCollectionWhen>, readonly (readonly (string | number)[])[] | BuilderParameter<string> | import("../..").BuilderRef>;
+    when(paths: Paramable<BuilderPaths>, name: string, payload: Paramable<BuilderCollectionWhen>): BuilderCollection<string, Paramable<BuilderCollectionWhen>, BuilderParameter<string> | import("../..").BuilderRef | readonly (readonly (string | number)[])[]>;
 };
 export {};

package/dist/entities/model/model.js

@@ -1,9 +1,9 @@
 import * as v from 'valibot';
-import { serialisable } from '../../serialisable.js';
 import { BuilderCollectionsSerialisedSchema } from '../collection/index.js';
 import { BuilderComponentsSerialisedSchema } from '../component/index.js';
 import { BuilderExpectationsSerialisedSchema } from '../expectation.js';
 import { BuilderOptionsSerialisedSchema } from '../option/index.js';
+import { serialisable } from '../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
 import { builderCollectionMethod, builderComponentMethod, builderOptionMethod } from './methods.js';
 import { BuilderModelsSerialisedSchema } from './models.js';

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

@@ -3,9 +3,9 @@ export type { BuilderSelectConfigLabels, BuilderSelectConfigSerialised, BuilderS
 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 { BuilderSelectConfig, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, select } from './select.js';
-export { BuilderToggleConfig, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, toggleBoolean, toggleNumber, toggleString } from './toggle.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 { BuilderSelectConfig, BuilderSelectConfigSchema, BuilderSelectConfigSerialisedSchema, select } from './select.js';
-export { BuilderToggleConfig, BuilderToggleConfigSchema, BuilderToggleConfigSerialisedSchema, toggleBoolean, toggleNumber, toggleString } from './toggle.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,5 +1,5 @@
-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 { BuilderOptionConfig, BuilderOptionConfigSerialised } from './config';
@@ -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,7 +1,8 @@
 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 { BuilderOptionConfigSerialisedSchema } from './config.js';
@@ -30,3 +31,5 @@ export const BuilderOptionSerialisedSchema = serialisable(v.object({
     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

@@ -42,4 +42,14 @@ export declare const BuilderSelectConfigSerialisedSchema: v.SchemaWithPipe<reado
 }>]>;
 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,5 +1,6 @@
 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 BuilderSelectConfig {
     type = 'select';
@@ -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

@@ -36,3 +36,10 @@ export declare const BuilderToggleConfigSerialisedSchema: v.SchemaWithPipe<reado
 }>]>;
 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,5 +1,7 @@
 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 BuilderToggleConfig {
@@ -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,5 +1,5 @@
-import type { BuilderPath } from '../../paths';
 import type { Paramable } from '../../references';
+import type { BuilderPath } from '../paths';
 import type { BuilderWhen } from '../when';
 import type { BuilderOptionConfig } from './config';
 export type BuilderOptionWhen = BuilderWhen<Paramable<BuilderOptionConfig>, Paramable<BuilderPath>, Paramable<Record<string, Paramable<BuilderOptionConfig> | null>>, Paramable<BuilderPath>>;

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 {

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

@@ -1,3 +1,8 @@
 import * as v from 'valibot';
 export type BuilderRates = Record<string, Record<string, number>>;
 export declare const BuilderRatesSchema: v.GenericSchema<BuilderRates>;
+export declare const validatePricingRates: (input: unknown, references?: import("../references.js").BuilderReferences, errors?: import("../../errors/errors.js").BuilderValidateErrors) => import("../validated.js").ValidationResult<{
+    readonly [x: string]: {
+        readonly [x: string]: number;
+    } & import("../../validate/brand.js").BuilderValidatedBrand;
+}>;

package/dist/entities/pricing/rates.js

@@ -1,3 +1,5 @@
 import * as v from 'valibot';
-import { serialisable } from '../../serialisable.js';
+import { serialisable } from '../serialisable.js';
+import { createEntityValidator } from '../kind.js';
 export const BuilderRatesSchema = serialisable(v.record(v.string(), v.record(v.string(), v.number())));
+export const validatePricingRates = createEntityValidator('pricingRates', BuilderRatesSchema);