mock-config-server 3.4.0 → 3.5.0

package/dist/bin/validateMockServerConfig/restConfigSchema/routeConfigSchema/routeConfigSchema.js

@@ -1,52 +1,66 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.routeConfigSchema = void 0;
-var _zod = require("zod");
-var _helpers = require("../../../../src/utils/helpers");
-var _helpers2 = require("../../../helpers");
-var _interceptorsSchema = require("../../interceptorsSchema/interceptorsSchema");
-var _queueSchema = require("../../queueSchema/queueSchema");
-var _settingsSchema = require("../../settingsSchema/settingsSchema");
-var _utils = require("../../utils");
-const METHODS_WITH_BODY = ['post', 'put', 'patch'];
-const entitiesByEntityNameSchema = method => {
-  const isMethodWithBody = METHODS_WITH_BODY.includes(method);
-  return (0, _utils.plainObjectSchema)(_zod.z.strictObject({
-    headers: _utils.mappedEntitySchema.optional(),
-    cookies: _utils.mappedEntitySchema.optional(),
-    params: _utils.mappedEntitySchema.optional(),
-    query: _utils.mappedEntitySchema.optional(),
-    ...(isMethodWithBody && {
-      body: _utils.plainEntitySchema.optional()
-    })
-  }));
-};
-const baseRouteConfigSchema = method => _zod.z.strictObject({
-  entities: entitiesByEntityNameSchema(method).optional(),
-  interceptors: (0, _utils.plainObjectSchema)(_interceptorsSchema.interceptorsSchema.pick({
-    response: true
-  })).optional()
+Object.defineProperty(exports, "routeConfigSchema", {
+    enumerable: true,
+    get: function() {
+        return routeConfigSchema;
+    }
 });
-const dataRouteConfigSchema = method => _zod.z.strictObject({
-  settings: (0, _utils.plainObjectSchema)(_settingsSchema.settingsSchema.extend({
-    polling: _zod.z.literal(false).optional()
-  })).optional(),
-  data: _zod.z.union([_zod.z.function(), _zod.z.any()])
-}).merge(baseRouteConfigSchema(method));
-const fileRouteConfigSchema = method => _zod.z.strictObject({
-  settings: (0, _utils.plainObjectSchema)(_settingsSchema.settingsSchema.extend({
-    polling: _zod.z.literal(false).optional()
-  })).optional(),
-  file: _zod.z.string()
-}).merge(baseRouteConfigSchema(method));
-const queueRouteConfigSchema = method => _zod.z.strictObject({
-  settings: _settingsSchema.settingsSchema.extend({
-    polling: _zod.z.literal(true)
-  }),
-  queue: _queueSchema.queueSchema
-}).merge(baseRouteConfigSchema(method));
-const routeConfigSchema = method => _zod.z.union([_zod.z.custom(value => (0, _helpers.isPlainObject)(value) && (0, _helpers2.isOnlyRequestedDataResolvingPropertyExists)(value, 'data')).pipe(dataRouteConfigSchema(method)), _zod.z.custom(value => (0, _helpers.isPlainObject)(value) && (0, _helpers2.isOnlyRequestedDataResolvingPropertyExists)(value, 'file')).pipe(fileRouteConfigSchema(method)), _zod.z.custom(value => (0, _helpers.isPlainObject)(value) && (0, _helpers2.isOnlyRequestedDataResolvingPropertyExists)(value, 'queue')).pipe(queueRouteConfigSchema(method))]);
-exports.routeConfigSchema = routeConfigSchema;
+const _zod = require("zod");
+const _helpers = require("../../../../src/utils/helpers");
+const _helpers1 = require("../../../helpers");
+const _interceptorsSchema = require("../../interceptorsSchema/interceptorsSchema");
+const _queueSchema = require("../../queueSchema/queueSchema");
+const _settingsSchema = require("../../settingsSchema/settingsSchema");
+const _utils = require("../../utils");
+const METHODS_WITH_BODY = [
+    "post",
+    "put",
+    "patch"
+];
+const entitiesByEntityNameSchema = (method)=>{
+    const isMethodWithBody = METHODS_WITH_BODY.includes(method);
+    return (0, _utils.plainObjectSchema)(_zod.z.strictObject({
+        headers: _utils.mappedEntitySchema.optional(),
+        cookies: _utils.mappedEntitySchema.optional(),
+        params: _utils.mappedEntitySchema.optional(),
+        query: _utils.mappedEntitySchema.optional(),
+        ...isMethodWithBody && {
+            body: _utils.plainEntitySchema.optional()
+        }
+    }));
+};
+const baseRouteConfigSchema = (method)=>_zod.z.strictObject({
+        entities: entitiesByEntityNameSchema(method).optional(),
+        interceptors: (0, _utils.plainObjectSchema)(_interceptorsSchema.interceptorsSchema.pick({
+            response: true
+        })).optional()
+    });
+const dataRouteConfigSchema = (method)=>_zod.z.strictObject({
+        settings: (0, _utils.plainObjectSchema)(_settingsSchema.settingsSchema.extend({
+            polling: _zod.z.literal(false).optional()
+        })).optional(),
+        data: _zod.z.union([
+            _zod.z.function(),
+            _zod.z.any()
+        ])
+    }).merge(baseRouteConfigSchema(method));
+const fileRouteConfigSchema = (method)=>_zod.z.strictObject({
+        settings: (0, _utils.plainObjectSchema)(_settingsSchema.settingsSchema.extend({
+            polling: _zod.z.literal(false).optional()
+        })).optional(),
+        file: _zod.z.string()
+    }).merge(baseRouteConfigSchema(method));
+const queueRouteConfigSchema = (method)=>_zod.z.strictObject({
+        settings: _settingsSchema.settingsSchema.extend({
+            polling: _zod.z.literal(true)
+        }),
+        queue: _queueSchema.queueSchema
+    }).merge(baseRouteConfigSchema(method));
+const routeConfigSchema = (method)=>_zod.z.union([
+        _zod.z.custom((value)=>(0, _helpers.isPlainObject)(value) && (0, _helpers1.isOnlyRequestedDataResolvingPropertyExists)(value, "data")).pipe(dataRouteConfigSchema(method)),
+        _zod.z.custom((value)=>(0, _helpers.isPlainObject)(value) && (0, _helpers1.isOnlyRequestedDataResolvingPropertyExists)(value, "file")).pipe(fileRouteConfigSchema(method)),
+        _zod.z.custom((value)=>(0, _helpers.isPlainObject)(value) && (0, _helpers1.isOnlyRequestedDataResolvingPropertyExists)(value, "queue")).pipe(queueRouteConfigSchema(method))
+    ]);

package/dist/bin/validateMockServerConfig/settingsSchema/settingsSchema.js

@@ -1,12 +1,16 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
+});
+Object.defineProperty(exports, "settingsSchema", {
+    enumerable: true,
+    get: function() {
+        return settingsSchema;
+    }
+});
+const _zod = require("zod");
+const settingsSchema = _zod.z.strictObject({
+    polling: _zod.z.boolean().optional(),
+    status: _zod.z.number().min(200).max(599).optional(),
+    delay: _zod.z.number().nonnegative().optional()
 });
