@builder-builder/builder 0.0.27 → 0.0.29

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

@@ -1,55 +1,28 @@
 import type { BuilderTags } from '../tags';
 import * as v from 'valibot';
-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>> {
+export type BuilderValueOptions = readonly [string, ...ReadonlyArray<string>];
+export type BuilderValueOptionLabels<Options extends BuilderValueOptions> = Partial<Record<Options[number], string>>;
+export declare class BuilderSelectConfig<const Options extends BuilderValueOptions = BuilderValueOptions, const ValueSchema extends v.GenericSchema<string | null> = v.GenericSchema<string | null>> {
     #private;
     readonly value: v.InferOutput<ValueSchema>;
-    readonly type: "select";
-    readonly options: Values;
+    readonly type: "value";
+    readonly kind: "select";
+    readonly options: Options;
     readonly valueSchema: ValueSchema;
     readonly defaultValue: v.InferOutput<ValueSchema>;
     readonly isOptional: boolean;
-    readonly optionLabels: BuilderSelectConfigLabels<Values>;
+    readonly optionLabels: BuilderValueOptionLabels<Options>;
     readonly tags?: BuilderTags;
-    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>;
+    constructor(options: Options, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, optionLabels?: BuilderValueOptionLabels<Options>, tags?: BuilderTags);
+    default(newDefault: v.InferOutput<ValueSchema>): BuilderSelectConfig<Options, ValueSchema>;
+    optional(): BuilderSelectConfig<Options, v.NullableSchema<ValueSchema, undefined>>;
+    labels(optionLabels: BuilderValueOptionLabels<Options>): BuilderSelectConfig<Options, ValueSchema>;
+    tag(...tags: Array<string>): BuilderSelectConfig<Options, ValueSchema>;
 }
-type SelectSchema<Values extends BuilderSelectConfigValues> = v.UnionSchema<{
-    [K in keyof Values]: v.LiteralSchema<Values[K], undefined>;
-}, undefined>;
-export declare function select<const Values extends BuilderSelectConfigValues>(values: Values): BuilderSelectConfig<Values, SelectSchema<Values>>;
+export declare function valueSelect<const Options extends BuilderValueOptions>(options: Options): BuilderSelectConfig<Options, SelectSchema<Options>>;
 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>;
-    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.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, 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;
-}>]>;
-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").BuilderErrorsScope) => 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;
-}>;
+type SelectSchema<Options extends BuilderValueOptions> = v.UnionSchema<{
+    [K in keyof Options]: v.LiteralSchema<Options[K], undefined>;
+}, undefined>;
 export {};

package/dist/entities/option/select.js

@@ -1,19 +1,16 @@
 import * as v from 'valibot';
-import { BooleanSchema, StringSchema } from '../../primitive.js';
-import { createEntityValidator } from '../kind.js';
-import { serialisable } from '../serialisable.js';
-import { BuilderTagsSchema } from '../tags.js';
 export class BuilderSelectConfig {
-    type = 'select';
+    type = 'value';
+    kind = 'select';
     options;
     valueSchema;
     defaultValue;
     isOptional;
     optionLabels;
     tags;
-    constructor(values, defaultValue, optional = false, optionLabels = {}, tags) {
-        this.options = values;
-        this.valueSchema = selectValueSchema(values, optional);
+    constructor(options, defaultValue, optional = false, optionLabels = {}, tags) {
+        this.options = options;
+        this.valueSchema = selectValueSchema(options, optional);
         this.defaultValue = defaultValue;
         this.isOptional = optional;
         this.optionLabels = optionLabels;
@@ -37,32 +34,12 @@ export class BuilderSelectConfig {
         return this.#next({ tags });
     }
 }
-export function select(values) {
-    const [defaultValue] = values;
-    return new BuilderSelectConfig(values, defaultValue, false);
+export function valueSelect(options) {
+    const [defaultValue] = options;
+    return new BuilderSelectConfig(options, defaultValue, false);
 }
 export const BuilderSelectConfigSchema = v.instance(BuilderSelectConfig);
-export const BuilderSelectConfigSerialisedSchema = serialisable(v.object({
-    type: v.literal('select'),
-    options: v.pipe(v.tupleWithRest([StringSchema], StringSchema), v.readonly()),
-    defaultValue: v.nullable(StringSchema),
-    isOptional: BooleanSchema,
-    optionLabels: v.record(StringSchema, StringSchema),
-    tags: v.optional(BuilderTagsSchema)
-}));
 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.scope('defaultValue', () => errors.entityInvalidSelectDefault());
-    }
-    errors.scope('optionLabels', () => {
-        Object.keys(input.optionLabels).forEach((key) => {
-            if (!input.options.includes(key)) {
-                errors.scope(key, () => errors.entityInvalidSelectLabel());
-            }
-        });
-    });
-});

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

