@builder-builder/builder 0.0.10 → 0.0.11

package/dist/mappers/variants/variants.js

@@ -0,0 +1,57 @@
+import { check } from '../../check.js';
+import { BuilderSerialisedSchema } from '../../entities/index.js';
+import { resolveCollection } from '../resolve.js';
+import { BuilderOptionGraph, crossProduct, dependencyKeys } from './option-graph.js';
+export function createVariants(entity) {
+    const model = check.is(BuilderSerialisedSchema, entity) ? entity.model : entity;
+    return buildVariants(model);
+}
+function buildVariants(model) {
+    const options = optionGraph(model.options);
+    const nestedVariants = model.collections.flatMap((entry) => variantsFor(entry, options).flatMap((instance) => {
+        const resolved = resolveCollection(entry, instance);
+        return resolved == null ? [] : [buildVariants(resolved.model)];
+    }));
+    return {
+        ...nestedVariants.reduce((merged, component) => ({ ...merged, ...component }), {}),
+        ...Object.fromEntries(model.components.map((component) => [
+            component.name,
+            variantsFor(component, options).map((instance) => ({ instance }))
+        ]))
+    };
+}
+function optionGraph(options) {
+    return options.reduce((graph, option) => graph.add(option), new BuilderOptionGraph());
+}
+function variantsFor(entity, options) {
+    const keys = new Set(dependencyKeys(entity.payload, entity.paths));
+    const graphPaths = Array.from(keys)
+        .map((key) => options.get(key))
+        .sort((pathA, pathB) => pathB.keys.size - pathA.keys.size);
+    const handledKeys = new Set();
+    let variants = [{}];
+    graphPaths.forEach((graphPath) => {
+        const isHandled = handledKeys.has(graphPath.name) &&
+            Array.from(graphPath.keys).every((key) => handledKeys.has(key));
+        if (!isHandled) {
+            const pickedInstances = pickKeys(graphPath, keys);
+            variants = crossProduct(variants, pickedInstances);
+            handledKeys.add(graphPath.name);
+            graphPath.keys.forEach((key) => handledKeys.add(key));
+        }
+    });
+    return variants;
+}
+function pickKeys(graphPath, keys) {
+    const seen = new Set();
+    const picked = [];
+    graphPath.instances.forEach((instance) => {
+        const filtered = Object.fromEntries(Object.entries(instance).filter(([key, value]) => keys.has(key) && value != null));
+        const identity = JSON.stringify(filtered);
+        if (identity !== '{}' && !seen.has(identity)) {
+            seen.add(identity);
+            picked.push(filtered);
+        }
+    });
+    return picked;
+}

package/dist/private.d.ts