-exports.settingsSchema = void 0;
-var _zod = require("zod");
-const settingsSchema = exports.settingsSchema = _zod.z.strictObject({
-  polling: _zod.z.boolean().optional(),
-  status: _zod.z.number().min(200).max(599).optional(),
-  delay: _zod.z.number().nonnegative().optional()
-});

package/dist/bin/validateMockServerConfig/staticPathSchema/staticPathSchema.js

@@ -1,14 +1,24 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.staticPathSchema = void 0;
-var _zod = require("zod");
-var _utils = require("../utils");
+Object.defineProperty(exports, "staticPathSchema", {
+    enumerable: true,
+    get: function() {
+        return staticPathSchema;
+    }
+});
+const _zod = require("zod");
+const _utils = require("../utils");
 const staticPathObjectSchema = _zod.z.strictObject({
-  prefix: _utils.stringForwardSlashSchema,
-  path: _utils.stringForwardSlashSchema
+    prefix: _utils.stringForwardSlashSchema,
+    path: _utils.stringForwardSlashSchema
 });
-const staticPathStringOrObjectSchema = _zod.z.union([_utils.stringForwardSlashSchema, staticPathObjectSchema]);
-const staticPathSchema = exports.staticPathSchema = _zod.z.union([staticPathStringOrObjectSchema, _zod.z.array(staticPathStringOrObjectSchema)]);
+const staticPathStringOrObjectSchema = _zod.z.union([
+    _utils.stringForwardSlashSchema,
+    staticPathObjectSchema
+]);
+const staticPathSchema = _zod.z.union([
+    staticPathStringOrObjectSchema,
+    _zod.z.array(staticPathStringOrObjectSchema)
+]);