@@ -0,0 +1,73 @@
+import type { BuilderPrimitive } from '../../primitive';
+import type { BuilderTags } from '../tags';
+import * as v from 'valibot';
+export declare const BuilderValueKindSchema: v.PicklistSchema<["string", "boolean", "number", "select"], undefined>;
+export type BuilderValueKind = v.InferOutput<typeof BuilderValueKindSchema>;
+export declare class BuilderValueConfig<const ValueSchema extends v.GenericSchema<BuilderPrimitive> = v.GenericSchema<BuilderPrimitive>> {
+    #private;
+    readonly value: v.InferOutput<ValueSchema>;
+    readonly type: "value";
+    readonly kind: 'string' | 'boolean' | 'number';
+    readonly valueSchema: ValueSchema;
+    readonly defaultValue: v.InferOutput<ValueSchema>;
+    readonly isOptional: boolean;
+    readonly tags?: BuilderTags;
+    constructor(kind: 'string' | 'boolean' | 'number', defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, tags?: BuilderTags);
+    default(newDefault: v.InferOutput<ValueSchema>): BuilderValueConfig<ValueSchema>;
+    optional(): BuilderValueConfig<v.NullableSchema<ValueSchema, undefined>>;
+    tag(...tags: Array<string>): BuilderValueConfig<ValueSchema>;
+}
+export declare function valueString(): BuilderValueConfig<v.StringSchema<undefined>>;
+export declare function valueBoolean(): BuilderValueConfig<v.BooleanSchema<undefined>>;
+export declare function valueNumber(): BuilderValueConfig<v.NumberSchema<undefined>>;
+export declare const BuilderValueConfigSchema: v.InstanceSchema<typeof BuilderValueConfig, undefined>;
+export declare const BuilderValueConfigSerialisedSchema: v.SchemaWithPipe<readonly [v.VariantSchema<"kind", [v.StrictObjectSchema<{
+    readonly kind: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+    readonly type: v.LiteralSchema<"value", 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.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+    readonly kind: v.LiteralSchema<"select", undefined>;
+    readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
+    readonly optionLabels: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, undefined>;
+    readonly type: v.LiteralSchema<"value", 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.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
+}, undefined>], undefined>, v.ReadonlyAction<{
+    kind: "string" | "number" | "boolean";
+    type: "value";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+    tags?: readonly string[] | undefined;
+} | {
+    kind: "select";
+    readonly options: readonly [string, ...string[]];
+    optionLabels?: {
+        [x: string]: string;
+    } | undefined;
+    type: "value";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+    tags?: readonly string[] | undefined;
+}>]>;
+export type BuilderValueConfigSerialised = v.InferOutput<typeof BuilderValueConfigSerialisedSchema>;
+export declare function valueKindSchema(kind: 'string' | 'boolean' | 'number', optional: boolean): v.GenericSchema;
+export declare const validateValue: (input: unknown, references?: import("..").BuilderReferences, issues?: import("../../errors/errors").BuilderIssuesScope) => import("..").ValidationResult<{
+    readonly kind: "string" | "number" | "boolean";
+    readonly type: "value";
+    readonly defaultValue: string | number | boolean | null;
+    readonly isOptional: boolean;
+    readonly tags?: readonly string[] | undefined;
+} | {
+    readonly kind: "select";
+    readonly options: readonly [string, ...string[]];
+    readonly optionLabels?: ({
+        readonly [x: string]: string;
+    } & import("../../validate").BuilderValidatedBrand) | undefined;
+    readonly type: "value";
+    readonly defaultValue: string | number | boolean | null;
+    readonly isOptional: boolean;
+    readonly tags?: readonly string[] | undefined;
+}>;

package/dist/entities/option/value.js

