@builder-builder/builder 0.0.14 → 0.0.15

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

@@ -1,17 +1,21 @@
 import type { BuilderPrimitive } from '../../primitive';
+import type { BuilderTags } from '../tags';
 import * as v from 'valibot';
 export declare const BuilderToggleValueTypeSchema: v.PicklistSchema<["string", "boolean", "number"], undefined>;
 export type BuilderToggleValueType = v.InferOutput<typeof BuilderToggleValueTypeSchema>;
 export declare class BuilderToggleType<const ValueSchema extends v.GenericSchema<BuilderPrimitive> = v.GenericSchema<BuilderPrimitive>> {
+    #private;
     readonly value: v.InferOutput<ValueSchema>;
     readonly type: "toggle";
     readonly valueType: BuilderToggleValueType;
     readonly valueSchema: ValueSchema;
     readonly defaultValue: v.InferOutput<ValueSchema>;
     readonly isOptional: boolean;
-    constructor(valueType: BuilderToggleValueType, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean);
+    readonly tags?: BuilderTags;
+    constructor(valueType: BuilderToggleValueType, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, tags?: BuilderTags);
     default(newDefault: v.InferOutput<ValueSchema>): BuilderToggleType<ValueSchema>;
     optional(): BuilderToggleType<v.NullableSchema<ValueSchema, undefined>>;
+    tag(...tags: Array<string>): BuilderToggleType<ValueSchema>;
 }
 export declare function toggleString(): BuilderToggleType<v.StringSchema<undefined>>;
 export declare function toggleBoolean(): BuilderToggleType<v.BooleanSchema<undefined>>;
@@ -22,11 +26,13 @@ export declare const BuilderToggleTypeSerialisedSchema: v.SchemaWithPipe<readonl
     readonly valueType: v.PicklistSchema<["string", "boolean", "number"], 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.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     type: "toggle";
     valueType: "string" | "number" | "boolean";
     defaultValue: string | number | boolean | null;
     isOptional: boolean;
+    tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderToggleTypeSerialised = v.InferOutput<typeof BuilderToggleTypeSerialisedSchema>;
 export declare function toggleValueSchema(valueType: BuilderToggleValueType, optional: boolean): v.GenericSchema;

package/dist/entities/option/toggle.js

