@builder-builder/builder 0.0.19 → 0.0.21

package/dist/entities/collection/collection.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 { BuilderCollectionConfigSerialisedSchema } from './config.js';
@@ -30,3 +31,5 @@ export const BuilderCollectionSerialisedSchema = serialisable(v.object({
     tags: v.optional(BuilderTagsSchema)
 }));
 export const BuilderCollectionsSerialisedSchema = v.pipe(v.array(BuilderCollectionSerialisedSchema), v.readonly());
+export const validateCollectionWhen = createEntityValidator('collectionWhen', BuilderCollectionWhenSerialisedSchema);
+export const validateCollectionSelectMap = createEntityValidator('collectionSelectMap', BuilderCollectionSelectMapSerialisedSchema);

package/dist/entities/collection/config.d.ts

@@ -87,4 +87,294 @@ export declare const BuilderCollectionConfigSerialisedSchema: v.SchemaWithPipe<r
     tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderCollectionConfigSerialised = v.InferOutput<typeof BuilderCollectionConfigSerialisedSchema>;
+export declare const BuilderCollectionConfigsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly model: v.UnionSchema<[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;
+    }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        type: "ref";
+        id: string;
+    }>]>, v.LazySchema<v.GenericSchema<import("..").BuilderModelSerialised>>], undefined>;
+    readonly min: v.UnionSchema<[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;
+    }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        type: "ref";
+        id: string;
+    }>]>, v.NumberSchema<undefined>], undefined>;
+    readonly max: v.UnionSchema<[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;
+    }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        type: "ref";
+        id: string;
+    }>]>, v.NumberSchema<undefined>], undefined>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
+}, undefined>, v.ReadonlyAction<{
+    model: Readonly<{
+        type: "parameter";
+        id: string;
+        name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
+    }> | import("..").BuilderModelSerialised;
+    min: number | Readonly<{
+        type: "parameter";
+        id: string;
+        name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
+    }>;
+    max: number | Readonly<{
+        type: "parameter";
+        id: string;
+        name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
+    }>;
+    tags?: readonly string[] | undefined;
+}>]>, undefined>, v.ReadonlyAction<Readonly<{
+    model: Readonly<{
+        type: "parameter";
+        id: string;
+        name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
+    }> | import("..").BuilderModelSerialised;
+    min: number | Readonly<{
+        type: "parameter";
+        id: string;
+        name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
+    }>;
+    max: number | Readonly<{
+        type: "parameter";
+        id: string;
+        name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
+    }>;
+    tags?: readonly string[] | undefined;
+}>[]>]>;
+export type BuilderCollectionConfigsSerialised = v.InferOutput<typeof BuilderCollectionConfigsSerialisedSchema>;
 export declare function collectionConfig<Model extends Paramable<BuilderModelGeneric> = Paramable<BuilderModelGeneric>, Min extends Paramable<number> = Paramable<number>, Max extends Paramable<number> = Paramable<number>>(model: Model, min: Min, max: Max): BuilderCollectionConfig<Model, Min, Max>;
