@builder-builder/builder 0.0.13 → 0.0.15

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

@@ -1,5 +1,6 @@
 import type { BuilderPaths } from '../../paths';
 import type { Paramable } from '../../references';
+import type { BuilderTags } from '../tags';
 import type { BuilderWhenSerialised } from '../when';
 import type { BuilderOptionValues, BuilderOptionValuesSerialised } from './values';
 import type { BuilderOptionWhen } from './when';
@@ -10,7 +11,9 @@ export declare class BuilderOption<const Name extends string = string, const Pay
     readonly name: Name;
     readonly payload: Payload;
     readonly paths?: Paths;
-    constructor(name: Name, payload: Payload, paths?: Paths);
+    readonly tags?: BuilderTags;
+    constructor(name: Name, payload: Payload, paths?: Paths, tags?: BuilderTags);
+    tag(...tags: Array<string>): BuilderOption<Name, Payload, Paths>;
 }
 export declare const BuilderOptionSchema: v.InstanceSchema<typeof BuilderOption, undefined>;
 export type BuilderOptions = ReadonlyArray<BuilderOption>;
@@ -22,11 +25,13 @@ export declare const BuilderOptionWhenSerialisedSchema: v.GenericSchema<BuilderW
     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;
 }>>>>;
 export type BuilderOptionWhenSerialised = BuilderWhenSerialised<BuilderOptionValuesSerialised>;
 export declare const BuilderOptionSelectMapSerialisedSchema: v.GenericSchema<import("..").BuilderMatchSelectMap<Readonly<{
@@ -41,11 +46,13 @@ export declare const BuilderOptionSelectMapSerialisedSchema: v.GenericSchema<imp
     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;
 }>>>>;
 export declare const BuilderOptionSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly name: v.StringSchema<undefined>;
@@ -69,6 +76,7 @@ export declare const BuilderOptionSerialisedSchema: v.SchemaWithPipe<readonly [v
         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[]];
@@ -77,16 +85,19 @@ export declare const BuilderOptionSerialisedSchema: v.SchemaWithPipe<readonly [v
         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[]];
@@ -95,11 +106,13 @@ export declare const BuilderOptionSerialisedSchema: v.SchemaWithPipe<readonly [v
         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;
     }>>]>, v.GenericSchema<BuilderWhenSerialised<Readonly<Readonly<{
         type: "select";
         readonly options: readonly [string, ...string[]];
@@ -108,11 +121,13 @@ export declare const BuilderOptionSerialisedSchema: v.SchemaWithPipe<readonly [v
         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;
     }>>>>], undefined>], undefined>;
     readonly paths: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
         readonly type: v.LiteralSchema<"parameter", undefined>;
@@ -129,6 +144,7 @@ export declare const BuilderOptionSerialisedSchema: v.SchemaWithPipe<readonly [v
         type: "ref";
         id: string;
     }>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>], undefined>, undefined>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     name: string;
     payload: Readonly<{
@@ -146,11 +162,13 @@ export declare const BuilderOptionSerialisedSchema: v.SchemaWithPipe<readonly [v
         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;
     }>> | BuilderWhenSerialised<Readonly<Readonly<{
         type: "select";
         readonly options: readonly [string, ...string[]];
@@ -159,11 +177,13 @@ export declare const BuilderOptionSerialisedSchema: v.SchemaWithPipe<readonly [v
         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;
     }>>>;
     paths?: readonly (readonly (string | number)[])[] | Readonly<{
         type: "parameter";
@@ -173,6 +193,7 @@ export declare const BuilderOptionSerialisedSchema: v.SchemaWithPipe<readonly [v
         type: "ref";
         id: string;
     }> | undefined;
+    tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderOptionSerialised = v.InferOutput<typeof BuilderOptionSerialisedSchema>;
 export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
@@ -197,6 +218,7 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         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[]];
@@ -205,16 +227,19 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         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[]];
@@ -223,11 +248,13 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         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;
     }>>]>, v.GenericSchema<BuilderWhenSerialised<Readonly<Readonly<{
         type: "select";
         readonly options: readonly [string, ...string[]];
@@ -236,11 +263,13 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         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;
     }>>>>], undefined>], undefined>;
     readonly paths: v.OptionalSchema<v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
         readonly type: v.LiteralSchema<"parameter", undefined>;