@@ -1,5 +1,6 @@
 import * as v from 'valibot';
 import { serialisable } from '../../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
 export const BuilderToggleValueTypeSchema = v.picklist(['string', 'boolean', 'number']);
 export class BuilderToggleType {
     type = 'toggle';
@@ -7,17 +8,27 @@ export class BuilderToggleType {
     valueSchema;
     defaultValue;
     isOptional;
-    constructor(valueType, defaultValue, optional) {
+    tags;
+    constructor(valueType, defaultValue, optional, tags) {
         this.valueType = valueType;
         this.valueSchema = toggleValueSchema(valueType, optional || false);
         this.defaultValue = defaultValue;
         this.isOptional = optional || false;
+        this.tags = tags;
+    }
+    #next(patch) {
+        return new BuilderToggleType(this.valueType, 'defaultValue' in patch
+            ? patch.defaultValue
+            : this.defaultValue, patch.optional ?? this.isOptional, patch.tags ?? this.tags);
     }
     default(newDefault) {
-        return new BuilderToggleType(this.valueType, newDefault, this.isOptional);
+        return this.#next({ defaultValue: newDefault });
     }
     optional() {
-        return new BuilderToggleType(this.valueType, this.defaultValue, true);
+        return this.#next({ optional: true });
+    }
+    tag(...tags) {
+        return this.#next({ tags });
     }
 }
 export function toggleString() {
@@ -34,7 +45,8 @@ export const BuilderToggleTypeSerialisedSchema = serialisable(v.object({
     type: v.literal('toggle'),
     valueType: BuilderToggleValueTypeSchema,
     defaultValue: v.nullable(v.union([v.boolean(), v.string(), v.number()])),
-    isOptional: v.boolean()
+    isOptional: v.boolean(),
+    tags: v.optional(BuilderTagsSchema)
 }));
 export function toggleValueSchema(valueType, optional) {
     const baseSchema = valueType === 'string' ? v.string() : valueType === 'boolean' ? v.boolean() : v.number();

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

@@ -7,6 +7,7 @@ export declare const BuilderOptionValuesSerialisedSchema: v.SchemaWithPipe<reado
     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.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     type: "select";
     readonly options: readonly [string, ...string[]];
@@ -15,16 +16,19 @@ export declare const BuilderOptionValuesSerialisedSchema: v.SchemaWithPipe<reado
     optionLabels: {
         [x: string]: string;
     };
+    tags?: readonly string[] | undefined;
 }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly type: v.LiteralSchema<"toggle", undefined>;
     readonly valueType: v.PicklistSchema<["string", "boolean", "number"], 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.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     type: "toggle";
     valueType: "string" | "number" | "boolean";
     defaultValue: string | number | boolean | null;
     isOptional: boolean;
+    tags?: readonly string[] | undefined;
 }>]>], undefined>, v.ReadonlyAction<Readonly<{
     type: "select";
     readonly options: readonly [string, ...string[]];
@@ -33,11 +37,13 @@ export declare const BuilderOptionValuesSerialisedSchema: v.SchemaWithPipe<reado
     optionLabels: {
         [x: string]: string;
     };
+    tags?: readonly string[] | undefined;
 }> | Readonly<{
     type: "toggle";
     valueType: "string" | "number" | "boolean";
     defaultValue: string | number | boolean | null;
     isOptional: boolean;
+    tags?: readonly string[] | undefined;
 }>>]>;
 export type BuilderOptionValuesSerialised = v.InferOutput<typeof BuilderOptionValuesSerialisedSchema>;
 export declare function optionValueSchema(payload: BuilderOptionValuesSerialised): v.GenericSchema;

package/dist/entities/pricing.d.ts

@@ -0,0 +1,64 @@
+import * as v from 'valibot';
+export declare const BuilderPricingReduceSchema: v.PicklistSchema<["product", "sum", "first"], undefined>;
+export type BuilderPricingReduce = v.InferOutput<typeof BuilderPricingReduceSchema>;
+export type BuilderPricingTagExpression = {
+    readonly kind: 'tag';
+    readonly value: string;
+} | {
+    readonly kind: 'modelTags';
+} | {
+    readonly kind: 'variantTags';
+};
+export declare const BuilderPricingTagExpressionSchema: v.GenericSchema<BuilderPricingTagExpression>;
+export type BuilderPricingExpression = {
+    readonly kind: 'num';
+    readonly value: number;
+} | {
+    readonly kind: 'variantPrice';
+} | {
+    readonly kind: 'rate';
+    readonly rate: string;
+    readonly tag: BuilderPricingTagExpression;
+    readonly reduce?: BuilderPricingReduce;
+} | {
+    readonly kind: 'variants';
+    readonly tag?: BuilderPricingTagExpression;
+    readonly expression: BuilderPricingExpression;
+    readonly reduce?: BuilderPricingReduce;
+} | {
+    readonly kind: 'add';
+    readonly left: BuilderPricingExpression;
+    readonly right: BuilderPricingExpression;
+} | {
+    readonly kind: 'sub';
+    readonly left: BuilderPricingExpression;
+    readonly right: BuilderPricingExpression;
+} | {
+    readonly kind: 'mul';
+    readonly left: BuilderPricingExpression;
+    readonly right: BuilderPricingExpression;
+} | {
+    readonly kind: 'div';
+    readonly left: BuilderPricingExpression;
+    readonly right: BuilderPricingExpression;
+};
+export declare const BuilderPricingExpressionSchema: v.GenericSchema<BuilderPricingExpression>;
+export type BuilderPricing = {
+    readonly rates: Record<string, Record<string, number>>;
+    readonly formula: BuilderPricingExpression;
+};
+export declare const BuilderPricingSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly rates: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.NumberSchema<undefined>, undefined>, undefined>, v.ReadonlyAction<{
+        [x: string]: {
+            [x: string]: number;
+        };
+    }>]>;
+    readonly formula: v.GenericSchema<BuilderPricingExpression>;
+}, undefined>, v.ReadonlyAction<{
+    readonly rates: Readonly<{
+        [x: string]: {
+            [x: string]: number;
+        };
+    }>;
+    formula: BuilderPricingExpression;
+}>]>;

