@builder-builder/builder 0.0.9 → 0.0.11

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

@@ -1,48 +1,75 @@
 import type { BuilderPaths } from '../../paths';
-import type { Refable } from '../../references';
-import type { BuilderWhen, WhenSerialised } from '../when';
+import type { Paramable } from '../../references';
+import type { BuilderWhenSerialised } from '../when';
 import type { BuilderOptionValues, BuilderOptionValuesSerialised } from './values';
+import type { BuilderOptionWhen } from './when';
 import * as v from 'valibot';
-export type BuilderOptionPayload = BuilderOptionValues | BuilderWhen<Refable<BuilderOptionValues>>;
-export declare class BuilderOption<const Name extends string = string, const Payload extends Refable<BuilderOptionPayload> = Refable<BuilderOptionPayload>, const GatePaths extends Refable<BuilderPaths> = Refable<BuilderPaths>> {
+export type BuilderOptionPayload = BuilderOptionValues | BuilderOptionWhen;
+export declare class BuilderOption<const Name extends string = string, const Payload extends Paramable<BuilderOptionPayload> = Paramable<BuilderOptionPayload>, const Paths extends Paramable<BuilderPaths> = Paramable<BuilderPaths>> {
     readonly type: 'option';
     readonly name: Name;
     readonly payload: Payload;
-    readonly gatePaths?: GatePaths;
-    constructor(name: Name, payload: Payload, gatePaths?: GatePaths);
+    readonly paths?: Paths;
+    constructor(name: Name, payload: Payload, paths?: Paths);
 }
 export declare const BuilderOptionSchema: v.InstanceSchema<typeof BuilderOption, undefined>;
 export type BuilderOptions = ReadonlyArray<BuilderOption>;
-export declare const BuilderOptionWhenSerialisedSchema: v.GenericSchema;
-export type BuilderOptionWhenSerialised = WhenSerialised<BuilderOptionValuesSerialised>;
+export declare const BuilderOptionWhenSerialisedSchema: v.GenericSchema<BuilderWhenSerialised<Readonly<Readonly<{
+    type: "select";
+    readonly options: readonly [string, ...string[]];
+    defaultValue: string | null;
+    isOptional: boolean;
+    optionLabels: {
+        [x: string]: string;
+    };
+}>> | Readonly<Readonly<{
+    type: "toggle";
+    valueType: "string" | "number" | "boolean";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+}>>>>;
+export type BuilderOptionWhenSerialised = BuilderWhenSerialised<BuilderOptionValuesSerialised>;
+export declare const BuilderOptionSelectMapSerialisedSchema: v.GenericSchema<import("..").BuilderMatchSelectMap<Readonly<{
+    type: "parameter";
+    id: string;
+    name: string;
+}> | Readonly<Readonly<{
+    type: "select";
+    readonly options: readonly [string, ...string[]];
+    defaultValue: string | null;
+    isOptional: boolean;
+    optionLabels: {
+        [x: string]: string;
+    };
+}>> | Readonly<Readonly<{
+    type: "toggle";
+    valueType: "string" | "number" | "boolean";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+}>>>>;
 export declare const BuilderOptionSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly name: v.StringSchema<undefined>;
-    readonly payload: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"ref", undefined>;
+    readonly payload: 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: "ref";
+        type: "parameter";
         id: string;
         name: string;
-    }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, undefined>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        type: "ref";
+        id: string;
+    }>]>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.SchemaWithPipe<readonly [v.ObjectSchema<{
         readonly type: v.LiteralSchema<"select", undefined>;
         readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
         readonly defaultValue: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly isOptional: v.BooleanSchema<undefined>;
         readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
-    }, undefined>, v.MetadataAction<{
-        type: "select";
-        readonly options: readonly [string, ...string[]];
-        defaultValue: string | null;
-        isOptional: boolean;
-        optionLabels: {
-            [x: string]: string;
-        };
-    }, {
-        readonly serialisable: typeof import("./select").BuilderSelectType;
-        readonly instance: v.InstanceSchema<typeof import("./select").BuilderSelectType, undefined>;
-    }>, v.ReadonlyAction<{
+    }, undefined>, v.ReadonlyAction<{
         type: "select";
         readonly options: readonly [string, ...string[]];
         defaultValue: string | null;
@@ -55,20 +82,25 @@ export declare const BuilderOptionSerialisedSchema: v.SchemaWithPipe<readonly [v
         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>;
-    }, undefined>, v.MetadataAction<{
+    }, undefined>, v.ReadonlyAction<{
         type: "toggle";
         valueType: "string" | "number" | "boolean";
         defaultValue: string | number | boolean | null;
         isOptional: boolean;
-    }, {
-        readonly serialisable: typeof import("./toggle").BuilderToggleType;
-        readonly instance: v.InstanceSchema<typeof import("./toggle").BuilderToggleType, undefined>;
-    }>, v.ReadonlyAction<{
+    }>]>], undefined>, v.ReadonlyAction<Readonly<{
+        type: "select";
+        readonly options: readonly [string, ...string[]];
+        defaultValue: string | null;
+        isOptional: boolean;
+        optionLabels: {
+            [x: string]: string;
+        };
+    }> | Readonly<{
         type: "toggle";
         valueType: "string" | "number" | "boolean";
         defaultValue: string | number | boolean | null;
         isOptional: boolean;
-    }>]>], undefined>, v.ReadonlyAction<Readonly<{
+    }>>]>, v.GenericSchema<BuilderWhenSerialised<Readonly<Readonly<{
         type: "select";
         readonly options: readonly [string, ...string[]];
         defaultValue: string | null;
@@ -76,134 +108,96 @@ export declare const BuilderOptionSerialisedSchema: v.SchemaWithPipe<readonly [v
         optionLabels: {
             [x: string]: string;
         };
-    }> | Readonly<{
+    }>> | Readonly<Readonly<{
         type: "toggle";
         valueType: "string" | "number" | "boolean";
         defaultValue: string | number | boolean | null;
         isOptional: boolean;
-    }>>]>, v.GenericSchema], undefined>], undefined>, v.MetadataAction<unknown, {
-        readonly refable: v.UnionSchema<[v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.SchemaWithPipe<readonly [v.ObjectSchema<{
-            readonly type: v.LiteralSchema<"select", undefined>;
-            readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
-            readonly defaultValue: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            readonly isOptional: v.BooleanSchema<undefined>;
-            readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
-        }, undefined>, v.MetadataAction<{
-            type: "select";
-            readonly options: readonly [string, ...string[]];
-            defaultValue: string | null;
-            isOptional: boolean;
-            optionLabels: {
-                [x: string]: string;
-            };
-        }, {
-            readonly serialisable: typeof import("./select").BuilderSelectType;
-            readonly instance: v.InstanceSchema<typeof import("./select").BuilderSelectType, undefined>;
-        }>, v.ReadonlyAction<{
-            type: "select";
-            readonly options: readonly [string, ...string[]];
-            defaultValue: string | null;
-            isOptional: boolean;
-            optionLabels: {
-                [x: string]: string;
-            };
-        }>]>, 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>;
-        }, undefined>, v.MetadataAction<{
-            type: "toggle";
-            valueType: "string" | "number" | "boolean";
-            defaultValue: string | number | boolean | null;
-            isOptional: boolean;
-        }, {
-            readonly serialisable: typeof import("./toggle").BuilderToggleType;
-            readonly instance: v.InstanceSchema<typeof import("./toggle").BuilderToggleType, undefined>;
-        }>, v.ReadonlyAction<{
-            type: "toggle";
-            valueType: "string" | "number" | "boolean";
-            defaultValue: string | number | boolean | null;
-            isOptional: boolean;
-        }>]>], undefined>, v.ReadonlyAction<Readonly<{
-            type: "select";
-            readonly options: readonly [string, ...string[]];
-            defaultValue: string | null;
-            isOptional: boolean;
-            optionLabels: {
-                [x: string]: string;
-            };
-        }> | Readonly<{
-            type: "toggle";
-            valueType: "string" | "number" | "boolean";
-            defaultValue: string | number | boolean | null;
-            isOptional: boolean;
-        }>>]>, v.GenericSchema], undefined>;
-    }>]>;
-    readonly gatePaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"ref", undefined>;
+    }>>>>], undefined>], undefined>;
+    readonly paths: v.OptionalSchema<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: "ref";
+        type: "parameter";
         id: string;
         name: string;