+export declare const validateCollectionConfig: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+    readonly model: {
+        readonly models: readonly (/*elided*/ any & import("../../validate").BuilderValidatedBrand)[];
+        readonly options: readonly {
+            readonly name: string;
+            readonly payload: {
+                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;
+                };
+            } | {
+                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 paths?: readonly (readonly (string | number)[])[] | undefined;
+            readonly tags?: readonly string[] | undefined;
+        }[];
+        readonly components: readonly {
+            readonly name: string;
+            readonly payload: {
+                readonly fields: readonly {
+                    readonly type: "component-field";
+                    readonly name: string;
+                    readonly valueType: "string" | "number" | "boolean";
+                    readonly isOptional: boolean;
+                    readonly tags?: readonly string[] | undefined;
+                }[];
+                readonly tags?: readonly string[] | undefined;
+            } | {
+                readonly type: "enable";
+                readonly payload: {
+                    readonly fields: readonly {
+                        readonly type: "component-field";
+                        readonly name: string;
+                        readonly valueType: "string" | "number" | "boolean";
+                        readonly isOptional: boolean;
+                        readonly tags?: readonly string[] | undefined;
+                    }[];
+                    readonly tags?: readonly string[] | undefined;
+                };
+            } | {
+                readonly type: "match";
+                readonly matchPath: readonly (string | number)[];
+                readonly selectMap: {
+                    readonly [x: string]: {
+                        readonly fields: readonly {
+                            readonly type: "component-field";
+                            readonly name: string;
+                            readonly valueType: "string" | "number" | "boolean";
+                            readonly isOptional: boolean;
+                            readonly tags?: readonly string[] | undefined;
+                        }[];
+                        readonly tags?: readonly string[] | undefined;
+                    } | null;
+                };
+            } | {
+                readonly type: "unless";
+                readonly unlessPath: readonly (string | number)[];
+                readonly disabledValues: readonly (string | number | boolean | null)[];
+                readonly payload: {
+                    readonly fields: readonly {
+                        readonly type: "component-field";
+                        readonly name: string;
+                        readonly valueType: "string" | "number" | "boolean";
+                        readonly isOptional: boolean;
+                        readonly tags?: readonly string[] | undefined;
+                    }[];
+                    readonly tags?: readonly string[] | undefined;
+                };
+            };
+            readonly paths?: readonly (readonly (string | number)[])[] | undefined;
+            readonly tags?: readonly string[] | undefined;
+        }[];
+        readonly collections: readonly {
+            readonly name: string;
+            readonly paths?: readonly (readonly (string | number)[])[] | undefined;
+            readonly payload: {
+                readonly model: /*elided*/ any & import("../../validate").BuilderValidatedBrand;
+                readonly min: number;
+                readonly max: number;
+                readonly tags?: readonly string[] | undefined;
+            } | {
+                readonly type: "enable";
+                readonly payload: {
+                    readonly model: /*elided*/ any & import("../../validate").BuilderValidatedBrand;
+                    readonly min: number;
+                    readonly max: number;
+                    readonly tags?: readonly string[] | undefined;
+                };
+            } | {
+                readonly type: "match";
+                readonly matchPath: readonly (string | number)[];
+                readonly selectMap: {
+                    readonly [x: string]: {
+                        readonly model: /*elided*/ any & import("../../validate").BuilderValidatedBrand;
+                        readonly min: number;
+                        readonly max: number;
+                        readonly tags?: readonly string[] | undefined;
+                    } | null;
+                };
+            } | {
+                readonly type: "unless";
+                readonly unlessPath: readonly (string | number)[];
+                readonly disabledValues: readonly (string | number | boolean | null)[];
+                readonly payload: {
+                    readonly model: /*elided*/ any & import("../../validate").BuilderValidatedBrand;
+                    readonly min: number;
+                    readonly max: number;
+                    readonly tags?: readonly string[] | undefined;
+                };
+            };
+            readonly tags?: readonly string[] | undefined;
+        }[];
+        readonly expectations: readonly ({
+            readonly name: string;
+            readonly kind: "option" | "component" | "collection";
+        } & import("../../validate").BuilderValidatedBrand)[];
+        readonly tags?: readonly string[] | undefined;
+    } & import("../../validate").BuilderValidatedBrand;
+    readonly min: number;
+    readonly max: number;
+    readonly tags?: readonly string[] | undefined;
+}>;

package/dist/entities/collection/config.js

@@ -1,7 +1,8 @@
 import * as v from 'valibot';
-import { paramable } from '../../references.js';
-import { serialisable } from '../../serialisable.js';
+import { isParamable, paramable } from '../../references.js';
+import { createEntityValidator } from '../kind.js';
 import { BuilderModelSerialisedSchema } from '../model/index.js';