package/dist/entities/pricing.js

@@ -0,0 +1,48 @@
+import * as v from 'valibot';
+import { serialisable } from '../serialisable.js';
+export const BuilderPricingReduceSchema = v.picklist(['product', 'sum', 'first']);
+export const BuilderPricingTagExpressionSchema = v.variant('kind', [
+    v.object({ kind: v.literal('tag'), value: v.string() }),
+    v.object({ kind: v.literal('modelTags') }),
+    v.object({ kind: v.literal('variantTags') })
+]);
+export const BuilderPricingExpressionSchema = v.lazy(() => v.variant('kind', [
+    v.object({ kind: v.literal('num'), value: v.number() }),
+    v.object({ kind: v.literal('variantPrice') }),
+    v.object({
+        kind: v.literal('rate'),
+        rate: v.string(),
+        tag: BuilderPricingTagExpressionSchema,
+        reduce: v.optional(BuilderPricingReduceSchema)
+    }),
+    v.object({
+        kind: v.literal('variants'),
+        tag: v.optional(BuilderPricingTagExpressionSchema),
+        expression: BuilderPricingExpressionSchema,
+        reduce: v.optional(BuilderPricingReduceSchema)
+    }),
+    v.object({
+        kind: v.literal('add'),
+        left: BuilderPricingExpressionSchema,
+        right: BuilderPricingExpressionSchema
+    }),
+    v.object({
+        kind: v.literal('sub'),
+        left: BuilderPricingExpressionSchema,
+        right: BuilderPricingExpressionSchema
+    }),
+    v.object({
+        kind: v.literal('mul'),
+        left: BuilderPricingExpressionSchema,
+        right: BuilderPricingExpressionSchema
+    }),
+    v.object({
+        kind: v.literal('div'),
+        left: BuilderPricingExpressionSchema,
+        right: BuilderPricingExpressionSchema
+    })
+]));
+export const BuilderPricingSchema = serialisable(v.object({
+    rates: v.pipe(v.record(v.string(), v.record(v.string(), v.number())), v.readonly()),
+    formula: BuilderPricingExpressionSchema
+}));

package/dist/entities/serialise.d.ts

@@ -20,6 +20,7 @@ export declare const entitiesMap: {
             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.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
         }, undefined>, v.ReadonlyAction<{
             type: "select";
             readonly options: readonly [string, ...string[]];
@@ -28,6 +29,7 @@ export declare const entitiesMap: {
             optionLabels: {
                 [x: string]: string;
             };
+            tags?: readonly string[] | undefined;
         }>]>;
     };
     readonly toggle: {
@@ -37,11 +39,13 @@ export declare const entitiesMap: {
             readonly valueType: v.PicklistSchema<["string", "boolean", "number"], 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.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
         }, undefined>, v.ReadonlyAction<{
             type: "toggle";
             valueType: "string" | "number" | "boolean";
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>]>;
     };
     readonly uiPage: {
@@ -169,6 +173,7 @@ export declare const entitiesMap: {
                 }>]>, v.UnknownSchema], undefined>, undefined>, v.ReadonlyAction<{
                     [x: string]: unknown;
                 }>]>], undefined>, undefined>;