@@ -257,6 +286,7 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         type: "ref";
         id: string;
     }>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<(string | number)[]>]>, undefined>, v.ReadonlyAction<(readonly (string | number)[])[]>]>], undefined>, undefined>;
+    readonly tags: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.ReadonlyAction<string[]>]>, undefined>;
 }, undefined>, v.ReadonlyAction<{
     name: string;
     payload: Readonly<{
@@ -274,11 +304,13 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         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;
     }>> | BuilderWhenSerialised<Readonly<Readonly<{
         type: "select";
         readonly options: readonly [string, ...string[]];
@@ -287,11 +319,13 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         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;
     }>>>;
     paths?: readonly (readonly (string | number)[])[] | Readonly<{
         type: "parameter";
@@ -301,6 +335,7 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         type: "ref";
         id: string;
     }> | undefined;
+    tags?: readonly string[] | undefined;
 }>]>, undefined>, v.ReadonlyAction<Readonly<{
     name: string;
     payload: Readonly<{
@@ -318,11 +353,13 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         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;
     }>> | BuilderWhenSerialised<Readonly<Readonly<{
         type: "select";
         readonly options: readonly [string, ...string[]];
@@ -331,11 +368,13 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         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;
     }>>>;
     paths?: readonly (readonly (string | number)[])[] | Readonly<{
         type: "parameter";
@@ -345,5 +384,6 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         type: "ref";
         id: string;
     }> | undefined;
+    tags?: readonly string[] | undefined;
 }>[]>]>;
 export type BuilderOptionsSerialised = v.InferOutput<typeof BuilderOptionsSerialisedSchema>;

package/dist/entities/option/option.js

@@ -2,16 +2,22 @@ import * as v from 'valibot';
 import { BuilderPathsSchema } from '../../paths.js';
 import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
 import { createSelectMapSerialisedSchema, createWhenSerialisedSchema } from '../when.js';
 import { BuilderOptionValuesSerialisedSchema } from './values.js';
 export class BuilderOption {
     name;
     payload;
     paths;
-    constructor(name, payload, paths) {
+    tags;
+    constructor(name, payload, paths, tags) {
         this.name = name;
         this.payload = payload;
         this.paths = paths;
+        this.tags = tags;
+    }
+    tag(...tags) {
+        return new BuilderOption(this.name, this.payload, this.paths, tags);
     }
 }
 export const BuilderOptionSchema = v.instance(BuilderOption);
@@ -20,6 +26,7 @@ export const BuilderOptionSelectMapSerialisedSchema = createSelectMapSerialisedS
 export const BuilderOptionSerialisedSchema = serialisable(v.object({
     name: v.string(),
     payload: paramable(v.union([BuilderOptionValuesSerialisedSchema, BuilderOptionWhenSerialisedSchema])),
-    paths: v.optional(paramable(BuilderPathsSchema))
+    paths: v.optional(paramable(BuilderPathsSchema)),
+    tags: v.optional(BuilderTagsSchema)
 }));
 export const BuilderOptionsSerialisedSchema = v.pipe(v.array(BuilderOptionSerialisedSchema), v.readonly());

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

@@ -1,7 +1,9 @@
+import type { BuilderTags } from '../tags';
 import * as v from 'valibot';
 export type BuilderSelectTypeLabels<Values extends BuilderSelectTypeValues> = Partial<Record<Values[number], string>>;
 export type BuilderSelectTypeValues = readonly [string, ...ReadonlyArray<string>];
 export declare class BuilderSelectType<const Values extends BuilderSelectTypeValues = BuilderSelectTypeValues, const ValueSchema extends v.GenericSchema<string | null> = v.GenericSchema<string | null>> {
+    #private;
     readonly value: v.InferOutput<ValueSchema>;
     readonly type: "select";
     readonly options: Values;
@@ -9,10 +11,12 @@ export declare class BuilderSelectType<const Values extends BuilderSelectTypeVal
     readonly defaultValue: v.InferOutput<ValueSchema>;
     readonly isOptional: boolean;
     readonly optionLabels: BuilderSelectTypeLabels<Values>;
-    constructor(values: Values, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, optionLabels?: BuilderSelectTypeLabels<Values>);
+    readonly tags?: BuilderTags;
+    constructor(values: Values, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean, optionLabels?: BuilderSelectTypeLabels<Values>, tags?: BuilderTags);
     default(newDefault: v.InferOutput<ValueSchema>): BuilderSelectType<Values, ValueSchema>;
     optional(): BuilderSelectType<Values, v.NullableSchema<ValueSchema, undefined>>;
     labels(optionLabels: BuilderSelectTypeLabels<Values>): BuilderSelectType<Values, ValueSchema>;
+    tag(...tags: Array<string>): BuilderSelectType<Values, ValueSchema>;
 }
 type SelectSchema<Values extends BuilderSelectTypeValues> = v.UnionSchema<{
     [K in keyof Values]: v.LiteralSchema<Values[K], undefined>;
@@ -25,6 +29,7 @@ export declare const BuilderSelectTypeSerialisedSchema: v.SchemaWithPipe<readonl
     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[]];
@@ -33,6 +38,7 @@ export declare const BuilderSelectTypeSerialisedSchema: v.SchemaWithPipe<readonl
     optionLabels: {
         [x: string]: string;
     };
+    tags?: readonly string[] | undefined;
 }>]>;
 export type BuilderSelectTypeSerialised = v.InferOutput<typeof BuilderSelectTypeSerialisedSchema>;
 export declare function selectValueSchema(options: ReadonlyArray<string>, optional: boolean): v.GenericSchema<string | null>;