package/dist/bin/validateMockServerConfig/utils/checkModeSchema/checkModeSchema.js

@@ -1,12 +1,30 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.compareWithDescriptorValueCheckModeSchema = exports.compareWithDescriptorStringValueCheckModeSchema = exports.compareWithDescriptorAnyValueCheckModeSchema = exports.checkActualValueCheckModeSchema = void 0;
-var _zod = require("zod");
-var _constants = require("../../../../src/utils/constants");
-const checkActualValueCheckModeSchema = exports.checkActualValueCheckModeSchema = _zod.z.enum(_constants.CHECK_ACTUAL_VALUE_CHECK_MODES);
-const compareWithDescriptorAnyValueCheckModeSchema = exports.compareWithDescriptorAnyValueCheckModeSchema = _zod.z.enum(_constants.COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES);
-const compareWithDescriptorStringValueCheckModeSchema = exports.compareWithDescriptorStringValueCheckModeSchema = _zod.z.enum(_constants.COMPARE_WITH_DESCRIPTOR_STRING_VALUE_CHECK_MODES);
-const compareWithDescriptorValueCheckModeSchema = exports.compareWithDescriptorValueCheckModeSchema = _zod.z.enum(_constants.COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES);
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    checkActualValueCheckModeSchema: function() {
+        return checkActualValueCheckModeSchema;
+    },
+    compareWithDescriptorAnyValueCheckModeSchema: function() {
+        return compareWithDescriptorAnyValueCheckModeSchema;
+    },
+    compareWithDescriptorStringValueCheckModeSchema: function() {
+        return compareWithDescriptorStringValueCheckModeSchema;
+    },
+    compareWithDescriptorValueCheckModeSchema: function() {
+        return compareWithDescriptorValueCheckModeSchema;
+    }
+});
+const _zod = require("zod");
+const _constants = require("../../../../src/utils/constants");
+const checkActualValueCheckModeSchema = _zod.z.enum(_constants.CHECK_ACTUAL_VALUE_CHECK_MODES);
+const compareWithDescriptorAnyValueCheckModeSchema = _zod.z.enum(_constants.COMPARE_WITH_DESCRIPTOR_ANY_VALUE_CHECK_MODES);
+const compareWithDescriptorStringValueCheckModeSchema = _zod.z.enum(_constants.COMPARE_WITH_DESCRIPTOR_STRING_VALUE_CHECK_MODES);
+const compareWithDescriptorValueCheckModeSchema = _zod.z.enum(_constants.COMPARE_WITH_DESCRIPTOR_VALUE_CHECK_MODES);

package/dist/bin/validateMockServerConfig/utils/entitiesSchema/entitiesSchema.js