-    }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, undefined>, 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>, v.MetadataAction<readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+    }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
         type: "ref";
         id: string;
-        name: string;
-    }>, {
-        readonly refable: 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>, v.MetadataAction<{
+    }>]>, 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>;
+}, undefined>, v.ReadonlyAction<{
     name: string;
-    payload: unknown;
-    gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-        type: "ref";
+    payload: Readonly<{
+        type: "parameter";
         id: string;
         name: string;
-    }> | undefined;
-}, {
-    readonly serialisable: typeof BuilderOption;
-    readonly instance: v.InstanceSchema<typeof BuilderOption, undefined>;
-}>, v.ReadonlyAction<{
-    name: string;
-    payload: unknown;
-    gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+    }> | Readonly<{
         type: "ref";
         id: string;
+    }> | Readonly<Readonly<{
+        type: "select";
+        readonly options: readonly [string, ...string[]];
+        defaultValue: string | null;
+        isOptional: boolean;
+        optionLabels: {
+            [x: string]: string;
+        };
+    }>> | Readonly<Readonly<{
+        type: "toggle";
+        valueType: "string" | "number" | "boolean";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+    }>> | BuilderWhenSerialised<Readonly<Readonly<{
+        type: "select";
+        readonly options: readonly [string, ...string[]];
+        defaultValue: string | null;
+        isOptional: boolean;
+        optionLabels: {
+            [x: string]: string;
+        };
+    }>> | Readonly<Readonly<{
+        type: "toggle";
+        valueType: "string" | "number" | "boolean";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+    }>>>;
+    paths?: readonly (readonly (string | number)[])[] | Readonly<{
+        type: "parameter";
+        id: string;
         name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
     }> | undefined;
 }>]>;
 export type BuilderOptionSerialised = v.InferOutput<typeof BuilderOptionSerialisedSchema>;
 export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
     readonly name: v.StringSchema<undefined>;
