@builder-builder/builder 0.0.5 → 0.0.7

package/dist/resolve/instance.d.ts

@@ -1,3 +1,35 @@
 import type { BuilderGeneric, BuilderModelOf } from '../core/index';
-import type { BuilderModelInput } from '../model';
-export declare function instance<const Builder extends BuilderGeneric>(builder: Builder, partial?: BuilderModelInput): BuilderModelOf<Builder>;
+import type { BuilderModel, BuilderModelInput } from '../model';
+declare const modelValidated: unique symbol;
+export type BuilderModelValidated = BuilderModel & {
+    readonly [modelValidated]: true;
+};
+export type BuilderModelValidateErrorInvalidOption = {
+    readonly kind: 'invalid-option';
+    readonly name: string;
+    readonly value: unknown;
+};
+export type BuilderModelValidateErrorInvalidCollection = {
+    readonly kind: 'invalid-collection';
+    readonly name: string;
+    readonly detail: string;
+};
+export type BuilderModelValidateError = BuilderModelValidateErrorInvalidOption | BuilderModelValidateErrorInvalidCollection;
+export type BuilderModelValidateErrors = ReadonlyArray<BuilderModelValidateError>;
+export type BuilderModelValidateResult = readonly [
+    BuilderModelValidated,
+    BuilderModelValidateErrors
+];
+export type BuilderModelValidateOptions = {
+    readonly strict: true;
+};
+export declare class BuilderModelValidateException extends Error {
+    readonly errors: BuilderModelValidateErrors;
+    constructor(errors: BuilderModelValidateErrors);
+}
+export declare function validateInstance(builder: BuilderGeneric, model: BuilderModel, options?: BuilderModelValidateOptions): BuilderModelValidateResult;
+export declare const instance: typeof createInstance & {
+    validate: typeof validateInstance;
+};
+declare function createInstance<const Builder extends BuilderGeneric>(builder: Builder, partial?: BuilderModelInput): BuilderModelOf<Builder> & BuilderModelValidated;
+export {};

package/dist/resolve/instance.js

@@ -1,6 +1,60 @@
 import * as v from 'valibot';
 import { resolveCollectionModels } from '../core/index.js';
-export function instance(builder, partial = {}) {
+export class BuilderModelValidateException extends Error {
+    errors;
+    constructor(errors) {
+        super('model validation failed');
+        this.errors = errors;
+    }
+}
+export function validateInstance(builder, model, options) {
+    const errors = validateModel(builder, model);
+    if (options?.strict && errors.length > 0) {
+        throw new BuilderModelValidateException(errors);
+    }
+    return [model, errors];
+}
+export const instance = Object.assign(createInstance, { validate: validateInstance });
+function validateModel(builder, model) {
+    let errors = [];
+    builder.options.forEach((entry) => {
+        const option = entry.resolve(model);
+        if (!option) {
+            return;
+        }
+        const value = model[option.name];
+        if (!v.is(option.values.valueSchema, value)) {
+            errors = [...errors, { kind: 'invalid-option', name: option.name, value }];
+        }
+    });
+    builder.collections.forEach((entry) => {
+        const collection = entry.resolve(model);
+        if (!collection) {
+            return;
+        }
+        const existing = model[collection.name];
+        if (!Array.isArray(existing)) {
+            errors = [
+                ...errors,
+                { kind: 'invalid-collection', name: collection.name, detail: 'expected an array' }
+            ];
+            return;
+        }
+        const collectionModels = resolveCollectionModels(model, collection.name);
+        collectionModels.forEach((itemModel, index) => {
+            const nestedErrors = validateModel(collection.builder, itemModel);
+            errors = [
+                ...errors,
+                ...nestedErrors.map((error) => ({
+                    ...error,
+                    name: `${collection.name}[${String(index)}].${error.name}`
+                }))
+            ];
+        });
+    });
+    return errors;
+}
+function createInstance(builder, partial = {}) {
     const model = partial;
     builder.options.forEach((entry) => {
         const option = entry.resolve(model);
@@ -20,7 +74,7 @@ export function instance(builder, partial = {}) {
         const collectionModels = existing != null ? resolveCollectionModels(model, collection.name) : [];
         model[collection.name] = Array.from({
             length: Math.max(collectionModels.length, collection.min)
-        }).map((_, index) => instance(collection.builder, collectionModels[index] || {}));
+        }).map((_, index) => createInstance(collection.builder, collectionModels[index] || {}));
     });
     return model;
 }

package/dist/resolve/models.d.ts