@@ -1,67 +1,124 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.plainEntitySchema = exports.mappedEntitySchema = void 0;
-var _zod = require("zod");
-var _checkModeSchema = require("../checkModeSchema/checkModeSchema");
-var _jsonSchema = require("../jsonSchema/jsonSchema");
-var _plainObjectSchema = require("../plainObjectSchema/plainObjectSchema");
-var _requiredPropertiesSchema = require("../requiredPropertiesSchema/requiredPropertiesSchema");
-/* ----- Plain entity schema ----- */
-
-const topLevelPlainEntityDescriptorSchema = (0, _requiredPropertiesSchema.requiredPropertiesSchema)(_zod.z.discriminatedUnion('checkMode', [_zod.z.strictObject({
-  checkMode: _zod.z.literal('function'),
-  value: _zod.z.function()
-}), _zod.z.strictObject({
-  checkMode: _checkModeSchema.compareWithDescriptorAnyValueCheckModeSchema,
-  value: _jsonSchema.jsonSchema
-}), _zod.z.strictObject({
-  checkMode: _checkModeSchema.checkActualValueCheckModeSchema
-})]), ['checkMode']);
-const propertyLevelPlainEntityDescriptorSchema = (0, _requiredPropertiesSchema.requiredPropertiesSchema)(_zod.z.discriminatedUnion('checkMode', [_zod.z.strictObject({
-  checkMode: _zod.z.literal('function'),
-  value: _zod.z.function()
-}), _zod.z.strictObject({
-  checkMode: _checkModeSchema.compareWithDescriptorAnyValueCheckModeSchema,
-  value: _jsonSchema.jsonSchema
-}), _zod.z.strictObject({
-  checkMode: _zod.z.literal('regExp'),
-  value: _zod.z.union([_zod.z.instanceof(RegExp), _zod.z.array(_zod.z.instanceof(RegExp))])
-}), _zod.z.strictObject({
-  checkMode: _checkModeSchema.compareWithDescriptorStringValueCheckModeSchema,
-  value: _zod.z.union([_jsonSchema.jsonLiteralSchema, _zod.z.array(_jsonSchema.jsonLiteralSchema)])
-}), _zod.z.strictObject({
-  checkMode: _checkModeSchema.checkActualValueCheckModeSchema
-})]), ['checkMode']);
-const nonCheckModeRecordSchema = recordSchema => (0, _plainObjectSchema.plainObjectSchema)(recordSchema.and(_zod.z.object({
-  checkMode: _zod.z.never().optional()
-})));
-
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    mappedEntitySchema: function() {
+        return mappedEntitySchema;
+    },
+    plainEntitySchema: function() {
+        return plainEntitySchema;
+    }
+});
+const _zod = require("zod");
+const _checkModeSchema = require("../checkModeSchema/checkModeSchema");
+const _jsonSchema = require("../jsonSchema/jsonSchema");
+const _plainObjectSchema = require("../plainObjectSchema/plainObjectSchema");
+const _requiredPropertiesSchema = require("../requiredPropertiesSchema/requiredPropertiesSchema");
+/* ----- Plain entity schema ----- */ const topLevelPlainEntityDescriptorSchema = (0, _requiredPropertiesSchema.requiredPropertiesSchema)(_zod.z.discriminatedUnion("checkMode", [
+    _zod.z.strictObject({
+        checkMode: _zod.z.literal("function"),
+        value: _zod.z.function()
+    }),
+    _zod.z.strictObject({
+        checkMode: _checkModeSchema.compareWithDescriptorAnyValueCheckModeSchema,
+        value: _jsonSchema.jsonSchema
+    }),
+    _zod.z.strictObject({
+        checkMode: _checkModeSchema.checkActualValueCheckModeSchema
+    })
+]), [
+    "checkMode"
+]);
+const propertyLevelPlainEntityDescriptorSchema = (0, _requiredPropertiesSchema.requiredPropertiesSchema)(_zod.z.discriminatedUnion("checkMode", [
+    _zod.z.strictObject({
+        checkMode: _zod.z.literal("function"),
+        value: _zod.z.function()
+    }),
+    _zod.z.strictObject({
+        checkMode: _checkModeSchema.compareWithDescriptorAnyValueCheckModeSchema,
+        value: _jsonSchema.jsonSchema
+    }),
+    _zod.z.strictObject({
+        checkMode: _zod.z.literal("regExp"),
+        value: _zod.z.union([
+            _zod.z.instanceof(RegExp),
+            _zod.z.array(_zod.z.instanceof(RegExp))
+        ])
+    }),
+    _zod.z.strictObject({
+        checkMode: _checkModeSchema.compareWithDescriptorStringValueCheckModeSchema,
+        value: _zod.z.union([
+            _jsonSchema.jsonLiteralSchema,
+            _zod.z.array(_jsonSchema.jsonLiteralSchema)
+        ])
+    }),
+    _zod.z.strictObject({
+        checkMode: _checkModeSchema.checkActualValueCheckModeSchema
+    })
+]), [
+    "checkMode"
+]);
+const nonCheckModeRecordSchema = (recordSchema)=>(0, _plainObjectSchema.plainObjectSchema)(recordSchema.and(_zod.z.object({
+        checkMode: _zod.z.never().optional()
+    })));
 // ✅ important:
 // 1st property level record disallow checkMode