+import { serialisable } from '../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
 export class BuilderCollectionConfig {
     model;
@@ -25,6 +26,16 @@ export const BuilderCollectionConfigSerialisedSchema = serialisable(v.object({
     max: paramable(v.number()),
     tags: v.optional(BuilderTagsSchema)
 }));
+export const BuilderCollectionConfigsSerialisedSchema = v.pipe(v.array(BuilderCollectionConfigSerialisedSchema), v.readonly());
 export function collectionConfig(model, min, max) {
     return new BuilderCollectionConfig(model, min, max);
 }
+export const validateCollectionConfig = createEntityValidator('collectionConfig', BuilderCollectionConfigSerialisedSchema, (input, errors) => {
+    const { min, max } = input;
+    if (isParamable(min) || isParamable(max)) {
+        return;
+    }
+    if (min < 0 || max <= 0 || max < min) {
+        errors.invalidCollectionBounds(min, max);
+    }
+});

package/dist/entities/collection/expectation.d.ts

@@ -1,5 +1,5 @@
-import type { BuilderModelState } from '../model/index';
 import type { BuilderExpectations } from '../expectation';
+import type { BuilderModelState } from '../model/index';
 import type { BuilderCollection } from './collection';
 import { BuilderExpectation } from '../expectation.js';
 export declare function collectionExpectation<const Name extends string>(name: Name): BuilderExpectation<Name, never, "collection">;

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

@@ -1,8 +1,8 @@
 export type { BuilderCollectionPayload, BuilderCollections, BuilderCollectionSerialised, BuilderCollectionsSerialised, BuilderCollectionWhenSerialised, CollectionNamesOf, CollectionShape } from './collection';
-export type { BuilderCollectionConfigSerialised } from './config';
+export type { BuilderCollectionConfigSerialised, BuilderCollectionConfigsSerialised } from './config';
 export type { CollectionsAsserted } from './expectation';
 export type { BuilderCollectionWhen } from './when';
-export { BuilderCollection, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema } from './collection.js';
-export { BuilderCollectionConfig, BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, collectionConfig } from './config.js';
+export { BuilderCollection, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, validateCollectionSelectMap, validateCollectionWhen } from './collection.js';
+export { BuilderCollectionConfig, BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionConfigsSerialisedSchema, collectionConfig, validateCollectionConfig } from './config.js';
 export { collectionExpectation } from './expectation.js';
 export { collectionWhen } from './when.js';

package/dist/entities/collection/index.js

@@ -1,4 +1,4 @@
-export { BuilderCollection, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema } from './collection.js';
-export { BuilderCollectionConfig, BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, collectionConfig } from './config.js';
+export { BuilderCollection, BuilderCollectionSchema, BuilderCollectionSelectMapSerialisedSchema, BuilderCollectionSerialisedSchema, BuilderCollectionsSerialisedSchema, BuilderCollectionWhenSerialisedSchema, validateCollectionSelectMap, validateCollectionWhen } from './collection.js';
+export { BuilderCollectionConfig, BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema, BuilderCollectionConfigsSerialisedSchema, collectionConfig, validateCollectionConfig } from './config.js';
 export { collectionExpectation } from './expectation.js';
 export { collectionWhen } from './when.js';

package/dist/entities/collection/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 { BuilderCollectionConfig } from './config';
 export type BuilderCollectionWhen = BuilderWhen<Paramable<BuilderCollectionConfig>, Paramable<BuilderPath>, Paramable<Record<string, Paramable<BuilderCollectionConfig> | null>>, Paramable<BuilderPath>>;

package/dist/entities/component/component.d.ts

@@ -1,11 +1,11 @@
-import type { BuilderPaths } from '../../paths';
 import type { Paramable } from '../../references';
+import type { BuilderPaths } from '../paths';
 import type { BuilderTags } from '../tags';
 import type { BuilderWhenSerialised } from '../when';
-import type { BuilderComponentDetails, BuilderComponentDetailsSerialised } from './details';
+import type { BuilderComponentConfig, BuilderComponentConfigSerialised } from './config';
 import type { BuilderComponentWhen } from './when';
 import * as v from 'valibot';
-export type BuilderComponentPayload = BuilderComponentDetails | BuilderComponentWhen;
+export type BuilderComponentPayload = BuilderComponentConfig | BuilderComponentWhen;
 export declare class BuilderComponent<const Name extends string = string, const Payload extends Paramable<BuilderComponentPayload> = Paramable<BuilderComponentPayload>, const Paths extends Paramable<BuilderPaths> = Paramable<BuilderPaths>> {
     readonly type: 'component';
     readonly name: Name;
@@ -34,7 +34,7 @@ export declare const BuilderComponentWhenSerialisedSchema: v.GenericSchema<Build
     }>[];
     tags?: readonly string[] | undefined;
 }>>>;
-export type BuilderComponentWhenSerialised = BuilderWhenSerialised<BuilderComponentDetailsSerialised>;
+export type BuilderComponentWhenSerialised = BuilderWhenSerialised<BuilderComponentConfigSerialised>;
 export declare const BuilderComponentSelectMapSerialisedSchema: v.GenericSchema<import("..").BuilderMatchSelectMap<Readonly<{
     type: "parameter";
     id: string;
@@ -198,14 +198,14 @@ export declare const BuilderComponentSerialisedSchema: v.SchemaWithPipe<readonly
         }>[];
         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 BuilderComponentSerialised = v.InferOutput<typeof BuilderComponentSerialisedSchema>;
@@ -351,14 +351,14 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
         }>[];
         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;