@@ -0,0 +1,4 @@
+export { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSchema, BuilderComponentFieldsSerialisedSchema, BuilderComponentFieldValueTypeSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderDescriptionItemSchema, BuilderDescriptionSchema, BuilderEntityKindSchema, BuilderEntitySerialisedSchema, BuilderExpectationKindSchema, BuilderExpectationSchema, BuilderExpectationSerialisedSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema, BuilderModelSchema, BuilderModelSerialisedSchema, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionValuesSchema, BuilderOptionValuesSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSchema, BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, BuilderSerialisedSchema, BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema, BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema, BuilderWhenConfigSchema, BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from './entities/index.js';
+export { BuilderEnvironmentSchema } from './environment.js';
+export { BuilderComponentVariantsSchema, BuilderVariantsSchema } from './instance.js';
+export { BuilderPathSchema, BuilderPathsSchema } from './paths.js';

package/dist/private.js

@@ -0,0 +1,4 @@
+export { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentFieldSerialisedSchema, BuilderComponentFieldsSchema, BuilderComponentFieldsSerialisedSchema, BuilderComponentFieldValueTypeSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentSerialisedSchema, BuilderComponentsSerialisedSchema, BuilderComponentWhenSerialisedSchema, BuilderDescriptionItemSchema, BuilderDescriptionSchema, BuilderEntityKindSchema, BuilderEntitySerialisedSchema, BuilderExpectationKindSchema, BuilderExpectationSchema, BuilderExpectationSerialisedSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema, BuilderModelSchema, BuilderModelSerialisedSchema, BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionsSerialisedSchema, BuilderOptionValuesSchema, BuilderOptionValuesSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSchema, BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, BuilderSerialisedSchema, BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema, BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema, BuilderWhenConfigSchema, BuilderWhenEnableSchema, BuilderWhenMatchSchema, BuilderWhenUnlessSchema } from './entities/index.js';
+export { BuilderEnvironmentSchema } from './environment.js';
+export { BuilderComponentVariantsSchema, BuilderVariantsSchema } from './instance.js';
+export { BuilderPathSchema, BuilderPathsSchema } from './paths.js';

package/dist/references.d.ts

@@ -1,17 +1,12 @@
 import * as v from 'valibot';
-export type Paramable<Value> = Value | BuilderParameter;
-export type ParamableSerialised<Value> = Value | BuilderParameterSerialised;
-export type ParamableMetadata = {
-    readonly paramable?: v.GenericSchema;
-};
+export type Paramable<Value> = Value | BuilderParameter | BuilderRef;
+export type ParamableSerialised<Value> = Value | BuilderParameterSerialised | BuilderRefSerialised;
 export declare class BuilderParameter<const Name extends string = string> {
     readonly id: string;
     readonly name: Name;
     constructor(name: Name, id?: string);
 }
 export declare const BuilderParameterSchema: v.InstanceSchema<typeof BuilderParameter, undefined>;
-export declare const BuilderParametersSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.InstanceSchema<typeof BuilderParameter, undefined>, undefined>, v.ReadonlyAction<BuilderParameter<string>[]>]>;
-export type BuilderParameters = v.InferOutput<typeof BuilderParametersSchema>;
 export declare const BuilderParameterSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"parameter", undefined>;
     readonly id: v.StringSchema<undefined>;
@@ -22,50 +17,23 @@ export declare const BuilderParameterSerialisedSchema: v.SchemaWithPipe<readonly
     name: string;
 }>]>;
 export type BuilderParameterSerialised = v.InferOutput<typeof BuilderParameterSerialisedSchema>;
-export declare const BuilderParametersSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<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: "parameter";
-    id: string;
-    name: string;
-}>]>, undefined>, v.ReadonlyAction<Readonly<{
-    type: "parameter";
-    id: string;
-    name: string;
-}>[]>]>;
-export type BuilderParametersSerialised = v.InferOutput<typeof BuilderParametersSerialisedSchema>;
 export declare class BuilderRef {
+    readonly type: "ref";
     readonly id: string;
     constructor(id: string);
 }
 export declare const BuilderRefSchema: v.InstanceSchema<typeof BuilderRef, undefined>;
-export declare const BuilderReferenceSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly parameter: v.StringSchema<undefined>;
+export declare const BuilderRefSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"ref", undefined>;
     readonly id: v.StringSchema<undefined>;
 }, undefined>, v.ReadonlyAction<{
-    parameter: string;
+    type: "ref";
     id: string;
 }>]>;
-export type BuilderReference = v.InferOutput<typeof BuilderReferenceSchema>;
-export declare const BuilderReferencesSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly parameter: v.StringSchema<undefined>;
-    readonly id: v.StringSchema<undefined>;
-}, undefined>, v.ReadonlyAction<{
-    parameter: string;
-    id: string;
-}>]>, undefined>, v.ReadonlyAction<Readonly<{
-    parameter: string;
-    id: string;
-}>[]>]>;
-export type BuilderReferences = v.InferOutput<typeof BuilderReferencesSchema>;
-export declare function isParameter(value: unknown): value is BuilderParameter;
-export declare function isSerialisedParameter(value: unknown): value is BuilderParameterSerialised;
-export declare function isRef(value: unknown): value is BuilderRef;
+export type BuilderRefSerialised = v.InferOutput<typeof BuilderRefSerialisedSchema>;
 export declare function parameter<const Name extends string>(name: Name): BuilderParameter<Name>;
 export declare function ref(id: string): BuilderRef;
-export declare function paramable<Schema extends v.GenericSchema>(paramable: Schema): v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
+export declare function paramable<Schema extends v.GenericSchema>(paramable: Schema): v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"parameter", undefined>;
     readonly id: v.StringSchema<undefined>;
     readonly name: v.StringSchema<undefined>;
