struct-fakerator 2.7.9 → 2.9.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 FizzyElt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -6,8 +6,8 @@
     - [Value](#value)
     - [Selection](#selection)
     - [Object](#object)
-    - [createArrayGenerator](#createarraygenerator)
-    - [createTupleGenerator](#createtuplegenerator)
+    - [Array](#array)
+    - [Tuple](#tuple)
     - [BoundedSeries](#boundedseries)
   - [擴充](#擴充)
 
@@ -47,7 +47,7 @@ import { StructConfig } from 'struct-fakerator'
 
 const scheme = StructConfig.object({
   name: StructConfig.value(() => 'hello'),
-  enum: StructConfig.selection([1, 2, 3]),
+  enum: StructConfig.select([1, 2, 3]),
   list: StructConfig.array(StructConfig.value(() => 10), 5),
   tuple: StructConfig.tuple([StructConfig.value(() => 'tuple1'), StructConfig.value(() => '100')])
 })
@@ -144,7 +144,7 @@ console.log(generateFn());
 
 ### Selection
 
-```javascript
+```typescript
 const generateFn = StructGenerator.genFn(StructConfig.select([1, 2, 3, 4, 5]))
 
 console.log(generateFn());
@@ -183,7 +183,7 @@ console.log(generateFn());
 // ["hello 10", "hello 10", "hello 10", "hello 10", "hello 10"]
 ```
 
-### createArrayGenerator
+### Array
 
 ```typescript
 const generateFn = StructGenerator.genFn(
@@ -209,7 +209,7 @@ console.log(generateFn());
 // [21, 32, 43, 54, 65]
 ```
 
-### createTupleGenerator
+### Tuple
 
 ```typescript
 const generateFn = StructGenerator.genFn(
@@ -226,7 +226,7 @@ console.log(generateFn());
 
 ### BoundedSeries
 
-```javascript
+```typescript
 const generateFn = StructGenerator.genFn(
   StructConfig.boundedSeries({
     upperLimit: 1.1,
@@ -258,7 +258,7 @@ flowchart TB
 
 但並不是所有人情況都能自己手動建立函數，有可能是開放給別人使用的服務，沒辦法在使用方建立函數，這時 `createGeneratorByType` 第二個可以讓製作服務的人帶入自己的擴充，這樣這個函數就能接受更多種型態。
 
-```javascript
+```typescript
 const createIntValueConfig = (option) => createValueConfig(() => faker.number.int(option));
 const createEmailValueConfig = (option) => createValueConfig(() => faker.internet.email(option));
 

package/dist/config.cjs

@@ -0,0 +1,51 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    select: ()=>external_create_config_cjs_namespaceObject.createSelectionConfig,
+    object: ()=>external_create_config_cjs_namespaceObject.createObjectConfig,
+    tuple: ()=>external_create_config_cjs_namespaceObject.createTupleConfig,
+    value: ()=>external_create_config_cjs_namespaceObject.createValueConfig,
+    boundedSeries: ()=>external_create_config_cjs_namespaceObject.createBoundedSeriesConfig,
+    array: ()=>external_create_config_cjs_namespaceObject.createArrayConfig
+});
+const external_create_config_cjs_namespaceObject = require("./create_config.cjs");
+exports.array = __webpack_exports__.array;
+exports.boundedSeries = __webpack_exports__.boundedSeries;
+exports.object = __webpack_exports__.object;
+exports.select = __webpack_exports__.select;
+exports.tuple = __webpack_exports__.tuple;
+exports.value = __webpack_exports__.value;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "array",
+    "boundedSeries",
+    "object",
+    "select",
+    "tuple",
+    "value"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/config.d.ts

@@ -1,2 +1 @@
-export { createArrayConfig as array, createBoundedSeriesConfig as boundedSeries, createObjectConfig as object, createSelectionConfig as select, createTupleConfig as tuple, createValueConfig as value } from './create_config.js';
-import './type.js';
+export { createArrayConfig as array, createBoundedSeriesConfig as boundedSeries, createObjectConfig as object, createSelectionConfig as select, createTupleConfig as tuple, createValueConfig as value, } from "./create_config";

package/dist/config.js

@@ -1,19 +1,2 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('./chunk-V2AWKRQI.js');
-
-
-
-
-
-
-
-var _chunkC3RGM3CBjs = require('./chunk-C3RGM3CB.js');
-require('./chunk-ZWLHVT5O.js');
-require('./chunk-4VNS5WPM.js');
-
-
-
-
-
-
-
-exports.array = _chunkC3RGM3CBjs.createArrayConfig; exports.boundedSeries = _chunkC3RGM3CBjs.createBoundedSeriesConfig; exports.object = _chunkC3RGM3CBjs.createObjectConfig; exports.select = _chunkC3RGM3CBjs.createSelectionConfig; exports.tuple = _chunkC3RGM3CBjs.createTupleConfig; exports.value = _chunkC3RGM3CBjs.createValueConfig;
+import { createArrayConfig, createBoundedSeriesConfig, createObjectConfig, createSelectionConfig, createTupleConfig, createValueConfig } from "./create_config.js";
+export { createArrayConfig as array, createBoundedSeriesConfig as boundedSeries, createObjectConfig as object, createSelectionConfig as select, createTupleConfig as tuple, createValueConfig as value };

package/dist/config_scheme.cjs

@@ -0,0 +1,95 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    boundedSeriesScheme: ()=>boundedSeriesScheme,
+    tupleConfigScheme: ()=>tupleConfigScheme,
+    valueConfigScheme: ()=>valueConfigScheme,
+    arrayConfigScheme: ()=>arrayConfigScheme,
+    selectionConfigScheme: ()=>selectionConfigScheme,
+    objConfigScheme: ()=>objConfigScheme
+});
+const external_zod_namespaceObject = require("zod");
+const valueConfigScheme = external_zod_namespaceObject.z.object({
+    type: external_zod_namespaceObject.z.string().regex(/^value$/, {
+        message: "invalid type string"
+    }),
+    generateFn: external_zod_namespaceObject.z.any()
+});
+const selectionConfigScheme = external_zod_namespaceObject.z.object({
+    type: external_zod_namespaceObject.z.string().regex(/^select$/, {
+        message: "invalid type string"
+    }),
+    items: external_zod_namespaceObject.z.any().array().nonempty({
+        message: "items can not be empty"
+    })
+});
+const arrayConfigScheme = external_zod_namespaceObject.z.object({
+    type: external_zod_namespaceObject.z.string().regex(/^arr$/, {
+        message: "invalid type string"
+    }),
+    item: external_zod_namespaceObject.z.object({}),
+    len: external_zod_namespaceObject.z.number().nonnegative()
+});
+const tupleConfigScheme = external_zod_namespaceObject.z.object({
+    type: external_zod_namespaceObject.z.string().regex(/^tuple$/, {
+        message: "invalid type string"
+    }),
+    configItems: external_zod_namespaceObject.z.any().array()
+});
+const objConfigScheme = external_zod_namespaceObject.z.object({
+    type: external_zod_namespaceObject.z.string().regex(/^obj$/, {
+        message: "invalid type string"
+    }),
+    content: external_zod_namespaceObject.z.object({})
+});
+const boundedSeriesScheme = external_zod_namespaceObject.z.object({
+    type: external_zod_namespaceObject.z.string().regex(/^bounded_series$/, {
+        message: "invalid type string"
+    }),
+    upperLimit: external_zod_namespaceObject.z.number().nonnegative(),
+    lowerLimit: external_zod_namespaceObject.z.number().nonnegative(),
+    createInitValue: external_zod_namespaceObject.z.any(),
+    count: external_zod_namespaceObject.z.number().nonnegative()
+}).refine(({ upperLimit, lowerLimit })=>upperLimit >= lowerLimit, {
+    message: "lowerLimit can not greater then upperLimit"
+});
+exports.arrayConfigScheme = __webpack_exports__.arrayConfigScheme;
+exports.boundedSeriesScheme = __webpack_exports__.boundedSeriesScheme;
+exports.objConfigScheme = __webpack_exports__.objConfigScheme;
+exports.selectionConfigScheme = __webpack_exports__.selectionConfigScheme;
+exports.tupleConfigScheme = __webpack_exports__.tupleConfigScheme;
+exports.valueConfigScheme = __webpack_exports__.valueConfigScheme;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "arrayConfigScheme",
+    "boundedSeriesScheme",
+    "objConfigScheme",
+    "selectionConfigScheme",
+    "tupleConfigScheme",
+    "valueConfigScheme"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/config_scheme.d.ts

@@ -1,32 +1,29 @@
-import { z } from 'zod/v4';
-
-declare const valueConfigScheme: z.ZodObject<{
+import { z } from "zod";
+export declare const valueConfigScheme: z.ZodObject<{
     type: z.ZodString;
     generateFn: z.ZodAny;
 }, z.core.$strip>;
-declare const selectionConfigScheme: z.ZodObject<{
+export declare const selectionConfigScheme: z.ZodObject<{
     type: z.ZodString;
     items: z.ZodArray<z.ZodAny>;
 }, z.core.$strip>;
-declare const arrayConfigScheme: z.ZodObject<{
+export declare const arrayConfigScheme: z.ZodObject<{
     type: z.ZodString;
     item: z.ZodObject<{}, z.core.$strip>;
     len: z.ZodNumber;
 }, z.core.$strip>;
-declare const tupleConfigScheme: z.ZodObject<{
+export declare const tupleConfigScheme: z.ZodObject<{
     type: z.ZodString;
     configItems: z.ZodArray<z.ZodAny>;
 }, z.core.$strip>;
-declare const objConfigScheme: z.ZodObject<{
+export declare const objConfigScheme: z.ZodObject<{
     type: z.ZodString;
     content: z.ZodObject<{}, z.core.$strip>;
 }, z.core.$strip>;
-declare const boundedSeriesScheme: z.ZodObject<{
+export declare const boundedSeriesScheme: z.ZodObject<{
     type: z.ZodString;
     upperLimit: z.ZodNumber;
     lowerLimit: z.ZodNumber;
     createInitValue: z.ZodAny;
     count: z.ZodNumber;
 }, z.core.$strip>;
-
-export { arrayConfigScheme, boundedSeriesScheme, objConfigScheme, selectionConfigScheme, tupleConfigScheme, valueConfigScheme };

package/dist/config_scheme.js

@@ -1,17 +1,46 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-
-
-var _chunkZWLHVT5Ojs = require('./chunk-ZWLHVT5O.js');
-require('./chunk-4VNS5WPM.js');
-
-
-
-
-
-
-
-exports.arrayConfigScheme = _chunkZWLHVT5Ojs.arrayConfigScheme; exports.boundedSeriesScheme = _chunkZWLHVT5Ojs.boundedSeriesScheme; exports.objConfigScheme = _chunkZWLHVT5Ojs.objConfigScheme; exports.selectionConfigScheme = _chunkZWLHVT5Ojs.selectionConfigScheme; exports.tupleConfigScheme = _chunkZWLHVT5Ojs.tupleConfigScheme; exports.valueConfigScheme = _chunkZWLHVT5Ojs.valueConfigScheme;
+import { z } from "zod";
+const valueConfigScheme = z.object({
+    type: z.string().regex(/^value$/, {
+        message: "invalid type string"
+    }),
+    generateFn: z.any()
+});
+const selectionConfigScheme = z.object({
+    type: z.string().regex(/^select$/, {
+        message: "invalid type string"
+    }),
+    items: z.any().array().nonempty({
+        message: "items can not be empty"
+    })
+});
+const arrayConfigScheme = z.object({
+    type: z.string().regex(/^arr$/, {
+        message: "invalid type string"
+    }),
+    item: z.object({}),
+    len: z.number().nonnegative()
+});
+const tupleConfigScheme = z.object({
+    type: z.string().regex(/^tuple$/, {
+        message: "invalid type string"
+    }),
+    configItems: z.any().array()
+});
+const objConfigScheme = z.object({
+    type: z.string().regex(/^obj$/, {
+        message: "invalid type string"
+    }),
+    content: z.object({})
+});
+const boundedSeriesScheme = z.object({
+    type: z.string().regex(/^bounded_series$/, {
+        message: "invalid type string"
+    }),
+    upperLimit: z.number().nonnegative(),
+    lowerLimit: z.number().nonnegative(),
+    createInitValue: z.any(),
+    count: z.number().nonnegative()
+}).refine(({ upperLimit, lowerLimit })=>upperLimit >= lowerLimit, {
+    message: "lowerLimit can not greater then upperLimit"
+});
+export { arrayConfigScheme, boundedSeriesScheme, objConfigScheme, selectionConfigScheme, tupleConfigScheme, valueConfigScheme };

package/dist/create_config.cjs

@@ -0,0 +1,110 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createSelectionConfig: ()=>createSelectionConfig,
+    createValueConfig: ()=>createValueConfig,
+    createObjectConfig: ()=>createObjectConfig,
+    createArrayConfig: ()=>createArrayConfig,
+    createBoundedSeriesConfig: ()=>createBoundedSeriesConfig,
+    createTupleConfig: ()=>createTupleConfig
+});
+const external_config_scheme_cjs_namespaceObject = require("./config_scheme.cjs");
+const createValueConfig = (generateFn)=>{
+    const config = {
+        type: "value",
+        generateFn
+    };
+    external_config_scheme_cjs_namespaceObject.valueConfigScheme.parse(config);
+    return config;
+};
+const createSelectionConfig = (items)=>{
+    const config = {
+        type: "select",
+        items
+    };
+    external_config_scheme_cjs_namespaceObject.selectionConfigScheme.parse(config);
+    return config;
+};
+function createObjectConfig(content, transformer) {
+    if (transformer) {
+        const config = {
+            type: "obj",
+            content,
+            transformer
+        };
+        external_config_scheme_cjs_namespaceObject.objConfigScheme.parse(config);
+        return config;
+    }
+    const config = {
+        type: "obj",
+        content
+    };
+    external_config_scheme_cjs_namespaceObject.objConfigScheme.parse(config);
+    return config;
+}
+const createArrayConfig = (item, len, next)=>{
+    const config = {
+        type: "arr",
+        item,
+        len,
+        next
+    };
+    external_config_scheme_cjs_namespaceObject.arrayConfigScheme.parse(config);
+    return config;
+};
+const createTupleConfig = (configItems)=>{
+    const config = {
+        type: "tuple",
+        configItems
+    };
+    external_config_scheme_cjs_namespaceObject.tupleConfigScheme.parse(config);
+    return config;
+};
+const createBoundedSeriesConfig = (config)=>{
+    const newConfig = {
+        type: "bounded_series",
+        ...config
+    };
+    external_config_scheme_cjs_namespaceObject.boundedSeriesScheme.parse(newConfig);
+    return newConfig;
+};
+exports.createArrayConfig = __webpack_exports__.createArrayConfig;
+exports.createBoundedSeriesConfig = __webpack_exports__.createBoundedSeriesConfig;
+exports.createObjectConfig = __webpack_exports__.createObjectConfig;
+exports.createSelectionConfig = __webpack_exports__.createSelectionConfig;
+exports.createTupleConfig = __webpack_exports__.createTupleConfig;
+exports.createValueConfig = __webpack_exports__.createValueConfig;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createArrayConfig",
+    "createBoundedSeriesConfig",
+    "createObjectConfig",
+    "createSelectionConfig",
+    "createTupleConfig",
+    "createValueConfig"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/create_config.d.ts

@@ -1,25 +1,24 @@
-import { ValueConfig, Result, ArrayConfig, ObjectConfig, ObjectConfigWithFn, TupleConfig, SelectionConfig, BoundedSeriesConfig } from './type.js';
-
+import type { ArrayConfig, BoundedSeriesConfig, ObjectConfig, ObjectConfigWithFn, Result, SelectionConfig, TupleConfig, ValueConfig } from "./type";
 /**
  * value
  * @param {function} generateFn - The function used to generate the value.
  * @return {ValueConfig} The configuration object with the type "value" and the provided generate function.
  */
-declare const createValueConfig: <T>(generateFn: () => T) => ValueConfig<T>;
+export declare const createValueConfig: <T>(generateFn: () => T) => ValueConfig<T>;
 /**
  * selection
  * @param {Array} items - The array of items to choose from.
  * @return {SelectionConfig} The configuration object with the type "select" and the provided items.
  */
-declare const createSelectionConfig: <T>(items: T[]) => SelectionConfig<T>;
+export declare const createSelectionConfig: <T>(items: T[]) => SelectionConfig<T>;
 /**
  * object
  * @param {object} content
  * @param {function} transformer
  * @return {ObjectConfig}
  */
-declare function createObjectConfig<T extends object>(content: T): ObjectConfig<T>;
-declare function createObjectConfig<T extends object, R>(content: T, transformer: (v: {
+export declare function createObjectConfig<T extends object>(content: T): ObjectConfig<T>;
+export declare function createObjectConfig<T extends object, R>(content: T, transformer: (v: {
     [K in keyof T]: Result<T[K]>;
 }) => R): ObjectConfigWithFn<T, R>;
 /**
@@ -29,7 +28,7 @@ declare function createObjectConfig<T extends object, R>(content: T, transformer
  * @param {function} next
  * @return {ArrayConfig}
  */
-declare const createArrayConfig: <T>(item: T, len: number, next?: (prev: Result<T>, current: Result<T>) => Result<T>) => ArrayConfig<T>;
+export declare const createArrayConfig: <T>(item: T, len: number, next?: (prev: Result<T>, current: Result<T>) => Result<T>) => ArrayConfig<T>;
 /**
  * tuple
  * @param {Array} configItems
@@ -47,12 +46,11 @@ interface CreateTupleConfig {
     <A, B>(configItems: [A, B]): TupleConfig<A, B>;
     <A>(configItems: [A]): TupleConfig<A>;
 }
-declare const createTupleConfig: CreateTupleConfig;
+export declare const createTupleConfig: CreateTupleConfig;
 /**
  * bounded series
  * @param {{ upperLimit: number, lowerLimit: number, createInitValue: () => number, count: number }} config
  * @return {BoundedSeriesConfig}
  */
-declare const createBoundedSeriesConfig: (config: Omit<BoundedSeriesConfig, "type">) => BoundedSeriesConfig;
-
-export { createArrayConfig, createBoundedSeriesConfig, createObjectConfig, createSelectionConfig, createTupleConfig, createValueConfig };
+export declare const createBoundedSeriesConfig: (config: Omit<BoundedSeriesConfig, "type">) => BoundedSeriesConfig;
+export {};

package/dist/create_config.js

@@ -1,18 +1,61 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-
-
-var _chunkC3RGM3CBjs = require('./chunk-C3RGM3CB.js');
-require('./chunk-ZWLHVT5O.js');
-require('./chunk-4VNS5WPM.js');
-
-
-
-
-
-
-
-exports.createArrayConfig = _chunkC3RGM3CBjs.createArrayConfig; exports.createBoundedSeriesConfig = _chunkC3RGM3CBjs.createBoundedSeriesConfig; exports.createObjectConfig = _chunkC3RGM3CBjs.createObjectConfig; exports.createSelectionConfig = _chunkC3RGM3CBjs.createSelectionConfig; exports.createTupleConfig = _chunkC3RGM3CBjs.createTupleConfig; exports.createValueConfig = _chunkC3RGM3CBjs.createValueConfig;
+import { arrayConfigScheme, boundedSeriesScheme, objConfigScheme, selectionConfigScheme, tupleConfigScheme, valueConfigScheme } from "./config_scheme.js";
+const createValueConfig = (generateFn)=>{
+    const config = {
+        type: "value",
+        generateFn
+    };
+    valueConfigScheme.parse(config);
+    return config;
+};
+const createSelectionConfig = (items)=>{
+    const config = {
+        type: "select",
+        items
+    };
+    selectionConfigScheme.parse(config);
+    return config;
+};
+function createObjectConfig(content, transformer) {
+    if (transformer) {
+        const config = {
+            type: "obj",
+            content,
+            transformer
+        };
+        objConfigScheme.parse(config);
+        return config;
+    }
+    const config = {
+        type: "obj",
+        content
+    };
+    objConfigScheme.parse(config);
+    return config;
+}
+const createArrayConfig = (item, len, next)=>{
+    const config = {
+        type: "arr",
+        item,
+        len,
+        next
+    };
+    arrayConfigScheme.parse(config);
+    return config;
+};
+const createTupleConfig = (configItems)=>{
+    const config = {
+        type: "tuple",
+        configItems
+    };
+    tupleConfigScheme.parse(config);
+    return config;
+};
+const createBoundedSeriesConfig = (config)=>{
+    const newConfig = {
+        type: "bounded_series",
+        ...config
+    };
+    boundedSeriesScheme.parse(newConfig);
+    return newConfig;
+};
+export { createArrayConfig, createBoundedSeriesConfig, createObjectConfig, createSelectionConfig, createTupleConfig, createValueConfig };

package/dist/create_config.test.d.ts

@@ -1,2 +1 @@
-
-export {  }
+export {};