@@ -402,14 +402,68 @@ export declare const BuilderComponentsSerialisedSchema: v.SchemaWithPipe<readonl
         }>[];
         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 BuilderComponentsSerialised = v.InferOutput<typeof BuilderComponentsSerialisedSchema>;
+export declare const validateComponentWhen: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+    readonly type: "enable";
+    readonly payload: {
+        readonly fields: readonly {
+            readonly type: "component-field";
+            readonly name: string;
+            readonly valueType: "string" | "number" | "boolean";
+            readonly isOptional: boolean;
+            readonly tags?: readonly string[] | undefined;
+        }[];
+        readonly tags?: readonly string[] | undefined;
+    };
+} | {
+    readonly type: "match";
+    readonly matchPath: readonly (string | number)[];
+    readonly selectMap: {
+        readonly [x: string]: {
+            readonly fields: readonly {
+                readonly type: "component-field";
+                readonly name: string;
+                readonly valueType: "string" | "number" | "boolean";
+                readonly isOptional: boolean;
+                readonly tags?: readonly string[] | undefined;
+            }[];
+            readonly tags?: readonly string[] | undefined;
+        } | null;
+    };
+} | {
+    readonly type: "unless";
+    readonly unlessPath: readonly (string | number)[];
+    readonly disabledValues: readonly (string | number | boolean | null)[];
+    readonly payload: {
+        readonly fields: readonly {
+            readonly type: "component-field";
+            readonly name: string;
+            readonly valueType: "string" | "number" | "boolean";
+            readonly isOptional: boolean;
+            readonly tags?: readonly string[] | undefined;
+        }[];
+        readonly tags?: readonly string[] | undefined;
+    };
+}>;
+export declare const validateComponentSelectMap: (input: unknown, references?: import("..").BuilderReferences, errors?: import("../../errors").BuilderValidateErrors) => import("..").ValidationResult<{
+    readonly [x: string]: {
+        readonly fields: readonly {
+            readonly type: "component-field";
+            readonly name: string;
+            readonly valueType: "string" | "number" | "boolean";
+            readonly isOptional: boolean;
+            readonly tags?: readonly string[] | undefined;
+        }[];
+        readonly tags?: readonly string[] | undefined;
+    } | null;
+}>;

package/dist/entities/component/component.js

@@ -1,10 +1,11 @@
 import * as v from 'valibot';
-import { BuilderPathsSchema } from '../../paths.js';
 import { paramable } from '../../references.js';
-import { serialisable } from '../../serialisable.js';
+import { createEntityValidator } from '../kind.js';
+import { BuilderPathsSchema } from '../paths.js';
+import { serialisable } from '../serialisable.js';
 import { BuilderTagsSchema } from '../tags.js';
 import { createSelectMapSerialisedSchema, createWhenSerialisedSchema } from '../when.js';
-import { BuilderComponentDetailsSerialisedSchema } from './details.js';
+import { BuilderComponentConfigSerialisedSchema } from './config.js';
 export class BuilderComponent {
     name;
     payload;
@@ -21,12 +22,14 @@ export class BuilderComponent {
     }
 }
 export const BuilderComponentSchema = v.instance(BuilderComponent);
-export const BuilderComponentWhenSerialisedSchema = createWhenSerialisedSchema(BuilderComponentDetailsSerialisedSchema);
-export const BuilderComponentSelectMapSerialisedSchema = createSelectMapSerialisedSchema(BuilderComponentDetailsSerialisedSchema);
+export const BuilderComponentWhenSerialisedSchema = createWhenSerialisedSchema(BuilderComponentConfigSerialisedSchema);
+export const BuilderComponentSelectMapSerialisedSchema = createSelectMapSerialisedSchema(BuilderComponentConfigSerialisedSchema);
 export const BuilderComponentSerialisedSchema = serialisable(v.object({
     name: v.string(),
-    payload: paramable(v.union([BuilderComponentDetailsSerialisedSchema, BuilderComponentWhenSerialisedSchema])),
+    payload: paramable(v.union([BuilderComponentConfigSerialisedSchema, BuilderComponentWhenSerialisedSchema])),
     paths: v.optional(paramable(BuilderPathsSchema)),
     tags: v.optional(BuilderTagsSchema)
 }));
 export const BuilderComponentsSerialisedSchema = v.pipe(v.array(BuilderComponentSerialisedSchema), v.readonly());
+export const validateComponentWhen = createEntityValidator('componentWhen', BuilderComponentWhenSerialisedSchema);
+export const validateComponentSelectMap = createEntityValidator('componentSelectMap', BuilderComponentSelectMapSerialisedSchema);