@powerduck/schema-designer 0.1.0

package/dist/react/parametersTable/index.d.cts

@@ -0,0 +1,7 @@
+import * as react from 'react';
+import { a as ParameterTableProps } from '../../types-B27Dw9do.cjs';
+export { A as ApplyAdjacentSplitterResizeOptions, C as ColumnDefinition, g as ColumnId, h as OpenApiExampleObject, i as OpenApiMediaType, O as OpenApiParameter, c as OpenApiReference, d as OpenApiSchema, P as ParameterInput, f as ParameterRow, e as ParameterTableGeneratorContext, j as ParameterValueSource, b as ParameterValues, R as ResolvedParameterValue, S as SplitterResizeSession } from '../../types-B27Dw9do.cjs';
+
+declare const ParameterTable: react.NamedExoticComponent<ParameterTableProps>;
+
+export { ParameterTable, ParameterTableProps, ParameterTable as ParametersTable };

package/dist/react/parametersTable/index.d.ts

@@ -0,0 +1,7 @@
+import * as react from 'react';
+import { a as ParameterTableProps } from '../../types-B27Dw9do.js';
+export { A as ApplyAdjacentSplitterResizeOptions, C as ColumnDefinition, g as ColumnId, h as OpenApiExampleObject, i as OpenApiMediaType, O as OpenApiParameter, c as OpenApiReference, d as OpenApiSchema, P as ParameterInput, f as ParameterRow, e as ParameterTableGeneratorContext, j as ParameterValueSource, b as ParameterValues, R as ResolvedParameterValue, S as SplitterResizeSession } from '../../types-B27Dw9do.js';
+
+declare const ParameterTable: react.NamedExoticComponent<ParameterTableProps>;
+
+export { ParameterTable, ParameterTableProps, ParameterTable as ParametersTable };

package/dist/react/parametersTable/index.js

@@ -0,0 +1,9 @@
+import '../../chunk-PBE36BVA.js';
+export { ParameterTable, ParameterTable as ParametersTable } from '../../chunk-GWHDTTQK.js';
+import '../../chunk-2XUQB6BQ.js';
+import '../../chunk-BXFABOMJ.js';
+import '../../chunk-P5B3HSPY.js';
+import '../../chunk-ZHNYNFGL.js';
+import '../../chunk-MADPN2PJ.js';
+import '../../chunk-HI5FBHCO.js';
+import '../../chunk-KX3LFFOV.js';

package/dist/react/parametersTable/libs/generateValue.cjs