-const topLevelRecordValueSchema = _zod.z.union([_jsonSchema.jsonLiteralSchema, _zod.z.array(_jsonSchema.jsonSchema), nonCheckModeRecordSchema(_zod.z.record(_jsonSchema.jsonSchema))]);
-
+const topLevelRecordValueSchema = _zod.z.union([
+    _jsonSchema.jsonLiteralSchema,
+    _zod.z.array(_jsonSchema.jsonSchema),
+    nonCheckModeRecordSchema(_zod.z.record(_jsonSchema.jsonSchema))
+]);
 // ✅ important:
 // top level record disallow checkMode
-const topLevelRecordSchema = nonCheckModeRecordSchema(_zod.z.record(_zod.z.union([propertyLevelPlainEntityDescriptorSchema, topLevelRecordValueSchema])));
-const topLevelArraySchema = _zod.z.array(_jsonSchema.jsonSchema.and(_zod.z.custom(value => !_jsonSchema.jsonLiteralSchema.safeParse(value).success)));
-const plainEntitySchema = exports.plainEntitySchema = _zod.z.union([topLevelPlainEntityDescriptorSchema, topLevelRecordSchema, topLevelArraySchema]);
-
-/* ----- Mapped entity schema ----- */
-
-const mappedEntityValueSchema = _zod.z.union([_zod.z.string(), _zod.z.number(), _zod.z.boolean()]);
-const mappedEntityDescriptorSchema = (0, _requiredPropertiesSchema.requiredPropertiesSchema)(_zod.z.discriminatedUnion('checkMode', [_zod.z.strictObject({
-  checkMode: _zod.z.literal('function'),
-  value: _zod.z.function()
-}), _zod.z.strictObject({
-  checkMode: _zod.z.literal('regExp'),
-  value: _zod.z.union([_zod.z.instanceof(RegExp), _zod.z.array(_zod.z.instanceof(RegExp))])
-}), _zod.z.strictObject({
-  checkMode: _checkModeSchema.compareWithDescriptorValueCheckModeSchema,
-  value: _zod.z.union([mappedEntityValueSchema, _zod.z.array(mappedEntityValueSchema)])
-}), _zod.z.strictObject({
-  checkMode: _checkModeSchema.checkActualValueCheckModeSchema
-})]), ['checkMode']);
-const mappedEntitySchema = exports.mappedEntitySchema = (0, _plainObjectSchema.plainObjectSchema)(_zod.z.record(_zod.z.union([mappedEntityValueSchema, _zod.z.array(mappedEntityValueSchema), mappedEntityDescriptorSchema])));
+const topLevelRecordSchema = nonCheckModeRecordSchema(_zod.z.record(_zod.z.union([
+    propertyLevelPlainEntityDescriptorSchema,
+    topLevelRecordValueSchema
+])));
+const topLevelArraySchema = _zod.z.array(_jsonSchema.jsonSchema.and(_zod.z.custom((value)=>!_jsonSchema.jsonLiteralSchema.safeParse(value).success)));
+const plainEntitySchema = _zod.z.union([
+    topLevelPlainEntityDescriptorSchema,
+    topLevelRecordSchema,
+    topLevelArraySchema
+]);
+/* ----- Mapped entity schema ----- */ const mappedEntityValueSchema = _zod.z.union([
+    _zod.z.string(),
+    _zod.z.number(),
+    _zod.z.boolean()
+]);
+const mappedEntityDescriptorSchema = (0, _requiredPropertiesSchema.requiredPropertiesSchema)(_zod.z.discriminatedUnion("checkMode", [
+    _zod.z.strictObject({
+        checkMode: _zod.z.literal("function"),
+        value: _zod.z.function()
+    }),
+    _zod.z.strictObject({
+        checkMode: _zod.z.literal("regExp"),
+        value: _zod.z.union([
+            _zod.z.instanceof(RegExp),
+            _zod.z.array(_zod.z.instanceof(RegExp))
+        ])
+    }),
+    _zod.z.strictObject({
+        checkMode: _checkModeSchema.compareWithDescriptorValueCheckModeSchema,
+        value: _zod.z.union([
+            mappedEntityValueSchema,
+            _zod.z.array(mappedEntityValueSchema)
+        ])
+    }),
+    _zod.z.strictObject({
+        checkMode: _checkModeSchema.checkActualValueCheckModeSchema
+    })
+]), [
+    "checkMode"
+]);
+const mappedEntitySchema = (0, _plainObjectSchema.plainObjectSchema)(_zod.z.record(_zod.z.union([
+    mappedEntityValueSchema,
+    _zod.z.array(mappedEntityValueSchema),
+    mappedEntityDescriptorSchema
+])));