@@ -1,3 +1,3 @@
 import type { BuilderData } from '../model';
-import type { BuilderGeneric } from '../core/index';
-export declare function models(builder: BuilderGeneric): BuilderData;
+import type { BuilderValidated } from '../core/validate';
+export declare function models(builder: BuilderValidated): BuilderData;

package/dist/resolve/models.js

@@ -1,6 +1,9 @@
 export function models(builder) {
+    return modelsRecursive(builder);
+}
+function modelsRecursive(builder) {
     const collectionModels = builder.collections.flatMap((entry) => {
-        return [models(entry.builder)];
+        return collectionBuilders(entry).map((collectionBuilder) => modelsRecursive(collectionBuilder));
     });
     const wrapped = Object.fromEntries(builder.componentGraph.paths.map((path) => [path.name, path.models.map((model) => ({ model }))]));
     return {
@@ -8,3 +11,10 @@ export function models(builder) {
         ...wrapped
     };
 }
+function collectionBuilders(entry) {
+    if (entry.config?.type === 'match') {
+        const selectMap = entry.config.selectMap;
+        return Object.values(selectMap).flatMap((value) => (value ? [value.builder] : []));
+    }
+    return [entry.builder];
+}

package/dist/resolve/order.d.ts

@@ -1,13 +1,15 @@
 import type { Prettify } from '../prettify';
-import type { BuilderModel, BuilderVariant } from '../model';
+import type { BuilderVariant } from '../model';
 import type { CollectionShape } from '../core/collection/index';
 import type { BuilderCollection, BuilderCollectionEntries, BuilderComponentEntries, BuilderComponentNamesOf, BuilderGeneric } from '../core/index';
+import type { BuilderValidated } from '../core/validate';
+import type { BuilderModelValidated } from './instance';
 import type { BuilderDataValidated } from './validate';
 export type BuilderOrder<Builder extends BuilderGeneric> = Builder extends {
     readonly _components: infer Components extends BuilderComponentEntries;
     readonly _collections: infer Collections extends BuilderCollectionEntries;
 } ? Prettify<ComponentsOrder<Components> & CollectionsOrder<Collections>> : Record<string, unknown>;
-export declare function order<const Builder extends BuilderGeneric>(builder: Builder, model: BuilderModel, componentModels: BuilderDataValidated): BuilderOrder<Builder>;
+export declare function order<const Builder extends BuilderGeneric>(builder: Builder & BuilderValidated, model: BuilderModelValidated, componentModels: BuilderDataValidated): BuilderOrder<Builder>;
 type ComponentsOrder<Components extends BuilderComponentEntries> = {
     readonly [Name in BuilderComponentNamesOf<Components>]: BuilderVariant | null;
 };

package/dist/resolve/order.js

@@ -1,15 +1,15 @@
 import { resolveCollectionModels } from '../core/index.js';
-export function order(builder, model, componentModels) {
+import { check } from '../check.js';
+function orderInternal(builder, model, componentModels) {
     const result = {};
-    const resolved = {};
+    const resolved = new Set();
     builder.components.forEach((component) => {
-        const active = component.resolve(resolved);
-        if (!active) {
-            return;
-        }
-        resolved[active.name] = active;
-        const variants = componentModels[active.name] ?? [];
-        result[active.name] =
+        component.dependencies.forEach((dependency) => {
+            check.truthy(resolved.has(dependency), `Component '${component.name}' depends on '${dependency}' which has not been resolved! ❌`);
+        });
+        resolved.add(component.name);
+        const variants = componentModels[component.name] ?? [];
+        result[component.name] =
             variants.find((variant) => Object.entries(variant.model).every(([key, value]) => model[key] === value)) ?? null;
     });
     builder.collections.forEach((entry) => {
@@ -18,7 +18,10 @@ export function order(builder, model, componentModels) {
             return;
         }
         const itemModels = resolveCollectionModels(model, collection.name);
-        result[collection.name] = itemModels.map((itemModel) => order(collection.builder, itemModel, componentModels));
+        result[collection.name] = itemModels.map((itemModel) => orderInternal(collection.builder, itemModel, componentModels));
     });
     return result;
 }
+export function order(builder, model, componentModels) {
+    return orderInternal(builder, model, componentModels);
+}

package/dist/resolve/render.d.ts

@@ -1,5 +1,7 @@
-import type { BuilderGeneric, BuilderOption } from '../core/index';
+import type { BuilderOption } from '../core/index';
+import type { BuilderValidated } from '../core/validate';
 import type { BuilderModel } from '../model';
+import type { BuilderModelValidated } from './instance';
 import type { BuilderDescription, BuilderUIItems, BuilderPrimitive } from '../schemas/index';
 import { BuilderUI } from '../ui.js';
 export type BuilderRenderOption = {
@@ -17,5 +19,5 @@ export type BuilderRenderResult = {
     readonly layout: BuilderRenderPages;
     readonly description: BuilderDescription;
 };
-export declare function render(rootBuilder: BuilderGeneric, rootModel: BuilderModel, input: BuilderUI | BuilderUIItems): BuilderRenderResult;
+export declare function render(rootBuilder: BuilderValidated, rootModel: BuilderModelValidated, input: BuilderUI | BuilderUIItems): BuilderRenderResult;
 export declare function ordinal(index: number): string;

package/dist/resolve/validate.d.ts

@@ -1,33 +1,37 @@
 import type { BuilderData, BuilderModel } from '../model';
-import type { BuilderGeneric } from '../core/index';
+import type { BuilderValidated } from '../core/validate';
 declare const validated: unique symbol;
 export type BuilderDataValidated = BuilderData & {
     readonly [validated]: true;
 };
-export type BuilderErrorComponentMissing = {
-    readonly type: 'missing-component';
+export type BuilderDataErrorComponentMissing = {
+    readonly kind: 'missing-component';
     readonly component: string;
 };
-export type BuilderErrorComponentUnexpected = {
-    readonly type: 'unexpected-component';
+export type BuilderDataErrorComponentUnexpected = {
+    readonly kind: 'unexpected-component';
     readonly component: string;
 };
-export type BuilderErrorVariantMissing = {
-    readonly type: 'missing-variant';
+export type BuilderDataErrorVariantMissing = {
+    readonly kind: 'missing-variant';
     readonly component: string;
     readonly model: BuilderModel;
 };
-export type BuilderErrorVariantInvalid = {
-    readonly type: 'invalid-variant';
+export type BuilderDataErrorVariantInvalid = {
+    readonly kind: 'invalid-variant';
     readonly component: string;
     readonly model: BuilderModel;
 };
-export type BuilderErrorValidate = BuilderErrorComponentMissing | BuilderErrorComponentUnexpected | BuilderErrorVariantMissing | BuilderErrorVariantInvalid;
-export type BuilderErrorsValidate = ReadonlyArray<BuilderErrorValidate>;
-export type BuilderValidateResult = readonly [BuilderDataValidated, BuilderErrorsValidate];
-export declare const validate: typeof validateBuilder & {
-    strict: typeof validateStrict;
+export type BuilderDataError = BuilderDataErrorComponentMissing | BuilderDataErrorComponentUnexpected | BuilderDataErrorVariantMissing | BuilderDataErrorVariantInvalid;
+export type BuilderDataErrors = ReadonlyArray<BuilderDataError>;
+export type BuilderDataValidateResult = readonly [BuilderDataValidated, BuilderDataErrors];
+export type BuilderDataValidateOptions = {
+    readonly strict: true;
 };
-declare function validateBuilder(builder: BuilderGeneric, builderModels: BuilderData): BuilderValidateResult;
-declare function validateStrict(builder: BuilderGeneric, builderModels: BuilderData): BuilderValidateResult;
+export declare class BuilderDataValidateError extends Error {
+    readonly errors: BuilderDataErrors;
+    constructor(errors: BuilderDataErrors);
+}
+export declare const validate: typeof validateData;
+declare function validateData(builder: BuilderValidated, builderData: BuilderData, options?: BuilderDataValidateOptions): BuilderDataValidateResult;
 export {};

package/dist/resolve/validate.js

@@ -1,12 +1,19 @@
 import { models } from './models.js';
-export const validate = Object.assign(validateBuilder, { strict: validateStrict });
-function validateBuilder(builder, builderModels) {
+export class BuilderDataValidateError extends Error {
+    errors;
+    constructor(errors) {
+        super('data validation failed');
+        this.errors = errors;
+    }
+}
+export const validate = validateData;
+function validateData(builder, builderData, options) {
     const expected = models(builder);
     let errors = [];
     Object.entries(expected).forEach(([component, expectedModels]) => {
-        const componentModels = builderModels[component];
+        const componentModels = builderData[component];
         if (!componentModels) {
-            errors = [...errors, { type: 'missing-component', component }];
+            errors = [...errors, { kind: 'missing-component', component }];
             return;
         }
         const expectedKeys = new Map(expectedModels.map((variant) => [sortedKey(variant.model), variant.model]));
@@ -15,37 +22,26 @@ function validateBuilder(builder, builderModels) {
             const key = sortedKey(variant.model);
             actualKeys.add(key);
             if (!expectedKeys.has(key)) {
-                errors = [...errors, { type: 'invalid-variant', component, model: variant.model }];
+                errors = [...errors, { kind: 'invalid-variant', component, model: variant.model }];
             }
         });
         expectedKeys.forEach((model, key) => {
             if (!actualKeys.has(key)) {
-                errors = [...errors, { type: 'missing-variant', component, model }];
+                errors = [...errors, { kind: 'missing-variant', component, model }];
             }
         });
     });
-    Object.keys(builderModels).forEach((component) => {
+    Object.keys(builderData).forEach((component) => {
         if (!expected[component]) {
-            errors = [...errors, { type: 'unexpected-component', component }];
+            errors = [...errors, { kind: 'unexpected-component', component }];
         }
     });
-    return [builderModels, errors];
-}
-function validateStrict(builder, builderModels) {
-    const [data, errors] = validateBuilder(builder, builderModels);
-    if (errors.length > 0) {
-        throw new ValidateException(errors);
+    if (options?.strict && errors.length > 0) {
+        throw new BuilderDataValidateError(errors);
     }
-    return [data, []];
+    return [builderData, errors];
 }
 function sortedKey(model) {
     const entries = Object.entries(model).filter(([, value]) => value != null);
     return JSON.stringify(entries.sort(([keyA], [keyB]) => keyA.localeCompare(keyB)));
 }
-class ValidateException extends Error {
-    errors;
-    constructor(errors) {
-        super(`Builder validation failed with ${String(errors.length)} error(s)`);
-        this.errors = errors;
-    }
-}

package/dist/serialise/deserialise.d.ts

@@ -1,9 +1,14 @@
 import type { BuilderGeneric } from '../core/index';
 import type { BuilderUIGeneric } from '../ui';
+import type { BuilderSelectTypeSerialised } from './schemas';
+import { Builder, BuilderSelectType } from '../core/index.js';
 export declare const deserialise: {
     builder: typeof deserialiseBuilder;
+    select: typeof deserialiseSelect;
     ui: typeof deserialiseUI;
+    validate: (data: unknown, options?: import("./validate.js").BuilderSerialisedValidateOptions) => import("./validate.js").BuilderSerialisedValidateResult;
 };
-declare function deserialiseBuilder(data: unknown): BuilderGeneric;
+declare function deserialiseBuilder(data: unknown): Builder;
 declare function deserialiseUI(builder: BuilderGeneric, data: unknown): BuilderUIGeneric;
+declare function deserialiseSelect(data: BuilderSelectTypeSerialised): BuilderSelectType;
 export {};

package/dist/serialise/deserialise.js

@@ -1,23 +1,26 @@
 import * as v from 'valibot';
-import { BuilderCollection, BuilderComponent, BuilderExpectation, BuilderOption, Builder, BuilderParameter, BuilderSelectType, BuilderToggleType } from '../core/index.js';
-import { BuilderSerialisedSchema, BuilderUIItemsSerialisedSchema } from './schemas.js';
+import { Builder, BuilderCollection, BuilderComponent, BuilderExpectation, BuilderOption, BuilderParameter, BuilderSelectType, BuilderToggleType } from '../core/index.js';
 import { BuilderUI } from '../ui.js';
+import { BuilderSerialisedSchema, BuilderUISerialisedSchema } from './schemas.js';
+import { validate as validateSerialised } from './validate.js';
 export const deserialise = {
     builder: deserialiseBuilder,
-    ui: deserialiseUI
+    select: deserialiseSelect,
+    ui: deserialiseUI,
+    validate: validateSerialised
 };
 function deserialiseBuilder(data) {
-    return buildBuilder(v.parse(BuilderSerialisedSchema, data));
+    const builderSerialised = v.parse(BuilderSerialisedSchema, data);
+    const options = builderSerialised.options.map(deserialiseOption);
+    const components = builderSerialised.components.map(deserialiseComponent);
+    const collections = builderSerialised.collections.map(deserialiseCollection);
+    const expectations = builderSerialised.expectations.map((expectation) => new BuilderExpectation(expectation.name, expectation.kind));
+    return new Builder(options, components, collections, expectations);
 }
 function deserialiseUI(builder, data) {
-    return new BuilderUI(builder, v.parse(BuilderUIItemsSerialisedSchema, data));
-}
-function buildBuilder(data) {
-    const options = data.options.map(deserialiseOption);
-    const components = data.components.map(deserialiseComponent);
-    const collections = data.collections.map(deserialiseCollection);
-    const expectations = data.expectations.map((expectation) => new BuilderExpectation(expectation.name, expectation.kind));
-    return new Builder(options, collections, components, expectations);
+    const parsed = v.parse(BuilderUISerialisedSchema, data);
+    const expectations = parsed.expectations.map((expectation) => new BuilderExpectation(expectation.name, expectation.kind));
+    return new BuilderUI(builder, parsed.items, expectations);
 }
 function deserialiseOption(data) {
     const values = deserialiseValues(data.values);
@@ -28,29 +31,29 @@ function deserialiseComponent(data) {
     return new BuilderComponent(data.name, data.paths, data.dependencies);
 }
 function deserialiseCollection(data) {
-    const built = buildBuilder(data.builder);
+    const builder = deserialiseBuilder(data.builder);
     const config = deserialiseCollectionWhenConfig(data.config);
-    return new BuilderCollection(data.name, built, data.min, data.max, data.gatePaths, config);
+    return new BuilderCollection(data.name, builder, data.min, data.max, data.gatePaths, config);
+}
+function deserialiseSelect(data) {
+    const { optional, options, defaultValue, labels } = data;
+    const valueSchema = v.union(options.map((value) => v.literal(value)));
+    return new BuilderSelectType(options, optional ? v.nullable(valueSchema) : valueSchema, defaultValue, optional, labels);
 }
 function deserialiseValues(data) {
     if (data.type === 'parameter') {
         return new BuilderParameter();
     }
     if (data.type === 'select') {
-        const { optional, options, defaultValue, labels } = data;
-        const valueSchema = v.union(options.map((value) => v.literal(value)));
-        return new BuilderSelectType(options, optional ? v.nullable(valueSchema) : valueSchema, defaultValue, optional, labels);
+        return deserialiseSelect(data);
     }
-    const valueSchema = deserialiseToggleValueSchema(data.valueType, data.optional);
-    return new BuilderToggleType(valueSchema, data.defaultValue, data.optional);
-}
-function deserialiseToggleValueSchema(valueType, optional) {
-    const base = valueType.includes('boolean')
+    const baseSchema = data.valueType === 'boolean'
         ? v.boolean()
-        : valueType.includes('string')
+        : data.valueType === 'string'
             ? v.string()
             : v.number();
-    return optional ? v.nullable(base) : base;
+    const valueSchema = data.optional ? v.nullable(baseSchema) : baseSchema;
+    return new BuilderToggleType(data.valueType, valueSchema, data.defaultValue, data.optional);
 }
 function deserialiseOptionWhenConfig(data) {
     if (data === null) {
@@ -88,26 +91,29 @@ function deserialiseCollectionWhenConfig(data) {
     switch (data.type) {
         case 'enable': {
             const { max, min, builder: builderData, type } = data;
-            return { type, builder: buildBuilder(builderData), min, max };
+            return { type, builder: deserialiseBuilder(builderData), min, max };
         }
         case 'match': {
-            const { matchPath, selectMap, type } = data;
-            const deserialisedSelectMap = Object.fromEntries(Object.entries(selectMap).map(([key, value]) => {
+            const { matchPath, type } = data;
+            const deserialisedSelectMap = Object.fromEntries(Object.entries(data.selectMap).map(([key, value]) => {
                 if (!value) {
                     return [key, null];
                 }
                 const { builder: builderData, min, max } = value;
-                return [key, { builder: buildBuilder(builderData), min, max }];
+                return [key, { builder: deserialiseBuilder(builderData), min, max }];
             }));
-            return {
-                type,
-                matchPath,
-                selectMap: deserialisedSelectMap
-            };
+            return { type, matchPath, selectMap: deserialisedSelectMap };
         }
         case 'unless': {
             const { disabledValues, max, min, builder: builderData, type, unlessPath } = data;
-            return { type, unlessPath, disabledValues, builder: buildBuilder(builderData), min, max };
+            return {
+                type,
+                unlessPath,
+                disabledValues,
+                builder: deserialiseBuilder(builderData),
+                min,
+                max
+            };
         }
     }
 }

package/dist/serialise/index.d.ts

@@ -1,4 +1,6 @@
 export type { BuilderCollectionSerialised, BuilderCollectionConfigSerialised, BuilderCollectionEnableConfigSerialised, BuilderCollectionMatchConfigSerialised, BuilderCollectionUnlessConfigSerialised, BuilderCollectionWhenConfigSerialised, BuilderComponentSerialised, BuilderExpectationSerialised, BuilderOptionSerialised, BuilderOptionEnableConfigSerialised, BuilderOptionMatchConfigSerialised, BuilderOptionUnlessConfigSerialised, BuilderOptionWhenConfigSerialised, BuilderSerialised, BuilderSelectTypeSerialised, BuilderToggleTypeSerialised, BuilderUISerialised, BuilderUICollectionSerialised, BuilderUIDescribeSerialised, BuilderUIItemSerialised, BuilderUIItemsSerialised, BuilderUIPageSerialised, BuilderParameterSerialised, BuilderValuesSerialised } from './schemas';
-export { BuilderCollectionConfigSerialisedSchema, BuilderCollectionEnableConfigSerialisedSchema, BuilderCollectionMatchConfigSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionUnlessConfigSerialisedSchema, BuilderCollectionWhenConfigSerialisedSchema, BuilderComponentSerialisedSchema, BuilderExpectationSerialisedSchema, BuilderOptionEnableConfigSerialisedSchema, BuilderOptionMatchConfigSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionUnlessConfigSerialisedSchema, BuilderOptionWhenConfigSerialisedSchema, BuilderSerialisedSchema, BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSerialisedSchema, BuilderUICollectionSerialisedSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSerialisedSchema, BuilderValuesSerialisedSchema } from './schemas.js';
+export { BuilderCollectionConfigSerialisedSchema, BuilderCollectionEnableConfigSerialisedSchema, BuilderCollectionMatchConfigSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionUnlessConfigSerialisedSchema, BuilderCollectionWhenConfigSerialisedSchema, BuilderComponentSerialisedSchema, BuilderExpectationSerialisedSchema, BuilderOptionEnableConfigSerialisedSchema, BuilderOptionMatchConfigSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionUnlessConfigSerialisedSchema, BuilderOptionWhenConfigSerialisedSchema, BuilderSerialisedSchema, BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSerialisedSchema, BuilderUICollectionSerialisedSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSerialisedSchema, BuilderUISerialisedSchema, BuilderValuesSerialisedSchema } from './schemas.js';
+export type { BuilderSerialisedValidated, BuilderSerialisedError, BuilderSerialisedErrors, BuilderSerialisedValidateOptions, BuilderSerialisedValidateResult } from './validate';
 export { deserialise } from './deserialise.js';
 export { serialise } from './serialise.js';
+export { BuilderSerialisedValidateError } from './validate.js';

package/dist/serialise/index.js

@@ -1,3 +1,4 @@
-export { BuilderCollectionConfigSerialisedSchema, BuilderCollectionEnableConfigSerialisedSchema, BuilderCollectionMatchConfigSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionUnlessConfigSerialisedSchema, BuilderCollectionWhenConfigSerialisedSchema, BuilderComponentSerialisedSchema, BuilderExpectationSerialisedSchema, BuilderOptionEnableConfigSerialisedSchema, BuilderOptionMatchConfigSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionUnlessConfigSerialisedSchema, BuilderOptionWhenConfigSerialisedSchema, BuilderSerialisedSchema, BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSerialisedSchema, BuilderUICollectionSerialisedSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSerialisedSchema, BuilderValuesSerialisedSchema } from './schemas.js';
+export { BuilderCollectionConfigSerialisedSchema, BuilderCollectionEnableConfigSerialisedSchema, BuilderCollectionMatchConfigSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionUnlessConfigSerialisedSchema, BuilderCollectionWhenConfigSerialisedSchema, BuilderComponentSerialisedSchema, BuilderExpectationSerialisedSchema, BuilderOptionEnableConfigSerialisedSchema, BuilderOptionMatchConfigSerialisedSchema, BuilderOptionSerialisedSchema, BuilderOptionUnlessConfigSerialisedSchema, BuilderOptionWhenConfigSerialisedSchema, BuilderSerialisedSchema, BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSerialisedSchema, BuilderUICollectionSerialisedSchema, BuilderUIDescribeSerialisedSchema, BuilderUIItemSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSerialisedSchema, BuilderUISerialisedSchema, BuilderValuesSerialisedSchema } from './schemas.js';
 export { deserialise } from './deserialise.js';
 export { serialise } from './serialise.js';
+export { BuilderSerialisedValidateError } from './validate.js';