@@ -0,0 +1,99 @@
+import * as v from 'valibot';
+import { check } from '../../errors/index.js';
+import { BooleanSchema, NumberSchema, StringSchema } from '../../primitive.js';
+import { createEntityValidator } from '../kind.js';
+import { serialisable } from '../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
+export const BuilderValueKindSchema = v.picklist(['string', 'boolean', 'number', 'select']);
+export class BuilderValueConfig {
+    type = 'value';
+    kind;
+    valueSchema;
+    defaultValue;
+    isOptional;
+    tags;
+    constructor(kind, defaultValue, optional, tags) {
+        this.kind = kind;
+        this.valueSchema = valueKindSchema(kind, optional || false);
+        this.defaultValue = defaultValue;
+        this.isOptional = optional || false;
+        this.tags = tags;
+    }
+    #next(patch) {
+        return new BuilderValueConfig(this.kind, 'defaultValue' in patch
+            ? patch.defaultValue
+            : this.defaultValue, patch.optional ?? this.isOptional, patch.tags ?? this.tags);
+    }
+    default(newDefault) {
+        return this.#next({ defaultValue: newDefault });
+    }
+    optional() {
+        return this.#next({ optional: true });
+    }
+    tag(...tags) {
+        return this.#next({ tags });
+    }
+}
+export function valueString() {
+    return new BuilderValueConfig('string', '');
+}
+export function valueBoolean() {
+    return new BuilderValueConfig('boolean', false);
+}
+export function valueNumber() {
+    return new BuilderValueConfig('number', 0);
+}
+export const BuilderValueConfigSchema = v.instance(BuilderValueConfig);
+const valueConfigSerialisedFields = {
+    type: v.literal('value'),
+    defaultValue: v.nullable(v.union([BooleanSchema, StringSchema, NumberSchema])),
+    isOptional: BooleanSchema,
+    tags: v.optional(BuilderTagsSchema)
+};
+// The wire shape mirrors the authoring split: `options`/`optionLabels` live only on a `select`, and
+// a `select` must carry `options`. So a hand-built object can't put options on a plain value, nor omit
+// them from a select — the same guarantee the two config classes give, enforced at validation too.
+export const BuilderValueConfigSerialisedSchema = serialisable(v.variant('kind', [
+    v.strictObject({
+        ...valueConfigSerialisedFields,
+        kind: v.picklist(['string', 'boolean', 'number'])
+    }),
+    v.strictObject({
+        ...valueConfigSerialisedFields,
+        kind: v.literal('select'),
+        options: v.pipe(v.tupleWithRest([StringSchema], StringSchema), v.readonly()),
+        optionLabels: v.optional(v.record(StringSchema, StringSchema))
+    })
+]));
+export function valueKindSchema(kind, optional) {
+    const kindSchemas = {
+        string: StringSchema,
+        boolean: BooleanSchema,
+        number: NumberSchema
+    };
+    const baseSchema = kindSchemas[kind];
+    return optional ? v.nullable(baseSchema) : baseSchema;
+}
+export const validateValue = createEntityValidator('value', BuilderValueConfigSerialisedSchema, (input, errors) => {
+    if (input.kind === 'select') {
+        const options = input.options;
+        if (input.defaultValue != null && !options.includes(`${input.defaultValue}`)) {
+            errors.scope('defaultValue', () => errors.entityInvalidSelectDefault());
+        }
+        errors.scope('optionLabels', () => {
+            Object.keys(input.optionLabels ?? {}).forEach((key) => {
+                if (!options.includes(key)) {
+                    errors.scope(key, () => errors.entityInvalidSelectLabel());
+                }
+            });
+        });
+        return;
+    }
+    if (input.defaultValue == null) {
+        return;
+    }
+    const valueSchema = valueKindSchema(input.kind, input.isOptional);
+    if (!check.is(valueSchema, input.defaultValue)) {
+        errors.scope('defaultValue', () => errors.entityInvalidValueDefault());
+    }
+});

package/dist/entities/paths.d.ts

@@ -3,5 +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.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, 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").BuilderErrorsScope) => import("./validated.js").ValidationResult<readonly (string | number)[]>;
-export declare const validatePaths: (input: unknown, references?: import("./references.js").BuilderReferences, errors?: import("../errors/errors.js").BuilderErrorsScope) => import("./validated.js").ValidationResult<readonly (readonly (string | number)[])[]>;
+export declare const validatePath: (input: unknown, references?: import("./references.js").BuilderReferences, issues?: import("../errors/errors.js").BuilderIssuesScope) => import("./validated.js").ValidationResult<readonly (string | number)[]>;
+export declare const validatePaths: (input: unknown, references?: import("./references.js").BuilderReferences, issues?: import("../errors/errors.js").BuilderIssuesScope) => import("./validated.js").ValidationResult<readonly (readonly (string | number)[])[]>;

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

@@ -9,62 +9,39 @@ export type BuilderPricingLookupKey = {
     readonly name: string;
 };
 export declare const BuilderPricingLookupKeySchema: v.GenericSchema<BuilderPricingLookupKey>;