-    readonly payload: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"ref", undefined>;
+    readonly payload: 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: "ref";
+        type: "parameter";
         id: string;
         name: string;
-    }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, undefined>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
+        type: "ref";
+        id: string;
+    }>]>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.SchemaWithPipe<readonly [v.ObjectSchema<{
         readonly type: v.LiteralSchema<"select", undefined>;
         readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
         readonly defaultValue: v.NullableSchema<v.StringSchema<undefined>, undefined>;
         readonly isOptional: v.BooleanSchema<undefined>;
         readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
-    }, undefined>, v.MetadataAction<{
-        type: "select";
-        readonly options: readonly [string, ...string[]];
-        defaultValue: string | null;
-        isOptional: boolean;
-        optionLabels: {
-            [x: string]: string;
-        };
-    }, {
-        readonly serialisable: typeof import("./select").BuilderSelectType;
-        readonly instance: v.InstanceSchema<typeof import("./select").BuilderSelectType, undefined>;
-    }>, v.ReadonlyAction<{
+    }, undefined>, v.ReadonlyAction<{
         type: "select";
         readonly options: readonly [string, ...string[]];
         defaultValue: string | null;
@@ -216,20 +210,25 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         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>;
-    }, undefined>, v.MetadataAction<{
+    }, undefined>, v.ReadonlyAction<{
         type: "toggle";
         valueType: "string" | "number" | "boolean";
         defaultValue: string | number | boolean | null;
         isOptional: boolean;
-    }, {
-        readonly serialisable: typeof import("./toggle").BuilderToggleType;
-        readonly instance: v.InstanceSchema<typeof import("./toggle").BuilderToggleType, undefined>;
-    }>, v.ReadonlyAction<{
+    }>]>], undefined>, v.ReadonlyAction<Readonly<{
+        type: "select";
+        readonly options: readonly [string, ...string[]];
+        defaultValue: string | null;
+        isOptional: boolean;
+        optionLabels: {
+            [x: string]: string;
+        };
+    }> | Readonly<{
         type: "toggle";
         valueType: "string" | "number" | "boolean";
         defaultValue: string | number | boolean | null;
         isOptional: boolean;
-    }>]>], undefined>, v.ReadonlyAction<Readonly<{
+    }>>]>, v.GenericSchema<BuilderWhenSerialised<Readonly<Readonly<{
         type: "select";
         readonly options: readonly [string, ...string[]];
         defaultValue: string | null;
@@ -237,111 +236,114 @@ export declare const BuilderOptionsSerialisedSchema: v.SchemaWithPipe<readonly [
         optionLabels: {
             [x: string]: string;
         };
-    }> | Readonly<{
+    }>> | Readonly<Readonly<{
         type: "toggle";
         valueType: "string" | "number" | "boolean";
         defaultValue: string | number | boolean | null;
         isOptional: boolean;
-    }>>]>, v.GenericSchema], undefined>], undefined>, v.MetadataAction<unknown, {
-        readonly refable: v.UnionSchema<[v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.SchemaWithPipe<readonly [v.ObjectSchema<{
-            readonly type: v.LiteralSchema<"select", undefined>;
-            readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
-            readonly defaultValue: v.NullableSchema<v.StringSchema<undefined>, undefined>;
-            readonly isOptional: v.BooleanSchema<undefined>;
-            readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
-        }, undefined>, v.MetadataAction<{
-            type: "select";
-            readonly options: readonly [string, ...string[]];
-            defaultValue: string | null;
-            isOptional: boolean;
-            optionLabels: {
-                [x: string]: string;
-            };
-        }, {
-            readonly serialisable: typeof import("./select").BuilderSelectType;
-            readonly instance: v.InstanceSchema<typeof import("./select").BuilderSelectType, undefined>;
-        }>, v.ReadonlyAction<{
-            type: "select";
-            readonly options: readonly [string, ...string[]];
-            defaultValue: string | null;
-            isOptional: boolean;
-            optionLabels: {
-                [x: string]: string;
-            };
-        }>]>, 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>;
-        }, undefined>, v.MetadataAction<{
-            type: "toggle";
-            valueType: "string" | "number" | "boolean";
-            defaultValue: string | number | boolean | null;
-            isOptional: boolean;
-        }, {
-            readonly serialisable: typeof import("./toggle").BuilderToggleType;
-            readonly instance: v.InstanceSchema<typeof import("./toggle").BuilderToggleType, undefined>;
-        }>, v.ReadonlyAction<{
-            type: "toggle";
-            valueType: "string" | "number" | "boolean";
-            defaultValue: string | number | boolean | null;
-            isOptional: boolean;
-        }>]>], undefined>, v.ReadonlyAction<Readonly<{
-            type: "select";
-            readonly options: readonly [string, ...string[]];
-            defaultValue: string | null;
-            isOptional: boolean;
-            optionLabels: {
-                [x: string]: string;
-            };
-        }> | Readonly<{
-            type: "toggle";
-            valueType: "string" | "number" | "boolean";
-            defaultValue: string | number | boolean | null;
-            isOptional: boolean;
-        }>>]>, v.GenericSchema], undefined>;
-    }>]>;
-    readonly gatePaths: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.ObjectSchema<{
-        readonly type: v.LiteralSchema<"ref", undefined>;
+    }>>>>], undefined>], undefined>;
+    readonly paths: v.OptionalSchema<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: "ref";
+        type: "parameter";
         id: string;
         name: string;