package/dist/entities/option/select.js

@@ -1,5 +1,6 @@
 import * as v from 'valibot';
 import { serialisable } from '../../serialisable.js';
+import { BuilderTagsSchema } from '../tags.js';
 export class BuilderSelectType {
     type = 'select';
     options;
@@ -7,22 +8,31 @@ export class BuilderSelectType {
     defaultValue;
     isOptional;
     optionLabels;
-    constructor(values, defaultValue, optional = false, optionLabels = {}) {
+    tags;
+    constructor(values, defaultValue, optional = false, optionLabels = {}, tags) {
         this.options = values;
         this.valueSchema = selectValueSchema(values, optional);
         this.defaultValue = defaultValue;
         this.isOptional = optional;
         this.optionLabels = optionLabels;
+        this.tags = tags;
+    }
+    #next(patch) {
+        return new BuilderSelectType(this.options, 'defaultValue' in patch
+            ? patch.defaultValue
+            : this.defaultValue, patch.optional ?? this.isOptional, patch.optionLabels ?? this.optionLabels, patch.tags ?? this.tags);
     }
     default(newDefault) {
-        return new BuilderSelectType(this.options, newDefault, this.isOptional, this.optionLabels);
+        return this.#next({ defaultValue: newDefault });
     }
     optional() {
-        const { options, defaultValue } = this;
-        return new BuilderSelectType(options, defaultValue, true, this.optionLabels);
+        return this.#next({ optional: true });
     }
     labels(optionLabels) {
-        return new BuilderSelectType(this.options, this.defaultValue, this.isOptional, optionLabels);
+        return this.#next({ optionLabels });
+    }
+    tag(...tags) {
+        return this.#next({ tags });
     }
 }
 export function select(values) {
@@ -35,7 +45,8 @@ export const BuilderSelectTypeSerialisedSchema = serialisable(v.object({
     options: v.pipe(v.tupleWithRest([v.string()], v.string()), v.readonly()),
     defaultValue: v.nullable(v.string()),
     isOptional: v.boolean(),
-    optionLabels: v.record(v.string(), v.string())
+    optionLabels: v.record(v.string(), v.string()),
+    tags: v.optional(BuilderTagsSchema)
 }));
 export function selectValueSchema(options, optional) {
     const baseSchema = v.union(options.map((value) => v.literal(value)));

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
+}));