package/dist/bin/validateMockServerConfig/utils/index.js

@@ -1,71 +1,23 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-var _checkModeSchema = require("./checkModeSchema/checkModeSchema");
-Object.keys(_checkModeSchema).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _checkModeSchema[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _checkModeSchema[key];
-    }
-  });
-});
-var _entitiesSchema = require("./entitiesSchema/entitiesSchema");
-Object.keys(_entitiesSchema).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _entitiesSchema[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _entitiesSchema[key];
-    }
-  });
-});
-var _jsonSchema = require("./jsonSchema/jsonSchema");
-Object.keys(_jsonSchema).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _jsonSchema[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _jsonSchema[key];
-    }
-  });
-});
-var _plainObjectSchema = require("./plainObjectSchema/plainObjectSchema");
-Object.keys(_plainObjectSchema).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _plainObjectSchema[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _plainObjectSchema[key];
-    }
-  });
-});
-var _requiredPropertiesSchema = require("./requiredPropertiesSchema/requiredPropertiesSchema");
-Object.keys(_requiredPropertiesSchema).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _requiredPropertiesSchema[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _requiredPropertiesSchema[key];
-    }
-  });
-});
-var _sharedSchema = require("./sharedSchema/sharedSchema");
-Object.keys(_sharedSchema).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _sharedSchema[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _sharedSchema[key];
-    }
-  });
-});
+_export_star(require("./checkModeSchema/checkModeSchema"), exports);
+_export_star(require("./entitiesSchema/entitiesSchema"), exports);
+_export_star(require("./jsonSchema/jsonSchema"), exports);
+_export_star(require("./plainObjectSchema/plainObjectSchema"), exports);
+_export_star(require("./requiredPropertiesSchema/requiredPropertiesSchema"), exports);
+_export_star(require("./sharedSchema/sharedSchema"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/bin/validateMockServerConfig/utils/jsonSchema/jsonSchema.js

@@ -1,13 +1,33 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.jsonSchema = exports.jsonLiteralSchema = void 0;
-var _zod = require("zod");
-var _helpers = require("../../../../src/utils/helpers");
-const jsonLiteralSchema = exports.jsonLiteralSchema = _zod.z.union([_zod.z.string(), _zod.z.number(), _zod.z.boolean(), _zod.z.null()]);
-const jsonSchema = exports.jsonSchema = _zod.z.lazy(() => _zod.z.union([jsonLiteralSchema, _zod.z.array(jsonSchema),
-// ✅ important:
-// using 'and' checking instead of 'plainObjectSchema' because of zod types peculiarities
-_zod.z.record(jsonSchema).and(_zod.z.custom(value => (0, _helpers.isPlainObject)(value)))]));
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    jsonLiteralSchema: function() {
+        return jsonLiteralSchema;
+    },
+    jsonSchema: function() {
+        return jsonSchema;
+    }
+});
+const _zod = require("zod");
+const _helpers = require("../../../../src/utils/helpers");
+const jsonLiteralSchema = _zod.z.union([
+    _zod.z.string(),
+    _zod.z.number(),
+    _zod.z.boolean(),
+    _zod.z.null()
+]);
+const jsonSchema = _zod.z.lazy(()=>_zod.z.union([
+        jsonLiteralSchema,
+        _zod.z.array(jsonSchema),
+        // ✅ important:
+        // using 'and' checking instead of 'plainObjectSchema' because of zod types peculiarities
+        _zod.z.record(jsonSchema).and(_zod.z.custom((value)=>(0, _helpers.isPlainObject)(value)))
+    ]));