@@ -0,0 +1,558 @@
+'use strict';
+
+var chunkWRHWOMZQ_cjs = require('../../../chunk-WRHWOMZQ.cjs');
+var chunkYWDKCX6N_cjs = require('../../../chunk-YWDKCX6N.cjs');
+var faker = require('@faker-js/faker');
+var Ajv = require('ajv/dist/2020.js');
+var addFormats = require('ajv-formats');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
+var addFormats__default = /*#__PURE__*/_interopDefault(addFormats);
+
+var generateSync;
+var DEFAULT_OPTIONS = {
+  humanize: true,
+  useDefault: true,
+  seed: Date.now(),
+  maxArrayItems: 3,
+  maxDepth: 5,
+  strictSchemaValidation: true,
+  validationRetryCount: 5
+};
+var ajv = new Ajv__default.default({ allErrors: true, strict: false, addUsedSchema: false });
+addFormats__default.default(ajv);
+var validators = /* @__PURE__ */ new WeakMap();
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isReference(value) {
+  return isRecord(value) && typeof value.$ref === "string";
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function normalizeTypes(schema) {
+  const t = schema.type;
+  if (typeof t === "string") return [t];
+  if (Array.isArray(t))
+    return t.filter((x) => typeof x === "string");
+  return [];
+}
+function getSchemaFormat(schema) {
+  return typeof schema.format === "string" ? schema.format : void 0;
+}
+function getParameterName(context) {
+  return context.parameter.name.trim().toLowerCase();
+}
+function tokenizeParameterName(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-./:[\]{}]+/g, " ").split(/\s+/).filter(Boolean).map((token) => token.toLowerCase());
+}
+function hasToken(tokens, candidates) {
+  return candidates.some((candidate) => tokens.includes(candidate));
+}
+function hasAnyToken(tokens, candidates) {
+  return candidates.some(
+    (candidate) => tokens.some((t) => t.includes(candidate))
+  );
+}
+function resolveEnumValue(schema, fakerInstance, humanize) {
+  if (schema.const !== void 0) return schema.const;
+  if (!Array.isArray(schema.enum) || schema.enum.length === 0) return void 0;
+  return humanize ? fakerInstance.helpers.arrayElement(schema.enum) : schema.enum[0];
+}
+function getStringBounds(schema) {
+  return {
+    min: isFiniteNumber(schema.minLength) ? Math.max(0, schema.minLength) : void 0,
+    max: isFiniteNumber(schema.maxLength) ? Math.max(0, schema.maxLength) : void 0
+  };
+}
+function constrainString(value, schema) {
+  const { min, max } = getStringBounds(schema);
+  let result = value;
+  if (max !== void 0 && result.length > max) result = result.slice(0, max);
+  if (min !== void 0 && result.length < min)
+    result = result.padEnd(min, "x");
+  return result;
+}
+function getNumberBounds(schema, integer) {
+  const fallbackMin = 1;
+  const fallbackMax = integer ? 100 : 100;
+  let min = isFiniteNumber(schema.minimum) ? schema.minimum : fallbackMin;
+  let max = isFiniteNumber(schema.maximum) ? schema.maximum : fallbackMax;
+  if (typeof schema.exclusiveMinimum === "number") {
+    min = integer ? Math.max(min, Math.floor(schema.exclusiveMinimum) + 1) : Math.max(min, schema.exclusiveMinimum + Number.EPSILON);
+  }
+  if (typeof schema.exclusiveMaximum === "number") {
+    max = integer ? Math.min(max, Math.ceil(schema.exclusiveMaximum) - 1) : Math.min(max, schema.exclusiveMaximum - Number.EPSILON);
+  }
+  if (max < min) max = min;
+  return { min, max };
+}
+function generateInteger(schema, fakerInstance) {
+  const { min, max } = getNumberBounds(schema, true);
+  const multipleOf = isFiniteNumber(schema.multipleOf) && schema.multipleOf > 0 ? schema.multipleOf : void 0;
+  if (multipleOf) {
+    const minMultiple = Math.ceil(min / multipleOf);
+    const maxMultiple = Math.floor(max / multipleOf);
+    if (maxMultiple >= minMultiple) {
+      return fakerInstance.number.int({ min: minMultiple, max: maxMultiple }) * multipleOf;
+    }
+  }
+  return fakerInstance.number.int({
+    min: Math.ceil(min),
+    max: Math.floor(max)
+  });
+}
+function generateNumber(schema, fakerInstance) {
+  const { min, max } = getNumberBounds(schema, false);
+  const multipleOf = isFiniteNumber(schema.multipleOf) && schema.multipleOf > 0 ? schema.multipleOf : void 0;
+  if (multipleOf) {
+    const minMultiple = Math.ceil(min / multipleOf);
+    const maxMultiple = Math.floor(max / multipleOf);
+    if (maxMultiple >= minMultiple) {
+      return fakerInstance.number.int({ min: minMultiple, max: maxMultiple }) * multipleOf;
+    }
+  }
+  return fakerInstance.number.float({ min, max, fractionDigits: 2 });
+}
+function generateDate(schema, fakerInstance) {
+  const date = fakerInstance.date.recent({ days: 30 });
+  return getSchemaFormat(schema) === "date" ? date.toISOString().slice(0, 10) : date.toISOString();
+}
+function generateTime(fakerInstance) {
+  return fakerInstance.date.recent({ days: 1 }).toISOString().slice(11, 19);
+}
+function generateStringByParameterName(schema, context, fakerInstance) {
+  const parameterName = getParameterName(context);
+  const tokens = tokenizeParameterName(parameterName);
+  const format = getSchemaFormat(schema);
+  switch (format) {
+    case "email":
+      return fakerInstance.internet.email();
+    case "uuid":
+      return fakerInstance.string.uuid();
+    case "uri":
+    case "uri-reference":
+      return fakerInstance.internet.url();
+    case "hostname":
+      return fakerInstance.internet.domainName();
+    case "ipv4":
+      return fakerInstance.internet.ip();
+    case "ipv6":
+      return fakerInstance.internet.ipv6();
+    case "date":
+    case "date-time":
+      return generateDate(schema, fakerInstance);
+    case "time":
+      return generateTime(fakerInstance);
+    case "password":
+      return fakerInstance.internet.password({ length: 14, memorable: false });
+  }
+  if (hasAnyToken(tokens, ["uuid", "guid"])) return fakerInstance.string.uuid();
+  if (hasToken(tokens, ["id", "identifier", "key"])) {
+    return `usr_${fakerInstance.string.alphanumeric({ length: 10, casing: "lower" })}`;
+  }
+  if (hasAnyToken(tokens, ["firstname", "givenname"]))
+    return fakerInstance.person.firstName();
+  if (hasAnyToken(tokens, ["lastname", "surname", "familyname"]))
+    return fakerInstance.person.lastName();
+  if (hasAnyToken(tokens, ["fullname", "displayname", "username"]))
+    return fakerInstance.person.fullName();
+  if (hasAnyToken(tokens, ["email", "mail"]))
+    return fakerInstance.internet.email();
+  if (hasAnyToken(tokens, ["phone", "mobile", "telephone"]))
+    return fakerInstance.phone.number();
+  if (hasAnyToken(tokens, ["url", "uri", "website", "homepage", "link"]))
+    return fakerInstance.internet.url();
+  if (hasAnyToken(tokens, ["country", "countrycode"])) {
+    return hasAnyToken(tokens, ["code"]) ? fakerInstance.location.countryCode() : fakerInstance.location.country();
+  }
+  if (hasAnyToken(tokens, ["city"])) return fakerInstance.location.city();
+  if (hasAnyToken(tokens, ["state", "province", "region"]))
+    return fakerInstance.location.state();
+  if (hasAnyToken(tokens, ["zip", "zipcode", "postalcode", "postcode"]))
+    return fakerInstance.location.zipCode();
+  if (hasAnyToken(tokens, ["street", "address"]))
+    return fakerInstance.location.streetAddress();
+  if (hasAnyToken(tokens, ["company", "organization", "organisation"]))
+    return fakerInstance.company.name();
+  if (hasAnyToken(tokens, ["job", "title", "position", "role"]))
+    return fakerInstance.person.jobTitle();
+  if (hasAnyToken(tokens, [
+    "token",
+    "access_token",
+    "accesstoken",
+    "refresh_token",
+    "refreshtoken"
+  ])) {
+    return fakerInstance.string.alphanumeric({ length: 32, casing: "mixed" });
+  }
+  if (hasAnyToken(tokens, ["api_key", "apikey", "secret", "secretkey"])) {
+    return fakerInstance.string.alphanumeric({ length: 32, casing: "mixed" });
+  }
+  if (hasAnyToken(tokens, ["search", "query", "keyword", "q"])) {
+    return fakerInstance.helpers.arrayElement([
+      "laptop",
+      "coffee",
+      "openapi",
+      "developer tools",
+      "wireless headphones",
+      "running shoes",
+      "travel backpack"
+    ]);
+  }
+  if (hasAnyToken(tokens, ["slug"])) {
+    return fakerInstance.helpers.slugify(fakerInstance.commerce.productName()).toLowerCase();
+  }
+  if (hasAnyToken(tokens, ["product", "productname", "item"]))
+    return fakerInstance.commerce.productName();
+  if (hasAnyToken(tokens, ["description", "summary"]))
+    return fakerInstance.commerce.productDescription();
+  if (hasAnyToken(tokens, ["price", "amount", "cost", "total", "balance"])) {
+    return fakerInstance.commerce.price({ min: 10, max: 500, dec: 2 });
+  }
+  if (hasAnyToken(tokens, [
+    "date",
+    "birthday",
+    "birthdate",
+    "createdat",
+    "updatedat",
+    "deletedat",
+    "timestamp"
+  ])) {
+    return generateDate(schema, fakerInstance);
+  }
+  if (hasAnyToken(tokens, ["message", "comment", "note", "text"])) {
+    return fakerInstance.lorem.sentence({ min: 5, max: 12 });
+  }
+  return void 0;
+}
+function tryValidateValue(value, schema) {
+  try {
+    let validate = validators.get(schema);
+    if (!validate) {
+      validate = ajv.compile(schema);
+      validators.set(schema, validate);
+      ajv.removeSchema(schema);
+    }
+    return Boolean(validate(value));
+  } catch {
+    return false;
+  }
+}
+function generateSafeFallback(schema, genCtx, fakerInstance) {
+  const types = normalizeTypes(schema);
+  const pickedType = types.length ? fakerInstance.helpers.arrayElement(types) : void 0;
+  switch (pickedType) {
+    case "string":
+      return fakerInstance.string.alpha({ length: 10, casing: "mixed" });
+    case "integer":
+      return 1;
+    case "number":
+      return 1.5;
+    case "boolean":
+      return false;
+    case "array":
+      return [];
+    case "object":
+      return {};
+    case "null":
+      return null;
+    default:
+      return `${genCtx.parameter.name || "value"}-example`;
+  }
+}
+function prepareSchemaForJsf(schema, options) {
+  const maps = /* @__PURE__ */ new Set([
+    "properties",
+    "patternProperties",
+    "$defs",
+    "definitions",
+    "dependentSchemas"
+  ]);
+  const arrays = /* @__PURE__ */ new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+  const singles = /* @__PURE__ */ new Set([
+    "items",
+    "contains",
+    "additionalProperties",
+    "unevaluatedProperties",
+    "unevaluatedItems",
+    "not",
+    "if",
+    "then",
+    "else",
+    "propertyNames"
+  ]);
+  const visit = (value) => {
+    if (!isRecord(value)) return value;
+    const result = { ...value };
+    if (value.type === "array" || value.items !== void 0) {
+      if (isFiniteNumber(value.minItems) && value.minItems > options.maxArrayItems)
+        throw new RangeError(
+          "Array minimum exceeds the generation item budget."
+        );
+      result.maxItems = Math.min(
+        isFiniteNumber(value.maxItems) ? value.maxItems : options.maxArrayItems,
+        options.maxArrayItems
+      );
+    }
+    if (value.type === "string" || value.minLength !== void 0 || value.maxLength !== void 0) {
+      if (isFiniteNumber(value.minLength) && value.minLength > 16384)
+        throw new RangeError(
+          "String minimum exceeds the generation length budget."
+        );
+      result.maxLength = Math.min(
+        isFiniteNumber(value.maxLength) ? value.maxLength : 16384,
+        16384
+      );
+    }
+    for (const [key, item] of Object.entries(value)) {
+      if (maps.has(key) && isRecord(item))
+        result[key] = Object.fromEntries(
+          Object.entries(item).map(([name, child]) => [name, visit(child)])
+        );
+      else if (arrays.has(key) && Array.isArray(item))
+        result[key] = item.map(visit);
+      else if (singles.has(key)) result[key] = visit(item);
+    }
+    return result;
+  };
+  return visit(schema);
+}
+function generateGenericSchemaValue(schema, genCtx, options, fakerInstance) {
+  const preparedSchema = prepareSchemaForJsf(schema, options);
+  try {
+    const raw = generateSync(
+      preparedSchema,
+      {
+        seed: options.seed,
+        maxDepth: options.maxDepth,
+        maxDefaultItems: options.maxArrayItems,
+        optionalsProbability: 0.35,
+        alwaysFakeOptionals: false,
+        fillProperties: true,
+        useDefaultValue: options.useDefault,
+        useExamplesValue: false,
+        extensions: { faker: fakerInstance },
+        failOnInvalidTypes: false
+      }
+    );
+    if (!options.strictSchemaValidation || tryValidateValue(raw, schema)) {
+      return raw;
+    }
+    for (let i = 0; i <= options.validationRetryCount; i++) {
+      const retryVal = generateSync(
+        preparedSchema,
+        {
+          seed: options.seed + i,
+          maxDepth: options.maxDepth,
+          maxDefaultItems: options.maxArrayItems,
+          optionalsProbability: 0.35,
+          alwaysFakeOptionals: false,
+          fillProperties: true,
+          useDefaultValue: options.useDefault,
+          useExamplesValue: false,
+          extensions: { faker: fakerInstance },
+          failOnInvalidTypes: false
+        }
+      );
+      if (tryValidateValue(retryVal, schema)) return retryVal;
+    }
+    return raw;
+  } catch {
+    return generateSafeFallback(schema, genCtx, fakerInstance);
+  }
+}
+function generateStringWithRetry(schema, context, fakerInstance, humanize, strict, retry) {
+  const enumVal = resolveEnumValue(schema, fakerInstance, humanize);
+  if (enumVal !== void 0) {
+    const candidate2 = constrainString(String(enumVal), schema);
+    if (!strict || tryValidateValue(candidate2, schema)) return candidate2;
+  }
+  const humanVal = generateStringByParameterName(
+    schema,
+    context,
+    fakerInstance
+  );
+  if (humanVal !== void 0) {
+    const candidate2 = constrainString(humanVal, schema);
+    if (!strict || tryValidateValue(candidate2, schema)) return candidate2;
+  }
+  if (schema.pattern && typeof schema.pattern === "string") {
+    try {
+      const jsfVal = generateSync(schema);
+      if (typeof jsfVal === "string") {
+        if (!strict || tryValidateValue(jsfVal, schema)) return jsfVal;
+      }
+    } catch {
+    }
+  }
+  const { min, max } = getStringBounds(schema);
+  if (min !== void 0 && min > 16384)
+    throw new RangeError(
+      "String minimum exceeds the generation length budget."
+    );
+  const length = fakerInstance.number.int({
+    min: min ?? Math.min(8, max ?? 8),
+    max: Math.min(max ?? Math.max(min ?? 8, 24), 16384)
+  });
+  const candidate = constrainString(
+    fakerInstance.string.alpha({ length, casing: "mixed" }),
+    schema
+  );
+  if (!strict || tryValidateValue(candidate, schema)) return candidate;
+  if (retry <= 0) return candidate;
+  return generateStringWithRetry(
+    schema,
+    context,
+    fakerInstance,
+    humanize,
+    strict,
+    retry - 1
+  );
+}
+function generateArrayValue(schema, genCtx, options, fakerInstance) {
+  if (genCtx.depth >= options.maxDepth) return [];
+  const minItems = isFiniteNumber(schema.minItems) ? Math.max(0, schema.minItems) : Math.min(
+    1,
+    isFiniteNumber(schema.maxItems) ? Math.max(0, schema.maxItems) : 1
+  );
+  if (minItems > options.maxArrayItems)
+    throw new RangeError("Array minimum exceeds the generation item budget.");
+  const maxItems = isFiniteNumber(schema.maxItems) ? Math.min(options.maxArrayItems, Math.max(minItems, schema.maxItems)) : options.maxArrayItems;
+  const count = fakerInstance.number.int({ min: minItems, max: maxItems });
+  if (!schema.items || isReference(schema.items)) return [];
+  return Array.from(
+    { length: count },
+    (_, index) => generateFromSchema(
+      schema.items === true ? {} : schema.items,
+      { ...genCtx, rowIndex: genCtx.rowIndex + index, depth: genCtx.depth + 1 },
+      options,
+      fakerInstance
+    )
+  );
+}
+function generateObjectValue(schema, genCtx, options, fakerInstance) {
+  if (genCtx.depth >= options.maxDepth) return {};
+  const generated = generateGenericSchemaValue(
+    schema,
+    genCtx,
+    options,
+    fakerInstance
+  );
+  return isRecord(generated) ? generated : {};
+}
+function generateFromSchema(schema, genCtx, options, fakerInstance) {
+  if (genCtx.depth >= options.maxDepth) {
+    return generateSafeFallback(schema, genCtx, fakerInstance);
+  }
+  const enumVal = resolveEnumValue(schema, fakerInstance, options.humanize);
+  if (enumVal !== void 0) {
+    if (!options.strictSchemaValidation || tryValidateValue(enumVal, schema)) {
+      return enumVal;
+    }
+  }
+  const types = normalizeTypes(schema);
+  const targetType = types.length ? fakerInstance.helpers.arrayElement(types) : void 0;
+  switch (targetType) {
+    case "string":
+      return generateStringWithRetry(
+        schema,
+        genCtx,
+        fakerInstance,
+        options.humanize,
+        options.strictSchemaValidation,
+        options.validationRetryCount
+      );
+    case "integer": {
+      for (let i = 0; i <= options.validationRetryCount; i++) {
+        const candidate = generateInteger(schema, fakerInstance);
+        if (!options.strictSchemaValidation || tryValidateValue(candidate, schema))
+          return candidate;
+      }
+      return generateInteger(schema, fakerInstance);
+    }
+    case "number": {
+      for (let i = 0; i <= options.validationRetryCount; i++) {
+        const candidate = generateNumber(schema, fakerInstance);
+        if (!options.strictSchemaValidation || tryValidateValue(candidate, schema))
+          return candidate;
+      }
+      return generateNumber(schema, fakerInstance);
+    }
+    case "boolean": {
+      for (let i = 0; i <= options.validationRetryCount; i++) {
+        const candidate = typeof enumVal === "boolean" ? enumVal : fakerInstance.datatype.boolean();
+        if (!options.strictSchemaValidation || tryValidateValue(candidate, schema)) {
+          return candidate;
+        }
+      }
+      return false;
+    }
+    case "array":
+      return generateArrayValue(schema, genCtx, options, fakerInstance);
+    case "object":
+      return generateObjectValue(schema, genCtx, options, fakerInstance);
+    case "null": {
+      const candidate = null;
+      if (!options.strictSchemaValidation || tryValidateValue(candidate, schema)) {
+        return candidate;
+      }
+      return generateSafeFallback(schema, genCtx, fakerInstance);
+    }
+    default:
+      return generateGenericSchemaValue(schema, genCtx, options, fakerInstance);
+  }
+}
+async function generateParameterValue(context, inputOptions) {
+  context.signal?.throwIfAborted();
+  generateSync ??= (await import('json-schema-faker')).generateSync;
+  const options = { ...DEFAULT_OPTIONS, ...inputOptions };
+  for (const [key, maximum] of [
+    ["maxArrayItems", 1e3],
+    ["maxDepth", 32],
+    ["validationRetryCount", 20]
+  ]) {
+    const value2 = options[key];
+    if (!Number.isInteger(value2) || value2 < (key === "validationRetryCount" ? 0 : 1) || value2 > maximum) {
+      throw new RangeError(`Invalid generator option: ${key}`);
+    }
+  }
+  const fakerInstance = options.fakerInstance ?? new faker.Faker({ locale: faker.en });
+  if (inputOptions?.seed !== void 0 && !inputOptions?.fakerInstance) {
+    fakerInstance.seed(options.seed);
+  }
+  context.signal?.throwIfAborted();
+  let rawSchema = chunkWRHWOMZQ_cjs.resolveParameterSchema(context.parameter, context.document) ?? context.parameter.schema;
+  if (rawSchema === void 0)
+    return `${context.parameter.name || "parameter"}-value`;
+  const resolvedSchema = chunkYWDKCX6N_cjs.dereferenceLocalSchema(
+    rawSchema,
+    context.document ?? rawSchema
+  );
+  if (resolvedSchema === false)
+    throw new Error("No value satisfies a false schema.");
+  const derefedSchema = resolvedSchema === true ? {} : resolvedSchema;
+  const generationSchema = prepareSchemaForJsf(
+    derefedSchema,
+    options
+  );
+  const genCtx = { ...context, depth: 0 };
+  context.signal?.throwIfAborted();
+  const value = generateFromSchema(
+    generationSchema,
+    genCtx,
+    options,
+    fakerInstance
+  );
+  if (options.strictSchemaValidation && !tryValidateValue(value, derefedSchema)) {
+    throw new Error(
+      "Unable to generate a value satisfying this schema. Provide an example or a custom generator."
+    );
+  }
+  return value;
+}
+
+exports.generateParameterValue = generateParameterValue;