@@ -73,14 +41,11 @@ export declare function paramable<Schema extends v.GenericSchema>(paramable: Sch
     type: "parameter";
     id: string;
     name: string;
-}>]>, v.InstanceSchema<typeof BuilderParameter, undefined>, Schema], undefined>, v.MetadataAction<v.InferOutput<v.SchemaWithPipe<readonly [v.ObjectSchema<{
-    readonly type: v.LiteralSchema<"parameter", undefined>;
+}>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"ref", undefined>;
     readonly id: v.StringSchema<undefined>;
-    readonly name: v.StringSchema<undefined>;
 }, undefined>, v.ReadonlyAction<{
-    type: "parameter";
+    type: "ref";
     id: string;
-    name: string;
-}>]> | v.InstanceSchema<typeof BuilderParameter, undefined> | Schema>, {
-    readonly paramable: Schema;
-}>]>;
+}>]>, Schema], undefined>;
+export declare function isParamable(value: unknown): boolean;

package/dist/references.js

@@ -9,27 +9,16 @@ export class BuilderParameter {
     }
 }
 export const BuilderParameterSchema = v.instance(BuilderParameter);
-export const BuilderParametersSchema = v.pipe(v.array(BuilderParameterSchema), v.readonly());
 export const BuilderParameterSerialisedSchema = v.pipe(v.object({ type: v.literal('parameter'), id: v.string(), name: v.string() }), v.readonly());
-export const BuilderParametersSerialisedSchema = v.pipe(v.array(BuilderParameterSerialisedSchema), v.readonly());
 export class BuilderRef {
+    type = 'ref';
     id;
     constructor(id) {
         this.id = id;
     }
 }
 export const BuilderRefSchema = v.instance(BuilderRef);
-export const BuilderReferenceSchema = v.pipe(v.object({ parameter: v.string(), id: v.string() }), v.readonly());
-export const BuilderReferencesSchema = v.pipe(v.array(BuilderReferenceSchema), v.readonly());
-export function isParameter(value) {
-    return check.is(BuilderParameterSchema, value);
-}
-export function isSerialisedParameter(value) {
-    return check.is(BuilderParameterSerialisedSchema, value);
-}
-export function isRef(value) {
-    return check.is(BuilderRefSchema, value);
-}
+export const BuilderRefSerialisedSchema = v.pipe(v.object({ type: v.literal('ref'), id: v.string() }), v.readonly());
 export function parameter(name) {
     return new BuilderParameter(name);
 }
@@ -37,5 +26,8 @@ export function ref(id) {
     return new BuilderRef(id);
 }
 export function paramable(paramable) {
-    return v.pipe(v.union([BuilderParameterSerialisedSchema, BuilderParameterSchema, paramable]), v.metadata({ paramable }));
+    return v.union([BuilderParameterSerialisedSchema, BuilderRefSerialisedSchema, paramable]);
+}
+export function isParamable(value) {
+    return (check.is(BuilderParameterSerialisedSchema, value) || check.is(BuilderRefSerialisedSchema, value));
 }

package/dist/serialisable.d.ts

@@ -1,10 +1,2 @@
 import * as v from 'valibot';
-export type SerialisableClass = new (...args: ReadonlyArray<never>) => object;
-export type SerialisableMetadata = {
-    readonly serialisable?: SerialisableClass;
-    readonly instance?: v.GenericSchema;
-};
-export declare function serialisable<Serialisable extends SerialisableClass, Schema extends v.GenericSchema>(serialisable: Serialisable, schema: Schema): v.SchemaWithPipe<readonly [Schema, v.MetadataAction<v.InferOutput<Schema>, {
-    readonly serialisable: Serialisable;
-    readonly instance: v.InstanceSchema<Serialisable, undefined>;
-}>, v.ReadonlyAction<v.InferOutput<Schema>>]>;
+export declare function serialisable<Schema extends v.GenericSchema>(schema: Schema): v.SchemaWithPipe<readonly [Schema, v.ReadonlyAction<v.InferOutput<Schema>>]>;

package/dist/serialisable.js

@@ -1,5 +1,4 @@
 import * as v from 'valibot';