-    }>]>, v.InstanceSchema<typeof import("../..").BuilderRef, undefined>, 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>, v.MetadataAction<readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+    }>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly type: v.LiteralSchema<"ref", undefined>;
+        readonly id: v.StringSchema<undefined>;
+    }, undefined>, v.ReadonlyAction<{
         type: "ref";
         id: string;
-        name: string;
-    }>, {
-        readonly refable: 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>, v.MetadataAction<{
+    }>]>, 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>;
+}, undefined>, v.ReadonlyAction<{
     name: string;
-    payload: unknown;
-    gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
-        type: "ref";
+    payload: Readonly<{
+        type: "parameter";
         id: string;
         name: string;
-    }> | undefined;
-}, {
-    readonly serialisable: typeof BuilderOption;
-    readonly instance: v.InstanceSchema<typeof BuilderOption, undefined>;
-}>, v.ReadonlyAction<{
-    name: string;
-    payload: unknown;
-    gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+    }> | Readonly<{
         type: "ref";
         id: string;
+    }> | Readonly<Readonly<{
+        type: "select";
+        readonly options: readonly [string, ...string[]];
+        defaultValue: string | null;
+        isOptional: boolean;
+        optionLabels: {
+            [x: string]: string;
+        };
+    }>> | Readonly<Readonly<{
+        type: "toggle";
+        valueType: "string" | "number" | "boolean";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+    }>> | BuilderWhenSerialised<Readonly<Readonly<{
+        type: "select";
+        readonly options: readonly [string, ...string[]];
+        defaultValue: string | null;
+        isOptional: boolean;
+        optionLabels: {
+            [x: string]: string;
+        };
+    }>> | Readonly<Readonly<{
+        type: "toggle";
+        valueType: "string" | "number" | "boolean";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+    }>>>;
+    paths?: readonly (readonly (string | number)[])[] | Readonly<{
+        type: "parameter";
+        id: string;
         name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
     }> | undefined;
 }>]>, undefined>, v.ReadonlyAction<Readonly<{
     name: string;
-    payload: unknown;
-    gatePaths?: readonly (readonly (string | number)[])[] | import("../..").BuilderRef | Readonly<{
+    payload: Readonly<{
+        type: "parameter";
+        id: string;
+        name: string;
+    }> | Readonly<{
         type: "ref";
         id: string;
+    }> | Readonly<Readonly<{
+        type: "select";
+        readonly options: readonly [string, ...string[]];
+        defaultValue: string | null;
+        isOptional: boolean;
+        optionLabels: {
+            [x: string]: string;
+        };
+    }>> | Readonly<Readonly<{
+        type: "toggle";
+        valueType: "string" | "number" | "boolean";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+    }>> | BuilderWhenSerialised<Readonly<Readonly<{
+        type: "select";
+        readonly options: readonly [string, ...string[]];
+        defaultValue: string | null;
+        isOptional: boolean;
+        optionLabels: {
+            [x: string]: string;
+        };
+    }>> | Readonly<Readonly<{
+        type: "toggle";
+        valueType: "string" | "number" | "boolean";
+        defaultValue: string | number | boolean | null;
+        isOptional: boolean;
+    }>>>;
+    paths?: readonly (readonly (string | number)[])[] | Readonly<{
+        type: "parameter";
+        id: string;
         name: string;
+    }> | Readonly<{
+        type: "ref";
+        id: string;
     }> | undefined;
 }>[]>]>;
 export type BuilderOptionsSerialised = v.InferOutput<typeof BuilderOptionsSerialisedSchema>;