package/dist/react/parametersTable/libs/generateValue.d.cts

@@ -0,0 +1,17 @@
+import { faker } from '@faker-js/faker';
+import { e as ParameterTableGeneratorContext } from '../../../types-B27Dw9do.cjs';
+import 'react';
+
+interface ParameterValueGeneratorOptions {
+    fakerInstance?: typeof faker;
+    humanize?: boolean;
+    useDefault?: boolean;
+    seed?: number;
+    maxArrayItems?: number;
+    maxDepth?: number;
+    strictSchemaValidation?: boolean;
+    validationRetryCount?: number;
+}
+declare function generateParameterValue(context: ParameterTableGeneratorContext, inputOptions?: ParameterValueGeneratorOptions): Promise<unknown>;
+
+export { type ParameterValueGeneratorOptions, generateParameterValue };

package/dist/react/parametersTable/libs/generateValue.d.ts

@@ -0,0 +1,17 @@
+import { faker } from '@faker-js/faker';
+import { e as ParameterTableGeneratorContext } from '../../../types-B27Dw9do.js';
+import 'react';
+
+interface ParameterValueGeneratorOptions {
+    fakerInstance?: typeof faker;
+    humanize?: boolean;
+    useDefault?: boolean;
+    seed?: number;
+    maxArrayItems?: number;
+    maxDepth?: number;
+    strictSchemaValidation?: boolean;
+    validationRetryCount?: number;
+}
+declare function generateParameterValue(context: ParameterTableGeneratorContext, inputOptions?: ParameterValueGeneratorOptions): Promise<unknown>;
+
+export { type ParameterValueGeneratorOptions, generateParameterValue };