package/dist/bin/validateMockServerConfig/utils/plainObjectSchema/plainObjectSchema.js

@@ -1,11 +1,12 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.plainObjectSchema = void 0;
-var _zod = require("zod");
-// ✅ important:
-// this schema is needed because zod handle RegExps as plain object
-const plainObjectSchema = schema => _zod.z.custom(value => !(value instanceof RegExp)).pipe(schema);
-exports.plainObjectSchema = plainObjectSchema;
+Object.defineProperty(exports, "plainObjectSchema", {
+    enumerable: true,
+    get: function() {
+        return plainObjectSchema;
+    }
+});
+const _zod = require("zod");
+const plainObjectSchema = (schema)=>_zod.z.custom((value)=>!(value instanceof RegExp)).pipe(schema);

package/dist/bin/validateMockServerConfig/utils/requiredPropertiesSchema/requiredPropertiesSchema.js

@@ -1,10 +1,13 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.requiredPropertiesSchema = void 0;
-var _zod = require("zod");
-var _helpers = require("../../../../src/utils/helpers");
-const requiredPropertiesSchema = (schema, requiredProperties) => _zod.z.custom(value => (0, _helpers.isPlainObject)(value) && requiredProperties.every(property => Object.prototype.hasOwnProperty.call(value, property))).pipe(schema);
-exports.requiredPropertiesSchema = requiredPropertiesSchema;
+Object.defineProperty(exports, "requiredPropertiesSchema", {
+    enumerable: true,
+    get: function() {
+        return requiredPropertiesSchema;
+    }
+});
+const _zod = require("zod");
+const _helpers = require("../../../../src/utils/helpers");
+const requiredPropertiesSchema = (schema, requiredProperties)=>_zod.z.custom((value)=>(0, _helpers.isPlainObject)(value) && requiredProperties.every((property)=>Object.prototype.hasOwnProperty.call(value, property))).pipe(schema);

package/dist/bin/validateMockServerConfig/utils/sharedSchema/sharedSchema.js

@@ -1,9 +1,21 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.stringJsonFilenameSchema = exports.stringForwardSlashSchema = void 0;
-var _zod = require("zod");
-const stringForwardSlashSchema = exports.stringForwardSlashSchema = _zod.z.string().startsWith('/');
-const stringJsonFilenameSchema = exports.stringJsonFilenameSchema = _zod.z.string().endsWith('.json');
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    stringForwardSlashSchema: function() {
+        return stringForwardSlashSchema;
+    },
+    stringJsonFilenameSchema: function() {
+        return stringJsonFilenameSchema;
+    }
+});
+const _zod = require("zod");
+const stringForwardSlashSchema = _zod.z.string().startsWith("/");
+const stringJsonFilenameSchema = _zod.z.string().endsWith(".json");