-export type BuilderPricingExpression = number | {
+type BuilderPricingLiteral = number;
+type BuilderPricingVariantPrice = {
     readonly kind: 'variantPrice';
-} | {
+};
+export type BuilderPricingLookup = {
     readonly kind: 'lookup';
     readonly rate: string;
     readonly key: BuilderPricingLookupKey;
     readonly reduce?: BuilderPricingReduce;
-} | {
+};
+export type BuilderPricingVariants = {
     readonly kind: 'variants';
     readonly tag?: string;
     readonly expression: Paramable<BuilderPricingExpression>;
     readonly reduce?: BuilderPricingReduce;
-} | {
-    readonly kind: 'add';
-    readonly left: Paramable<BuilderPricingExpression>;
-    readonly right: Paramable<BuilderPricingExpression>;
-} | {
-    readonly kind: 'sub';
-    readonly left: Paramable<BuilderPricingExpression>;
-    readonly right: Paramable<BuilderPricingExpression>;
-} | {
-    readonly kind: 'mul';
-    readonly left: Paramable<BuilderPricingExpression>;
-    readonly right: Paramable<BuilderPricingExpression>;
-} | {
-    readonly kind: 'div';
+};
+type BuilderPricingArithmetic = {
+    readonly kind: 'add' | 'sub' | 'mul' | 'div';
     readonly left: Paramable<BuilderPricingExpression>;
     readonly right: Paramable<BuilderPricingExpression>;
 };
-export type BuilderPricingExpressionSerialised = number | {
-    readonly kind: 'variantPrice';
-} | {
-    readonly kind: 'lookup';
-    readonly rate: string;
-    readonly key: BuilderPricingLookupKey;
-    readonly reduce?: BuilderPricingReduce;
-} | {
+export type BuilderPricingExpression = BuilderPricingLiteral | BuilderPricingVariantPrice | BuilderPricingLookup | BuilderPricingVariants | BuilderPricingArithmetic;
+type BuilderPricingVariantsSerialised = {
     readonly kind: 'variants';
     readonly tag?: string;
     readonly expression: ParamableSerialised<BuilderPricingExpressionSerialised>;
     readonly reduce?: BuilderPricingReduce;
-} | {
-    readonly kind: 'add';
-    readonly left: ParamableSerialised<BuilderPricingExpressionSerialised>;
-    readonly right: ParamableSerialised<BuilderPricingExpressionSerialised>;
-} | {
-    readonly kind: 'sub';
-    readonly left: ParamableSerialised<BuilderPricingExpressionSerialised>;
-    readonly right: ParamableSerialised<BuilderPricingExpressionSerialised>;
-} | {
-    readonly kind: 'mul';
-    readonly left: ParamableSerialised<BuilderPricingExpressionSerialised>;
-    readonly right: ParamableSerialised<BuilderPricingExpressionSerialised>;
-} | {
-    readonly kind: 'div';
+};
+type BuilderPricingArithmeticSerialised = {
+    readonly kind: 'add' | 'sub' | 'mul' | 'div';
     readonly left: ParamableSerialised<BuilderPricingExpressionSerialised>;
     readonly right: ParamableSerialised<BuilderPricingExpressionSerialised>;
 };
+export type BuilderPricingExpressionSerialised = BuilderPricingLiteral | BuilderPricingVariantPrice | BuilderPricingLookup | BuilderPricingVariantsSerialised | BuilderPricingArithmeticSerialised;
 export declare const BuilderPricingExpressionSchema: v.GenericSchema<BuilderPricingExpression>;
+export {};

package/dist/entities/pricing/expression.js

@@ -22,22 +22,7 @@ export const BuilderPricingExpressionSchema = v.lazy(() => v.union([
         reduce: v.optional(BuilderPricingReduceSchema)
     }),
     v.object({
-        kind: v.literal('add'),
-        left: paramable(BuilderPricingExpressionSchema),
-        right: paramable(BuilderPricingExpressionSchema)
-    }),
-    v.object({
-        kind: v.literal('sub'),
-        left: paramable(BuilderPricingExpressionSchema),
-        right: paramable(BuilderPricingExpressionSchema)
-    }),
-    v.object({
-        kind: v.literal('mul'),
-        left: paramable(BuilderPricingExpressionSchema),
-        right: paramable(BuilderPricingExpressionSchema)
-    }),
-    v.object({
-        kind: v.literal('div'),
+        kind: v.picklist(['add', 'sub', 'mul', 'div']),
         left: paramable(BuilderPricingExpressionSchema),
         right: paramable(BuilderPricingExpressionSchema)
     })

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

@@ -1,4 +1,4 @@
-export type { BuilderPricingExpression, BuilderPricingLookupKey, BuilderPricingReduce } from './expression';
+export type { BuilderPricingExpression, BuilderPricingLookup, BuilderPricingLookupKey, BuilderPricingReduce, BuilderPricingVariants } from './expression';
 export type { BuilderRates } from './rates';
 export type { BuilderPricingSerialised } from './pricing';
 export { BuilderPricingExpressionSchema, BuilderPricingLookupKeySchema, BuilderPricingReduceSchema } from './expression.js';

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

@@ -1,7 +1,7 @@
 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").BuilderErrorsScope) => import("../validated.js").ValidationResult<{
+export declare const validatePricingRates: (input: unknown, references?: import("../references.js").BuilderReferences, issues?: import("../../errors/errors.js").BuilderIssuesScope) => import("../validated.js").ValidationResult<{
     readonly [x: string]: {
         readonly [x: string]: number;
     } & import("../../validate/brand.js").BuilderValidatedBrand;