struct-fakerator 2.7.9 → 2.8.9

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/biome.json

@@ -1,27 +1,31 @@
 {
-	"$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
-	"organizeImports": {
-		"enabled": true
-	},
-	"linter": {
-		"enabled": true,
-		"rules": {
-			"recommended": true
-		},
-		"include": [
-			"src/**/*"
-		]
-	},
-	"formatter": {
-		"indentStyle": "space",
-		"include": [
-			"src/**/*",
-			"tsup.config.ts"
-		]
-	},
-	"javascript": {
-		"formatter": {
-			"quoteStyle": "double"
-		}
-	}
-}
+  "$schema": "https://biomejs.dev/schemas/2.0.5/schema.json",
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    },
+    "includes": ["src/**/*"]
+  },
+  "formatter": {
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineEnding": "lf",
+    "includes": ["src/**/*", "tsup.config.ts", "rslib.config.ts"]
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double"
+    }
+  },
+  "assist": {
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  },
+  "files": {
+    "includes": ["src/**/*", "tsup.config.ts", "rslib.config.ts"]
+  }
+}

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,51 @@
-"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;
+"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_js_namespaceObject.createSelectionConfig,
+    object: ()=>external_create_config_js_namespaceObject.createObjectConfig,
+    tuple: ()=>external_create_config_js_namespaceObject.createTupleConfig,
+    value: ()=>external_create_config_js_namespaceObject.createValueConfig,
+    boundedSeries: ()=>external_create_config_js_namespaceObject.createBoundedSeriesConfig,
+    array: ()=>external_create_config_js_namespaceObject.createArrayConfig
+});
+const external_create_config_js_namespaceObject = require("./create_config.js");
+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.mjs

@@ -1,19 +1,2 @@
-import "./chunk-VE3Q5LC3.mjs";
-import {
-  createArrayConfig,
-  createBoundedSeriesConfig,
-  createObjectConfig,
-  createSelectionConfig,
-  createTupleConfig,
-  createValueConfig
-} from "./chunk-ZQA42PYM.mjs";
-import "./chunk-USLYTOPD.mjs";
-import "./chunk-XGB3TDIC.mjs";
-export {
-  createArrayConfig as array,
-  createBoundedSeriesConfig as boundedSeries,
-  createObjectConfig as object,
-  createSelectionConfig as select,
-  createTupleConfig as tuple,
-  createValueConfig as value
-};
+import { createArrayConfig, createBoundedSeriesConfig, createObjectConfig, createSelectionConfig, createTupleConfig, createValueConfig } from "./create_config.mjs";
+export { createArrayConfig as array, createBoundedSeriesConfig as boundedSeries, createObjectConfig as object, createSelectionConfig as select, createTupleConfig as tuple, createValueConfig as value };

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,95 @@
-"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;
+"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.mjs

@@ -1,17 +1,46 @@
-import {
-  arrayConfigScheme,
-  boundedSeriesScheme,
-  objConfigScheme,
-  selectionConfigScheme,
-  tupleConfigScheme,
-  valueConfigScheme
-} from "./chunk-USLYTOPD.mjs";
-import "./chunk-XGB3TDIC.mjs";
-export {
-  arrayConfigScheme,
-  boundedSeriesScheme,
-  objConfigScheme,
-  selectionConfigScheme,
-  tupleConfigScheme,
-  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.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,110 @@
-"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;
+"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_js_namespaceObject = require("./config_scheme.js");
+const createValueConfig = (generateFn)=>{
+    const config = {
+        type: "value",
+        generateFn
+    };
+    external_config_scheme_js_namespaceObject.valueConfigScheme.parse(config);
+    return config;
+};
+const createSelectionConfig = (items)=>{
+    const config = {
+        type: "select",
+        items
+    };
+    external_config_scheme_js_namespaceObject.selectionConfigScheme.parse(config);
+    return config;
+};
+function createObjectConfig(content, transformer) {
+    if (transformer) {
+        const config = {
+            type: "obj",
+            content,
+            transformer
+        };
+        external_config_scheme_js_namespaceObject.objConfigScheme.parse(config);
+        return config;
+    }
+    const config = {
+        type: "obj",
+        content
+    };
+    external_config_scheme_js_namespaceObject.objConfigScheme.parse(config);
+    return config;
+}
+const createArrayConfig = (item, len, next)=>{
+    const config = {
+        type: "arr",
+        item,
+        len,
+        next
+    };
+    external_config_scheme_js_namespaceObject.arrayConfigScheme.parse(config);
+    return config;
+};
+const createTupleConfig = (configItems)=>{
+    const config = {
+        type: "tuple",
+        configItems
+    };
+    external_config_scheme_js_namespaceObject.tupleConfigScheme.parse(config);
+    return config;
+};
+const createBoundedSeriesConfig = (config)=>{
+    const newConfig = {
+        type: "bounded_series",
+        ...config
+    };
+    external_config_scheme_js_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
+});