+                readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
             }, undefined>, v.ReadonlyAction<{
                 type: "input";
                 path: readonly (string | number)[] | Readonly<{
@@ -205,6 +210,7 @@ export declare const entitiesMap: {
                 }> | Readonly<{
                     [x: string]: unknown;
                 }> | undefined;
+                tags?: readonly string[] | undefined;
             }>]>], undefined>, undefined>, v.ReadonlyAction<(Readonly<{
                 type: "parameter";
                 id: string;
@@ -248,7 +254,9 @@ export declare const entitiesMap: {
                 }> | Readonly<{
                     [x: string]: unknown;
                 }> | undefined;
+                tags?: readonly string[] | undefined;
             }>)[]>]>], undefined>;
+            readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
         }, undefined>, v.ReadonlyAction<{
             type: "page";
             label: string | Readonly<{
@@ -309,7 +317,9 @@ export declare const entitiesMap: {
                 }> | Readonly<{
                     [x: string]: unknown;
                 }> | undefined;
+                tags?: readonly string[] | undefined;
             }>)[];
+            tags?: readonly string[] | undefined;
         }>]>;
     };
     readonly uiDescribe: {
@@ -437,6 +447,7 @@ export declare const entitiesMap: {
                 }>]>, v.UnknownSchema], undefined>, undefined>, v.ReadonlyAction<{
                     [x: string]: unknown;
                 }>]>], undefined>, undefined>;
+                readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
             }, undefined>, v.ReadonlyAction<{
                 type: "input";
                 path: readonly (string | number)[] | Readonly<{
@@ -473,6 +484,7 @@ export declare const entitiesMap: {
                 }> | Readonly<{
                     [x: string]: unknown;
                 }> | undefined;
+                tags?: readonly string[] | undefined;
             }>]>], undefined>, undefined>, v.ReadonlyAction<(Readonly<{
                 type: "parameter";
                 id: string;
@@ -516,7 +528,9 @@ export declare const entitiesMap: {
                 }> | Readonly<{
                     [x: string]: unknown;
                 }> | undefined;
+                tags?: readonly string[] | undefined;
             }>)[]>]>], undefined>;
+            readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
         }, undefined>, v.ReadonlyAction<{
             type: "describe";
             label: string | Readonly<{
@@ -577,7 +591,9 @@ export declare const entitiesMap: {
                 }> | Readonly<{
                     [x: string]: unknown;
                 }> | undefined;
+                tags?: readonly string[] | undefined;
             }>)[];
+            tags?: readonly string[] | undefined;
         }>]>;
     };
     readonly uiPages: {
@@ -664,6 +680,7 @@ export declare const entitiesMap: {
             }>]>, v.UnknownSchema], undefined>, undefined>, v.ReadonlyAction<{
                 [x: string]: unknown;
             }>]>], undefined>, undefined>;
+            readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
         }, undefined>, v.ReadonlyAction<{
             type: "input";
             path: readonly (string | number)[] | Readonly<{
@@ -700,6 +717,39 @@ export declare const entitiesMap: {
             }> | Readonly<{
                 [x: string]: unknown;
             }> | undefined;
+            tags?: readonly string[] | undefined;
+        }>]>;
+    };
+    readonly pricing: {
+        readonly runtime: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+            readonly rates: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.NumberSchema<undefined>, undefined>, undefined>, v.ReadonlyAction<{
+                [x: string]: {
+                    [x: string]: number;
+                };
+            }>]>;
+            readonly formula: v.GenericSchema<import("./pricing.js").BuilderPricingExpression>;
+        }, undefined>, v.ReadonlyAction<{
+            readonly rates: Readonly<{
+                [x: string]: {
+                    [x: string]: number;
+                };
+            }>;
+            formula: import("./pricing.js").BuilderPricingExpression;
+        }>]>;
+        readonly serialised: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+            readonly rates: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.NumberSchema<undefined>, undefined>, undefined>, v.ReadonlyAction<{
+                [x: string]: {
+                    [x: string]: number;
+                };
+            }>]>;
+            readonly formula: v.GenericSchema<import("./pricing.js").BuilderPricingExpression>;
+        }, undefined>, v.ReadonlyAction<{
+            readonly rates: Readonly<{
+                [x: string]: {
+                    [x: string]: number;
+                };
+            }>;
+            formula: import("./pricing.js").BuilderPricingExpression;
         }>]>;
     };
     readonly componentDetails: {
@@ -724,17 +774,21 @@ export declare const entitiesMap: {
                 readonly name: v.StringSchema<undefined>;
                 readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
                 readonly isOptional: v.BooleanSchema<undefined>;
+                readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
             }, undefined>, v.ReadonlyAction<{
                 type: "component-field";
                 name: string;
                 valueType: "string" | "number" | "boolean";
                 isOptional: boolean;
+                tags?: readonly string[] | undefined;
             }>]>, undefined>, v.ReadonlyAction<Readonly<{
                 type: "component-field";
                 name: string;
                 valueType: "string" | "number" | "boolean";
                 isOptional: boolean;
+                tags?: readonly string[] | undefined;
             }>[]>]>], undefined>;