package/dist/entities/option/option.js

@@ -1,24 +1,25 @@
 import * as v from 'valibot';
 import { BuilderPathsSchema } from '../../paths.js';
-import { refable } from '../../references.js';
+import { paramable } from '../../references.js';
 import { serialisable } from '../../serialisable.js';
-import { createWhenSerialisedSchema } from '../when.js';
+import { createSelectMapSerialisedSchema, createWhenSerialisedSchema } from '../when.js';
 import { BuilderOptionValuesSerialisedSchema } from './values.js';
 export class BuilderOption {
     name;
     payload;
-    gatePaths;
-    constructor(name, payload, gatePaths) {
+    paths;
+    constructor(name, payload, paths) {
         this.name = name;
         this.payload = payload;
-        this.gatePaths = gatePaths;
+        this.paths = paths;
     }
 }
 export const BuilderOptionSchema = v.instance(BuilderOption);
 export const BuilderOptionWhenSerialisedSchema = createWhenSerialisedSchema(BuilderOptionValuesSerialisedSchema);
-export const BuilderOptionSerialisedSchema = serialisable(BuilderOption, v.object({
+export const BuilderOptionSelectMapSerialisedSchema = createSelectMapSerialisedSchema(BuilderOptionValuesSerialisedSchema);
+export const BuilderOptionSerialisedSchema = serialisable(v.object({
     name: v.string(),
-    payload: refable(v.union([BuilderOptionValuesSerialisedSchema, BuilderOptionWhenSerialisedSchema])),
-    gatePaths: v.optional(refable(BuilderPathsSchema))
+    payload: paramable(v.union([BuilderOptionValuesSerialisedSchema, BuilderOptionWhenSerialisedSchema])),
+    paths: v.optional(paramable(BuilderPathsSchema))
 }));
 export const BuilderOptionsSerialisedSchema = v.pipe(v.array(BuilderOptionSerialisedSchema), v.readonly());

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

@@ -25,18 +25,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>;
-}, undefined>, v.MetadataAction<{
-    type: "select";
-    readonly options: readonly [string, ...string[]];
-    defaultValue: string | null;
-    isOptional: boolean;
-    optionLabels: {
-        [x: string]: string;
-    };
-}, {
-    readonly serialisable: typeof BuilderSelectType;
-    readonly instance: v.InstanceSchema<typeof BuilderSelectType, undefined>;
-}>, v.ReadonlyAction<{
+}, undefined>, v.ReadonlyAction<{
     type: "select";
     readonly options: readonly [string, ...string[]];
     defaultValue: string | null;
@@ -46,4 +35,5 @@ export declare const BuilderSelectTypeSerialisedSchema: v.SchemaWithPipe<readonl
     };
 }>]>;
 export type BuilderSelectTypeSerialised = v.InferOutput<typeof BuilderSelectTypeSerialisedSchema>;
+export declare function selectValueSchema(options: ReadonlyArray<string>, optional: boolean): v.GenericSchema<string | null>;
 export {};

package/dist/entities/option/select.js

@@ -9,8 +9,7 @@ export class BuilderSelectType {
     optionLabels;
     constructor(values, defaultValue, optional = false, optionLabels = {}) {
         this.options = values;
-        const baseSchema = v.union(values.map((value) => v.literal(value)));
-        this.valueSchema = (optional ? v.nullable(baseSchema) : baseSchema);
+        this.valueSchema = selectValueSchema(values, optional);
         this.defaultValue = defaultValue;
         this.isOptional = optional;
         this.optionLabels = optionLabels;
@@ -31,10 +30,14 @@ export function select(values) {
     return new BuilderSelectType(values, defaultValue, false);
 }
 export const BuilderSelectTypeSchema = v.instance(BuilderSelectType);
-export const BuilderSelectTypeSerialisedSchema = serialisable(BuilderSelectType, v.object({
+export const BuilderSelectTypeSerialisedSchema = serialisable(v.object({
     type: v.literal('select'),
     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())
 }));
+export function selectValueSchema(options, optional) {
+    const baseSchema = v.union(options.map((value) => v.literal(value)));
+    return optional ? v.nullable(baseSchema) : baseSchema;
+}