-export function serialisable(serialisable, schema) {
-    const instance = v.instance(serialisable);
-    return v.pipe(schema, v.metadata({ serialisable, instance }), v.readonly());
+export function serialisable(schema) {
+    return v.pipe(schema, v.readonly());
 }

package/dist/validate/brand.d.ts

@@ -0,0 +1,14 @@
+import type { BuilderErrorLocation } from '../exception';
+declare const VALIDATED: unique symbol;
+export type BuilderValidatedBrand = {
+    readonly [VALIDATED]: true;
+};
+export declare function builderErrorUnvalidated(value: unknown, location?: BuilderErrorLocation): {
+    value: unknown;
+    kind: "unvalidated";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorUnvalidated = ReturnType<typeof builderErrorUnvalidated>;
+export declare function validate<Input extends object>(value: Input): Input & BuilderValidatedBrand;
+export declare function assertValidated<Input>(value: Input): asserts value is Input & BuilderValidatedBrand;
+export {};

package/dist/validate/brand.js

@@ -0,0 +1,17 @@
+import { builderError, BuilderException } from '../exception.js';
+const VALIDATED = Symbol('builder.validated');
+export function builderErrorUnvalidated(value, location = []) {
+    return { ...builderError('unvalidated', location), value };
+}
+export function validate(value) {
+    Object.defineProperty(value, VALIDATED, {
+        value: true,
+        enumerable: false
+    });
+    return value;
+}
+export function assertValidated(value) {
+    if (typeof value !== 'object' || value === null || !(VALIDATED in value)) {
+        throw new BuilderException([builderErrorUnvalidated(value)]);
+    }
+}

package/dist/validate/builder.d.ts

@@ -0,0 +1,4 @@
+import type { BuilderRefEntities, BuilderValidated } from '../entities/index';
+import type { ValidationResult } from './result';
+export type BuilderValidationResult = ValidationResult<BuilderValidated>;
+export declare function validateBuilder(input: unknown, references?: BuilderRefEntities): BuilderValidationResult;

package/dist/validate/builder.js

@@ -0,0 +1,27 @@
+import { check } from '../check.js';
+import { builder, BuilderSerialisedSchema, modelsMerge, serialise } from '../entities/index.js';
+import { validate } from './brand.js';
+import { checkModelExpectations, validateModelStructure } from './model.js';
+import { resolver } from './resolve.js';
+import { builderErrorInvalidInput } from './result.js';
+import { checkUIExpectations, validateUIStructure } from './ui.js';
+export function validateBuilder(input, references = []) {
+    if (!check.is(BuilderSerialisedSchema, input)) {
+        const errors = [builderErrorInvalidInput('builder')];
+        return [validate(serialise.builder(builder())), errors];
+    }
+    const resolve = resolver(references, input.bindings);
+    const [validatedModel, modelErrors] = validateModelStructure(input.model, resolve, ['model']);
+    const [validatedUI, uiErrors] = validateUIStructure(input.ui, resolve, ['ui']);
+    const mergedModel = modelsMerge(validatedModel);
+    const expectationErrors = [
+        ...checkModelExpectations(mergedModel, validatedModel, ['model']),
+        ...checkUIExpectations(mergedModel, validatedUI, ['ui'])
+    ];
+    const data = validate({
+        ...serialise.builder(builder()),
+        model: mergedModel,
+        ui: validatedUI
+    });
+    return [data, [...expectationErrors, ...modelErrors, ...uiErrors]];
+}

package/dist/validate/expectations.d.ts

@@ -0,0 +1,10 @@
+import type { BuilderExpectationKind, BuilderExpectationsSerialised, BuilderModelSerialised } from '../entities/index';
+import type { BuilderErrorLocation, BuilderErrors } from '../exception';
+export declare function builderErrorUnmetExpectation(expectationKind: BuilderExpectationKind, name: string, location?: BuilderErrorLocation): {
+    expectationKind: "option" | "component" | "collection";
+    name: string;
+    kind: "unmet-expectation";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorUnmetExpectation = ReturnType<typeof builderErrorUnmetExpectation>;
+export declare function checkExpectations(model: BuilderModelSerialised, expectations: BuilderExpectationsSerialised, location: BuilderErrorLocation): BuilderErrors;

package/dist/validate/expectations.js

@@ -0,0 +1,12 @@
+import { builderError } from '../exception.js';
+export function builderErrorUnmetExpectation(expectationKind, name, location = []) {
+    return { ...builderError('unmet-expectation', location), expectationKind, name };
+}
+export function checkExpectations(model, expectations, location) {
+    return expectations.flatMap(({ kind, name }, index) => {
+        if (model[`${kind}s`].some((entry) => entry.name === name)) {
+            return [];
+        }
+        return [builderErrorUnmetExpectation(kind, name, [...location, index])];
+    });
+}

package/dist/validate/index.d.ts

@@ -0,0 +1,18 @@
+export type { BuilderErrorUnvalidated } from './brand';
+export type { BuilderValidationResult } from './builder';
+export type { BuilderErrorUnmetExpectation } from './expectations';
+export type { BuilderErrorInvalidCollection, BuilderErrorInvalidOption, BuilderInstanceValidationResult } from './instance';
+export type { BuilderErrorDuplicateName, BuilderErrorInvalidCollectionBounds, BuilderErrorInvalidPath, BuilderErrorInvalidPathReason, BuilderErrorInvalidSelectMapKey, BuilderModelValidationResult } from './model';
+export type { BuilderErrorMissingReference, BuilderErrorUnboundParameter } from './resolve';
+export type { BuilderErrorInvalidInput } from './result';
+export type { BuilderUIValidationResult } from './ui';
+export type { BuilderComponentVariantsValidationResult, BuilderErrorInvalidDetail, BuilderErrorInvalidVariant, BuilderErrorMissingComponent, BuilderErrorMissingDetail, BuilderErrorMissingVariant, BuilderErrorUnexpectedComponent, BuilderErrorUnexpectedDetail, BuilderVariantsValidationOptions } from './variants';
+export { assertValidated, builderErrorUnvalidated } from './brand.js';
+export { validateBuilder } from './builder.js';
+export { builderErrorUnmetExpectation } from './expectations.js';
+export { builderErrorInvalidCollection, builderErrorInvalidOption, validateInstance } from './instance.js';
+export { builderErrorDuplicateName, builderErrorInvalidCollectionBounds, builderErrorInvalidPath, builderErrorInvalidSelectMapKey, validateModel } from './model.js';
+export { builderErrorMissingReference, builderErrorUnboundParameter } from './resolve.js';
+export { builderErrorInvalidInput } from './result.js';
+export { validateUI } from './ui.js';
+export { builderErrorInvalidDetail, builderErrorInvalidVariant, builderErrorMissingComponent, builderErrorMissingDetail, builderErrorMissingVariant, builderErrorUnexpectedComponent, builderErrorUnexpectedDetail, validateVariants } from './variants.js';

package/dist/validate/index.js

@@ -0,0 +1,9 @@
+export { assertValidated, builderErrorUnvalidated } from './brand.js';
+export { validateBuilder } from './builder.js';
+export { builderErrorUnmetExpectation } from './expectations.js';
+export { builderErrorInvalidCollection, builderErrorInvalidOption, validateInstance } from './instance.js';
+export { builderErrorDuplicateName, builderErrorInvalidCollectionBounds, builderErrorInvalidPath, builderErrorInvalidSelectMapKey, validateModel } from './model.js';
+export { builderErrorMissingReference, builderErrorUnboundParameter } from './resolve.js';
+export { builderErrorInvalidInput } from './result.js';
+export { validateUI } from './ui.js';
+export { builderErrorInvalidDetail, builderErrorInvalidVariant, builderErrorMissingComponent, builderErrorMissingDetail, builderErrorMissingVariant, builderErrorUnexpectedComponent, builderErrorUnexpectedDetail, validateVariants } from './variants.js';

package/dist/validate/instance.d.ts

@@ -0,0 +1,19 @@
+import type { BuilderInstanceValidated, BuilderModelValidated } from '../entities/index';
+import type { BuilderErrorLocation } from '../exception';
+import type { BuilderInstance } from '../instance';
+import type { ValidationResult } from './result';
+export declare function builderErrorInvalidOption(name: string, value: unknown, location?: BuilderErrorLocation): {
+    name: string;
+    value: unknown;
+    kind: "invalid-option";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorInvalidOption = ReturnType<typeof builderErrorInvalidOption>;
+export declare function builderErrorInvalidCollection(name: string, location?: BuilderErrorLocation): {
+    name: string;
+    kind: "invalid-collection";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorInvalidCollection = ReturnType<typeof builderErrorInvalidCollection>;
+export type BuilderInstanceValidationResult = ValidationResult<BuilderInstanceValidated>;
+export declare function validateInstance(model: BuilderModelValidated, instance: BuilderInstance): BuilderInstanceValidationResult;

package/dist/validate/instance.js

@@ -0,0 +1,46 @@
+import { check } from '../check.js';
+import { optionValueSchema } from '../entities/index.js';
+import { builderError } from '../exception.js';
+import { resolveCollection, resolveOption } from '../mappers/index.js';
+import { validate } from './brand.js';
+export function builderErrorInvalidOption(name, value, location = []) {
+    return { ...builderError('invalid-option', location), name, value };
+}
+export function builderErrorInvalidCollection(name, location = []) {
+    return { ...builderError('invalid-collection', location), name };
+}
+export function validateInstance(model, instance) {
+    const errors = checkInstance(model, instance, ['instance']);
+    return [validate(instance), errors];
+}
+function checkInstance(model, instance, location) {
+    const { options, collections } = model;
+    const optionErrors = options.flatMap((option) => {
+        const { name } = option;
+        const payload = resolveOption(option, instance);
+        if (!payload) {
+            return [];
+        }
+        const value = instance[name];
+        if (!check.is(optionValueSchema(payload), value)) {
+            return [builderErrorInvalidOption(name, value, [...location, name])];
+        }
+        return [];
+    });
+    const collectionErrors = collections.flatMap((collection) => {
+        const { name } = collection;
+        const payload = resolveCollection(collection, instance);
+        if (!payload) {
+            return [];
+        }
+        const existing = instance[name];
+        if (!Array.isArray(existing)) {
+            return [builderErrorInvalidCollection(name, [...location, name])];
+        }
+        return existing.flatMap((itemInstance, index) => checkInstance(payload.model, itemInstance, [...location, name, index]).map((error) => ({
+            ...error,
+            name: `${name}[${index}].${error.name}`
+        })));
+    });
+    return [...optionErrors, ...collectionErrors];
+}

package/dist/validate/model.d.ts

@@ -0,0 +1,36 @@
+import type { BuilderModelSerialised, BuilderModelValidated, BuilderRefEntities } from '../entities/index';
+import type { BuilderErrorLocation, BuilderErrors } from '../exception';
+import type { ParamableSerialised } from '../references';
+import type { BuilderResolve } from './resolve';
+import type { ValidationResult } from './result';
+export type BuilderModelValidationResult = ValidationResult<BuilderModelValidated>;
+export declare function builderErrorDuplicateName(name: string, location?: BuilderErrorLocation): {
+    name: string;
+    kind: "duplicate-name";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorDuplicateName = ReturnType<typeof builderErrorDuplicateName>;
+export declare function builderErrorInvalidCollectionBounds(name: string, min: number, max: number, location?: BuilderErrorLocation): {
+    name: string;
+    min: number;
+    max: number;
+    kind: "invalid-collection-bounds";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorInvalidCollectionBounds = ReturnType<typeof builderErrorInvalidCollectionBounds>;
+export type BuilderErrorInvalidPathReason = 'shape' | 'out-of-bounds' | 'missing-collection' | 'option-not-found';
+export declare function builderErrorInvalidPath(reason: BuilderErrorInvalidPathReason, location?: BuilderErrorLocation): {
+    reason: BuilderErrorInvalidPathReason;
+    kind: "invalid-path";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorInvalidPath = ReturnType<typeof builderErrorInvalidPath>;
+export declare function builderErrorInvalidSelectMapKey(key: string, location?: BuilderErrorLocation): {
+    key: string;
+    kind: "invalid-select-map-key";
+    location: BuilderErrorLocation;
+};
+export type BuilderErrorInvalidSelectMapKey = ReturnType<typeof builderErrorInvalidSelectMapKey>;
+export declare function validateModel(input: unknown, references?: BuilderRefEntities): BuilderModelValidationResult;
+export declare function checkModelExpectations(mergedModel: BuilderModelSerialised, model: BuilderModelSerialised, location: BuilderErrorLocation): BuilderErrors;
+export declare function validateModelStructure(input: ParamableSerialised<BuilderModelSerialised>, resolve: BuilderResolve, location: BuilderErrorLocation): BuilderModelValidationResult;