+            readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
         }, undefined>, v.ReadonlyAction<{
             fields: Readonly<{
                 type: "parameter";
@@ -748,7 +802,9 @@ export declare const entitiesMap: {
                 name: string;
                 valueType: "string" | "number" | "boolean";
                 isOptional: boolean;
+                tags?: readonly string[] | undefined;
             }>[];
+            tags?: readonly string[] | undefined;
         }>]>;
     };
     readonly collectionConfig: {
@@ -799,6 +855,7 @@ export declare const entitiesMap: {
                 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";
@@ -824,6 +881,7 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }>;
+            tags?: readonly string[] | undefined;
         }>]>;
     };
     readonly expectations: {
@@ -894,11 +952,13 @@ export declare const entitiesMap: {
             optionLabels: {
                 [x: string]: string;
             };
+            tags?: readonly string[] | undefined;
         }>> | Readonly<Readonly<{
             type: "toggle";
             valueType: "string" | "number" | "boolean";
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>>>>;
         readonly serialised: v.GenericSchema<import("./when.js").BuilderWhenSerialised<Readonly<Readonly<{
             type: "select";
@@ -908,11 +968,13 @@ export declare const entitiesMap: {
             optionLabels: {
                 [x: string]: string;
             };
+            tags?: readonly string[] | undefined;
         }>> | Readonly<Readonly<{
             type: "toggle";
             valueType: "string" | "number" | "boolean";
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>>>>;
     };
     readonly componentWhen: {
@@ -929,7 +991,9 @@ export declare const entitiesMap: {
                 name: string;
                 valueType: "string" | "number" | "boolean";
                 isOptional: boolean;
+                tags?: readonly string[] | undefined;
             }>[];
+            tags?: readonly string[] | undefined;
         }>>>;
         readonly serialised: v.GenericSchema<import("./when.js").BuilderWhenSerialised<Readonly<{
             fields: Readonly<{
@@ -944,7 +1008,9 @@ export declare const entitiesMap: {
                 name: string;
                 valueType: "string" | "number" | "boolean";
                 isOptional: boolean;
+                tags?: readonly string[] | undefined;
             }>[];
+            tags?: readonly string[] | undefined;
         }>>>;
     };
     readonly collectionWhen: {
@@ -973,6 +1039,7 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }>;
+            tags?: readonly string[] | undefined;
         }>>>;
         readonly serialised: v.GenericSchema<import("./when.js").BuilderWhenSerialised<Readonly<{
             model: Readonly<{
@@ -999,6 +1066,7 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }>;
+            tags?: readonly string[] | undefined;
         }>>>;
     };
     readonly optionSelectMap: {
@@ -1014,11 +1082,13 @@ export declare const entitiesMap: {
             optionLabels: {
                 [x: string]: string;
             };
+            tags?: readonly string[] | undefined;
         }>> | Readonly<Readonly<{
             type: "toggle";
             valueType: "string" | "number" | "boolean";
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>>>>;
         readonly serialised: v.GenericSchema<import("./when.js").BuilderMatchSelectMap<Readonly<{
             type: "parameter";
@@ -1032,11 +1102,13 @@ export declare const entitiesMap: {
             optionLabels: {
                 [x: string]: string;
             };
+            tags?: readonly string[] | undefined;
         }>> | Readonly<Readonly<{
             type: "toggle";
             valueType: "string" | "number" | "boolean";
             defaultValue: string | number | boolean | null;
             isOptional: boolean;
+            tags?: readonly string[] | undefined;
         }>>>>;
     };
     readonly componentSelectMap: {
@@ -1057,7 +1129,9 @@ export declare const entitiesMap: {
                 name: string;
                 valueType: "string" | "number" | "boolean";
                 isOptional: boolean;
+                tags?: readonly string[] | undefined;
             }>[];
+            tags?: readonly string[] | undefined;
         }>>>;
         readonly serialised: v.GenericSchema<import("./when.js").BuilderMatchSelectMap<Readonly<{
             type: "parameter";
@@ -1076,7 +1150,9 @@ export declare const entitiesMap: {
                 name: string;
                 valueType: "string" | "number" | "boolean";
                 isOptional: boolean;
+                tags?: readonly string[] | undefined;
             }>[];
+            tags?: readonly string[] | undefined;
         }>>>;
     };
     readonly collectionSelectMap: {
@@ -1109,6 +1185,7 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }>;
+            tags?: readonly string[] | undefined;
         }>>>;
         readonly serialised: v.GenericSchema<import("./when.js").BuilderMatchSelectMap<Readonly<{
             type: "parameter";
@@ -1139,6 +1216,7 @@ export declare const entitiesMap: {
                 type: "ref";
                 id: string;
             }>;
+            tags?: readonly string[] | undefined;
         }>>>;
     };
     readonly paths: {

package/dist/entities/serialise.js

@@ -6,6 +6,7 @@ import { BuilderCollectionConfigSchema, BuilderCollectionConfigSerialisedSchema,
 import { BuilderComponentDetailsSchema, BuilderComponentDetailsSerialisedSchema, BuilderComponentFieldSchema, BuilderComponentSchema, BuilderComponentSelectMapSerialisedSchema, BuilderComponentWhenSerialisedSchema } from './component/index.js';
 import { BuilderExpectationSchema, BuilderExpectationsSchema, BuilderExpectationsSerialisedSchema } from './expectation.js';
 import { BuilderModelSchema, BuilderModelSerialisedSchema } from './model/index.js';
+import { BuilderPricingSchema } from './pricing.js';
 import { BuilderOptionSchema, BuilderOptionSelectMapSerialisedSchema, BuilderOptionWhenSerialisedSchema, BuilderSelectTypeSchema, BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSchema, BuilderToggleTypeSerialisedSchema } from './option/index.js';
 import { BuilderUIDescribeSchema, BuilderUIDescribeSerialisedSchema, BuilderUIInputSchema, BuilderUIInputSerialisedSchema, BuilderUIItemsSerialisedSchema, BuilderUIPageSchema, BuilderUIPageSerialisedSchema, BuilderUIPagesSchema, BuilderUIPagesSerialisedSchema, BuilderUISchema, BuilderUISerialisedSchema } from './ui/index.js';
 import { BuilderSchema, BuilderSerialisedSchema } from './builder/index.js';
@@ -19,6 +20,7 @@ export const entitiesMap = {
     uiDescribe: { runtime: BuilderUIDescribeSchema, serialised: BuilderUIDescribeSerialisedSchema },
     uiPages: { runtime: BuilderUIPagesSchema, serialised: BuilderUIPagesSerialisedSchema },
     uiInput: { runtime: BuilderUIInputSchema, serialised: BuilderUIInputSerialisedSchema },
+    pricing: { runtime: BuilderPricingSchema, serialised: BuilderPricingSchema },
     componentDetails: {
         runtime: BuilderComponentDetailsSchema,
         serialised: BuilderComponentDetailsSerialisedSchema
@@ -93,64 +95,78 @@ const serialiserMap = [
     serialiser(BuilderSchema, (value) => ({
         model: serialiseValue(value.model),
         ui: serialiseValue(value.ui),
-        bindings: serialiseRecord(value.bindings)
+        bindings: serialiseRecord(value.bindings),
+        tags: value.tags,
+        pricing: value.pricing
     })),
     serialiser(BuilderModelSchema, (value) => ({
         models: value.models.map(serialiseValue),
         options: value.options.map(serialiseValue),
         components: value.components.map(serialiseValue),
         collections: value.collections.map(serialiseValue),
-        expectations: value.expectations.map(serialiseValue)
+        expectations: value.expectations.map(serialiseValue),
+        tags: value.tags
     })),
     serialiser(BuilderUISchema, (value) => ({
         uis: value.uis.map(serialiseValue),
         items: value.items.map(serialiseValue),
-        expectations: value.expectations.map(serialiseValue)
+        expectations: value.expectations.map(serialiseValue),
+        tags: value.tags
     })),
     serialiser(BuilderUIPageSchema, (value) => ({
         type: 'page',
         label: serialiseValue(value.label),
-        inputs: serialiseValue(value.inputs)
+        inputs: serialiseValue(value.inputs),
+        tags: value.tags
     })),
     serialiser(BuilderUIDescribeSchema, (value) => ({
         type: 'describe',
         label: serialiseValue(value.label),
-        inputs: serialiseValue(value.inputs)
+        inputs: serialiseValue(value.inputs),
+        tags: value.tags
     })),
     serialiser(BuilderUIPagesSchema, (value) => ({
         type: 'pages',
         name: value.name,
         label: serialiseValue(value.label),
-        items: serialiseValue(value.items)
+        items: serialiseValue(value.items),
+        tags: value.tags
     })),
     serialiser(BuilderUIInputSchema, (value) => serialiseRecord({ ...value })),
     serialiser(BuilderOptionSchema, serialiseNamedEntry),
     serialiser(BuilderComponentSchema, serialiseNamedEntry),
     serialiser(BuilderCollectionSchema, serialiseNamedEntry),
-    serialiser(BuilderComponentDetailsSchema, (value) => ({ fields: serialiseValue(value.fields) })),
+    serialiser(BuilderComponentDetailsSchema, (value) => ({
+        fields: serialiseValue(value.fields),
+        tags: value.tags
+    })),
     serialiser(BuilderComponentFieldSchema, (value) => ({
         type: 'component-field',
         name: value.name,
         valueType: value.valueType,
-        isOptional: value.isOptional
+        isOptional: value.isOptional,
+        tags: value.tags
     })),
     serialiser(BuilderCollectionConfigSchema, (value) => ({
         model: serialiseValue(value.model),
         min: serialiseValue(value.min),
-        max: serialiseValue(value.max)
+        max: serialiseValue(value.max),
+        tags: value.tags
     })),
     serialiser(BuilderSelectTypeSchema, (value) => ({
         type: 'select',
         options: value.options,
         defaultValue: value.defaultValue,
         isOptional: value.isOptional,
-        optionLabels: value.optionLabels
+        optionLabels: value.optionLabels,
+        tags: value.tags
     })),
     serialiser(BuilderToggleTypeSchema, (value) => ({
         type: 'toggle',
         valueType: value.valueType,
         defaultValue: value.defaultValue,
-        isOptional: value.isOptional
+        isOptional: value.isOptional,
+        tags: value.tags
     })),
     serialiser(BuilderExpectationSchema, (value) => ({ name: value.name, kind: value.kind }))
 ];
@@ -162,6 +178,9 @@ function serialiseNamedEntry(value) {
     if (value.paths != null) {
         entry.paths = serialiseValue(value.paths);
     }
+    if (value.tags != null) {
+        entry.tags = serialiseValue(value.tags);
+    }
     return entry;
 }
 function serialiseRecord(record) {