@utilix-tech/sdk 0.29.0 → 0.30.0

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 Full release notes for all Utilix surfaces (browser tools, REST API, SDKs, MCP server) live at [utilix.tech/changelog](https://utilix.tech/changelog). This file tracks just this package.
 
+## 0.30.0
+- Add `jsonSchemaToTypescript` (json-schema-to-typescript): convert a JSON Schema document into TypeScript interfaces/types, reading `required`/`enum`/`oneOf`/`anyOf`/`allOf`/`$ref` directly instead of inferring from an example payload.
+- Add `estimatePasswordEntropy` (password-entropy-estimator): bits of entropy from a password's character pool, a strength label, and crack-time estimates across four guess-rate scenarios.
+
 ## 0.29.0
 - Add `readPdfPageDimensions` (pdf-page-dimensions): each page's MediaBox width/height (points and inches), rotation, and orientation, walking the Root -> Pages -> Kids tree and inheriting from ancestor nodes, plus a common paper size match (Letter, A4, etc.).
 - Add `parseIpv6Address` (ipv6-compressor): expand an IPv6 address to its full 8-group form or compress it to its RFC 5952 canonical shortest form, classify its address type, and handle an embedded IPv4 suffix or zone ID.

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/sdk
 
-**581 developer utility functions for Node.js: runs locally, no API key required.**
+**583 developer utility functions for Node.js: runs locally, no API key required.**
 
 [![npm version](https://img.shields.io/npm/v/@utilix-tech/sdk?style=flat-square&color=cb3837)](https://www.npmjs.com/package/@utilix-tech/sdk)
 [![npm downloads](https://img.shields.io/npm/dm/@utilix-tech/sdk?style=flat-square)](https://www.npmjs.com/package/@utilix-tech/sdk)
@@ -65,7 +65,7 @@ const { formatJson } = require("@utilix-tech/sdk/json");
 ### `/json`: JSON Tools
 
 ```ts
-import { formatJson, minifyJson, diffJson, jsonToTypescript, validateJson,
+import { formatJson, minifyJson, diffJson, jsonToTypescript, jsonSchemaToTypescript, validateJson,
          evaluateJsonPath, resolveJsonPointer, jsonToCsv, yamlToJson, jsonToYaml, getJsonStats } from "@utilix-tech/sdk/json";
 
 // Format with 2-space indent
@@ -77,6 +77,9 @@ diffJson(jsonA, jsonB);
 // Generate TypeScript interface from JSON
 jsonToTypescript('{"id":1,"name":"Alice"}', { rootName: "User" });
 
+// Generate TypeScript interfaces from a JSON Schema (reads required/enum/$ref directly)
+jsonSchemaToTypescript('{"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}', { rootName: "User" });
+
 // Query with JSONPath
 evaluateJsonPath(obj, "$.users[*].name");
 
@@ -222,14 +225,17 @@ shiftSubtitles("1\n00:00:01,000 --> 00:00:04,000\nHi\n", -2.5);
 
 ```ts
 import { generateUuid, generateV4, generateV7, generateUlid,
-         generatePassword, checkStrength, generateData } from "@utilix-tech/sdk/generators";
+         generatePassword, checkStrength, estimatePasswordEntropy, generateData } from "@utilix-tech/sdk/generators";
 
 generateUuid();       // "f47ac10b-58cc-4372-a567-0e02b2c3d479"  (v4)
 generateV7();         // time-ordered UUID v7
 generateUlid();       // "01ARZ3NDEKTSV4RRFFQ69G5FAV"
 
 generatePassword({ length: 16, symbols: true, numbers: true });
-checkStrength("P@ssw0rd!");  // { score: 4, label: "Strong", entropy: 52.4 }
+checkStrength("P@ssw0rd!");  // { score: 4, label: "Strong", color: "#16a34a" }
+
+// Actual bits of entropy from the character pool, plus crack-time estimates
+estimatePasswordEntropy("Tr0ub4dor&3xyzKL9!");  // { entropyBits: 118.26, strength: "strong", crackTimes: [...] }
 
 // Generate fake data rows
 generateData([
@@ -637,12 +643,12 @@ readVideoInfo(new Uint8Array(videoBytes));
 
 | Import | What it does |
 |---|---|
-| `@utilix-tech/sdk/json` | Format, minify, diff, validate, JSONPath, CSV↔JSON, YAML↔JSON, TS types |
+| `@utilix-tech/sdk/json` | Format, minify, diff, validate, JSONPath, CSV↔JSON, YAML↔JSON, TS types from data or from a JSON Schema |
 | `@utilix-tech/sdk/encoding` | Base64, URL, HTML entities, Base32/Base58/Base62 encode/decode |
 | `@utilix-tech/sdk/hashing` | MD5, SHA-1/256/512, bcrypt, HMAC, .htpasswd |
 | `@utilix-tech/sdk/text` | Case convert, slugify, word count, lorem ipsum, line ops, HTML→Markdown, Levenshtein/Damerau string distance |
 | `@utilix-tech/sdk/data` | CSV, YAML, TOML, XML, INI, NDJSON parse and convert, SRT/WebVTT subtitles |
-| `@utilix-tech/sdk/generators` | UUID v4/v7, ULID, passwords, strength check, fake data |
+| `@utilix-tech/sdk/generators` | UUID v4/v7, ULID, passwords, strength check, entropy estimator, fake data |
 | `@utilix-tech/sdk/time` | Date diff, timezone convert, cron parse, relative time |
 | `@utilix-tech/sdk/units` | Bytes, CSS px/rem, number bases, currency format, credit card/IBAN/barcode/ISBN validation, loan calculator, compound/simple interest calculators, VAT/sales tax calculator, tip/bill split calculator, break-even point calculator, Rule of 72 calculator |
 | `@utilix-tech/sdk/network` | HTTP status codes, IP validation, country flags, geolocation URLs, HAR file parsing, User-Agent parsing, IPv6 address compress/expand |

package/dist/{chunk-2CJSLYWI.js → chunk-3TYWIX3B.js}

@@ -12,6 +12,7 @@ __export(generators_exports, {
   SYMBOL_CHARS: () => SYMBOL_CHARS,
   ULID_REGEX: () => ULID_REGEX,
   checkStrength: () => checkStrength,
+  estimatePasswordEntropy: () => estimatePasswordEntropy,
   generateBulk: () => generateBulk,
   generateBulkPasswords: () => generateBulkPasswords,
   generateBulkUlids: () => generateBulkUlids,
@@ -228,6 +229,111 @@ function checkStrength(password) {
     color: levels[score].color
   };
 }
+var _SYMBOL_POOL_CHARS = " !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
+var _SYMBOL_POOL_SET = new Set(_SYMBOL_POOL_CHARS.split(""));
+function _hasSymbolChar(password) {
+  for (const ch of password) {
+    if (_SYMBOL_POOL_SET.has(ch)) return true;
+  }
+  return false;
+}
+function _hasSequentialRun(password, minRun) {
+  let ascRun = 1;
+  let descRun = 1;
+  for (let i = 1; i < password.length; i++) {
+    const prev = password.charCodeAt(i - 1);
+    const curr = password.charCodeAt(i);
+    if (curr === prev + 1) {
+      ascRun++;
+      descRun = 1;
+    } else if (curr === prev - 1) {
+      descRun++;
+      ascRun = 1;
+    } else {
+      ascRun = 1;
+      descRun = 1;
+    }
+    if (ascRun >= minRun || descRun >= minRun) return true;
+  }
+  return false;
+}
+function _formatCrackDuration(seconds) {
+  if (!isFinite(seconds)) return "effectively never";
+  if (seconds < 1) return "instantly";
+  const units = [
+    ["century", 315576e4],
+    ["year", 31557600],
+    ["month", 2629800],
+    ["day", 86400],
+    ["hour", 3600],
+    ["minute", 60],
+    ["second", 1]
+  ];
+  for (const [name, unitSeconds] of units) {
+    if (seconds >= unitSeconds) {
+      const value = seconds / unitSeconds;
+      if (name === "century" && value > 1e3) return "longer than the age of the universe";
+      const rounded = value >= 100 ? Math.round(value) : Math.round(value * 10) / 10;
+      const plural = name === "century" ? "centuries" : `${name}s`;
+      return `${rounded} ${rounded === 1 ? name : plural}`;
+    }
+  }
+  return "instantly";
+}
+function estimatePasswordEntropy(password) {
+  if (!password) return { error: "Password is required" };
+  const hasLowercase = /[a-z]/.test(password);
+  const hasUppercase = /[A-Z]/.test(password);
+  const hasDigits = /[0-9]/.test(password);
+  const hasSymbols = _hasSymbolChar(password);
+  const hasOther = /[^\x20-\x7e]/.test(password);
+  let poolSize = 0;
+  if (hasLowercase) poolSize += 26;
+  if (hasUppercase) poolSize += 26;
+  if (hasDigits) poolSize += 10;
+  if (hasSymbols) poolSize += _SYMBOL_POOL_CHARS.length;
+  if (hasOther) poolSize += 100;
+  const entropyBits = Math.round(password.length * Math.log2(poolSize) * 100) / 100;
+  let strength;
+  if (entropyBits < 28) strength = "very-weak";
+  else if (entropyBits < 36) strength = "weak";
+  else if (entropyBits < 60) strength = "fair";
+  else if (entropyBits < 128) strength = "strong";
+  else strength = "very-strong";
+  const averageGuesses = Math.pow(2, entropyBits) / 2;
+  const scenarios = [
+    { scenario: "Online, throttled (100 guesses/hour)", guessesPerSecond: 100 / 3600 },
+    { scenario: "Online, unthrottled (10 guesses/sec)", guessesPerSecond: 10 },
+    { scenario: "Offline, slow hash e.g. bcrypt (10k guesses/sec)", guessesPerSecond: 1e4 },
+    { scenario: "Offline, fast hash / GPU cluster (10B guesses/sec)", guessesPerSecond: 1e10 }
+  ];
+  const crackTimes = scenarios.map((s) => ({
+    scenario: s.scenario,
+    guessesPerSecond: s.guessesPerSecond,
+    humanReadable: _formatCrackDuration(averageGuesses / s.guessesPerSecond)
+  }));
+  const warnings = [];
+  if (password.length < 8) {
+    warnings.push("Shorter than 8 characters \u2014 most sites and cracking tools treat this as trivially weak regardless of entropy.");
+  }
+  if (/(.)\1{2,}/.test(password)) {
+    warnings.push('Contains a repeated character run (e.g. "aaa"), which is easier to guess than the entropy figure implies.');
+  }
+  if (_hasSequentialRun(password, 3)) {
+    warnings.push('Contains a sequential run (e.g. "abc" or "321"), which is easier to guess than the entropy figure implies.');
+  }
+  if (poolSize <= 26) {
+    warnings.push("Uses only one character class \u2014 mixing in uppercase, digits, or symbols raises the character pool and entropy.");
+  }
+  return {
+    length: password.length,
+    charset: { hasLowercase, hasUppercase, hasDigits, hasSymbols, hasOther, poolSize },
+    entropyBits,
+    strength,
+    crackTimes,
+    warnings
+  };
+}
 var DATA_TYPES = [
   { value: "name", label: "Full Name", example: "John Smith" },
   { value: "email", label: "Email Address", example: "john.smith@gmail.com" },
@@ -517,4 +623,4 @@ async function generateQrDataUrl(text, options) {
   });
 }
 
-export { AMBIGUOUS_CHARS, DATA_TYPES, DEFAULT_OPTIONS, DEFAULT_QR_OPTIONS, SYMBOL_CHARS, ULID_REGEX, checkStrength, generateBulk, generateBulkPasswords, generateBulkUlids, generateData, generatePassword, generateQrDataUrl, generateQrSvg, generateSingle, generateUlid, generateUuid, generateV4, generateV7, generators_exports, isValidUlid, isValidUuid, parseUlid, parseUuidVersion };
+export { AMBIGUOUS_CHARS, DATA_TYPES, DEFAULT_OPTIONS, DEFAULT_QR_OPTIONS, SYMBOL_CHARS, ULID_REGEX, checkStrength, estimatePasswordEntropy, generateBulk, generateBulkPasswords, generateBulkUlids, generateData, generatePassword, generateQrDataUrl, generateQrSvg, generateSingle, generateUlid, generateUuid, generateV4, generateV7, generators_exports, isValidUlid, isValidUuid, parseUlid, parseUuidVersion };

package/dist/{chunk-WO3LJMVV.js → chunk-WVEKRKGU.js}

@@ -15,6 +15,7 @@ __export(json_exports, {
   inferGoType: () => inferGoType,
   inferPythonType: () => inferPythonType,
   inferType: () => inferType,
+  jsonSchemaToTypescript: () => jsonSchemaToTypescript,
   jsonToCsv: () => jsonToCsv,
   jsonToGo: () => jsonToGo,
   jsonToPython: () => jsonToPython,
@@ -1302,5 +1303,104 @@ function resolveJsonPointer(json, pointer) {
   }
   return { pointer, found: true, value: current, tokens };
 }
+function _schemaRefName(ref) {
+  const parts = ref.split("/");
+  return _capitalize(parts[parts.length - 1] || "Ref");
+}
+function _schemaLiteralType(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value === null) return "null";
+  return JSON.stringify(value);
+}
+function _safePropertyKey(key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+function _schemaToTsType(schema, name, interfaces) {
+  if (schema.$ref) return _schemaRefName(schema.$ref);
+  if (schema.const !== void 0) return _schemaLiteralType(schema.const);
+  if (schema.enum) return schema.enum.map(_schemaLiteralType).join(" | ");
+  if (schema.oneOf) return schema.oneOf.map((s, i) => _schemaToTsType(s, `${name}Variant${i}`, interfaces)).join(" | ");
+  if (schema.anyOf) return schema.anyOf.map((s, i) => _schemaToTsType(s, `${name}Variant${i}`, interfaces)).join(" | ");
+  if (schema.allOf) return schema.allOf.map((s, i) => _schemaToTsType(s, `${name}Part${i}`, interfaces)).join(" & ");
+  const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+  const nullable = types.includes("null");
+  const nonNullTypes = types.filter((t) => t !== "null");
+  const primaryType = nonNullTypes[0] ?? (schema.properties || schema.additionalProperties !== void 0 ? "object" : void 0);
+  let result;
+  switch (primaryType) {
+    case "string":
+      result = "string";
+      break;
+    case "number":
+    case "integer":
+      result = "number";
+      break;
+    case "boolean":
+      result = "boolean";
+      break;
+    case "array": {
+      const itemsSchema = Array.isArray(schema.items) ? schema.items[0] : schema.items;
+      const itemType = itemsSchema ? _schemaToTsType(itemsSchema, `${name}Item`, interfaces) : "unknown";
+      result = `${itemType}[]`;
+      break;
+    }
+    case "object": {
+      _buildSchemaInterface(schema, name, interfaces);
+      result = name;
+      break;
+    }
+    default:
+      result = "unknown";
+  }
+  return nullable ? `${result} | null` : result;
+}
+function _buildSchemaInterface(schema, name, interfaces) {
+  if (interfaces.has(name)) return;
+  const required = new Set(schema.required ?? []);
+  const lines = [`interface ${name} {`];
+  for (const [key, propSchema] of Object.entries(schema.properties ?? {})) {
+    if (propSchema.description) lines.push(`  /** ${propSchema.description} */`);
+    const optional = required.has(key) ? "" : "?";
+    const propType = _schemaToTsType(propSchema, _capitalize(key), interfaces);
+    lines.push(`  ${_safePropertyKey(key)}${optional}: ${propType};`);
+  }
+  if (schema.additionalProperties === true) {
+    lines.push("  [key: string]: unknown;");
+  } else if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    const addType = _schemaToTsType(schema.additionalProperties, `${name}Value`, interfaces);
+    lines.push(`  [key: string]: ${addType};`);
+  }
+  lines.push("}");
+  interfaces.set(name, lines.join("\n"));
+}
+function jsonSchemaToTypescript(schemaJson, options) {
+  let schema;
+  try {
+    schema = JSON.parse(schemaJson);
+  } catch {
+    return { error: "Invalid JSON input" };
+  }
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+    return { error: "Schema must be a JSON object" };
+  }
+  const rootName = options?.rootName ?? "Root";
+  const typedSchema = schema;
+  const interfaces = /* @__PURE__ */ new Map();
+  const defs = { ...typedSchema.$defs ?? {}, ...typedSchema.definitions ?? {} };
+  for (const [defName, defSchema] of Object.entries(defs)) {
+    const defTypeName = _capitalize(defName);
+    const defType = _schemaToTsType(defSchema, defTypeName, interfaces);
+    if (!interfaces.has(defTypeName)) {
+      interfaces.set(defTypeName, `type ${defTypeName} = ${defType};`);
+    }
+  }
+  const rootType = _schemaToTsType(typedSchema, rootName, interfaces);
+  const parts = [...interfaces.values()];
+  if (!interfaces.has(rootName)) {
+    parts.push(`type ${rootName} = ${rootType};`);
+  }
+  return parts.join("\n\n");
+}
 
-export { csvToJson, detectFormat, diffJson, evaluateJsonPath, formatDiffLine, formatJson, generateExample, getJsonStats, inferGoType, inferPythonType, inferType, jsonToCsv, jsonToGo, jsonToPython, jsonToTypescript, jsonToYaml, jsonToZod, json_exports, minifyJson, parseJson, parseStructs, resolveJsonPointer, toPascalCase, toSnakeCase, validateJson, validateJsonPath, validateJsonString, yamlToJson };
+export { csvToJson, detectFormat, diffJson, evaluateJsonPath, formatDiffLine, formatJson, generateExample, getJsonStats, inferGoType, inferPythonType, inferType, jsonSchemaToTypescript, jsonToCsv, jsonToGo, jsonToPython, jsonToTypescript, jsonToYaml, jsonToZod, json_exports, minifyJson, parseJson, parseStructs, resolveJsonPointer, toPascalCase, toSnakeCase, validateJson, validateJsonPath, validateJsonString, yamlToJson };

package/dist/{generators-BGtRGpJZ.d.cts → generators-Du8cBesn.d.cts}

@@ -7,6 +7,7 @@
  *  - uuid-generator  : generateV4, generateV7, generateUuid, generateBulk, isValidUuid, parseUuidVersion
  *  - ulid-generator  : generateUlid, generateBulkUlids, parseUlid, isValidUlid
  *  - password-generator : generatePassword, generateBulkPasswords, checkStrength
+ *  - password-entropy-estimator : estimatePasswordEntropy
  *  - random-data     : generateSingle, generateData
  *  - qr-code         : generateQrSvg, generateQrDataUrl
  */
@@ -50,6 +51,43 @@ declare function checkStrength(password: string): {
     label: 'Very Weak' | 'Weak' | 'Fair' | 'Strong' | 'Very Strong';
     color: string;
 };
+interface PasswordCharsetInfo {
+    hasLowercase: boolean;
+    hasUppercase: boolean;
+    hasDigits: boolean;
+    hasSymbols: boolean;
+    hasOther: boolean;
+    poolSize: number;
+}
+interface PasswordCrackTimeEstimate {
+    scenario: string;
+    guessesPerSecond: number;
+    humanReadable: string;
+}
+type PasswordEntropyStrength = 'very-weak' | 'weak' | 'fair' | 'strong' | 'very-strong';
+interface PasswordEntropyResult {
+    length: number;
+    charset: PasswordCharsetInfo;
+    entropyBits: number;
+    strength: PasswordEntropyStrength;
+    crackTimes: PasswordCrackTimeEstimate[];
+    warnings: string[];
+}
+/**
+ * Estimate a password's entropy in bits from the character classes it
+ * actually draws from (lowercase, uppercase, digits, symbols, other/Unicode),
+ * then derive a strength label and crack-time estimates at a few realistic
+ * guess rates. This is the classic pool-size x length method, the same
+ * approach used by most public entropy calculators: it measures resistance
+ * to brute force over the theoretical character space, not real-world
+ * guessability against a breach-database or dictionary attack — a common
+ * word with substitutions can score high here while being easy to guess in
+ * practice, which is why the pattern-based warnings below exist alongside
+ * the raw entropy figure rather than folded into it.
+ */
+declare function estimatePasswordEntropy(password: string): PasswordEntropyResult | {
+    error: string;
+};
 type DataType = 'name' | 'email' | 'uuid' | 'phone' | 'date' | 'number' | 'boolean' | 'color' | 'url' | 'ipv4' | 'sentence' | 'paragraph';
 interface RandomConfig {
     type: DataType;
@@ -86,6 +124,10 @@ declare const generators_DEFAULT_OPTIONS: typeof DEFAULT_OPTIONS;
 declare const generators_DEFAULT_QR_OPTIONS: typeof DEFAULT_QR_OPTIONS;
 type generators_DataType = DataType;
 type generators_GeneratedUuid = GeneratedUuid;
+type generators_PasswordCharsetInfo = PasswordCharsetInfo;
+type generators_PasswordCrackTimeEstimate = PasswordCrackTimeEstimate;
+type generators_PasswordEntropyResult = PasswordEntropyResult;
+type generators_PasswordEntropyStrength = PasswordEntropyStrength;
 type generators_PasswordOptions = PasswordOptions;
 type generators_QrErrorLevel = QrErrorLevel;
 type generators_QrOptions = QrOptions;
@@ -95,6 +137,7 @@ declare const generators_SYMBOL_CHARS: typeof SYMBOL_CHARS;
 declare const generators_ULID_REGEX: typeof ULID_REGEX;
 type generators_UuidVersion = UuidVersion;
 declare const generators_checkStrength: typeof checkStrength;
+declare const generators_estimatePasswordEntropy: typeof estimatePasswordEntropy;
 declare const generators_generateBulk: typeof generateBulk;
 declare const generators_generateBulkPasswords: typeof generateBulkPasswords;
 declare const generators_generateBulkUlids: typeof generateBulkUlids;
@@ -112,7 +155,7 @@ declare const generators_isValidUuid: typeof isValidUuid;
 declare const generators_parseUlid: typeof parseUlid;
 declare const generators_parseUuidVersion: typeof parseUuidVersion;
 declare namespace generators {
-  export { generators_AMBIGUOUS_CHARS as AMBIGUOUS_CHARS, generators_DATA_TYPES as DATA_TYPES, generators_DEFAULT_OPTIONS as DEFAULT_OPTIONS, generators_DEFAULT_QR_OPTIONS as DEFAULT_QR_OPTIONS, type generators_DataType as DataType, type generators_GeneratedUuid as GeneratedUuid, type generators_PasswordOptions as PasswordOptions, type generators_QrErrorLevel as QrErrorLevel, type generators_QrOptions as QrOptions, type generators_QrOutputFormat as QrOutputFormat, type generators_RandomConfig as RandomConfig, generators_SYMBOL_CHARS as SYMBOL_CHARS, generators_ULID_REGEX as ULID_REGEX, type generators_UuidVersion as UuidVersion, generators_checkStrength as checkStrength, generators_generateBulk as generateBulk, generators_generateBulkPasswords as generateBulkPasswords, generators_generateBulkUlids as generateBulkUlids, generators_generateData as generateData, generators_generatePassword as generatePassword, generators_generateQrDataUrl as generateQrDataUrl, generators_generateQrSvg as generateQrSvg, generators_generateSingle as generateSingle, generators_generateUlid as generateUlid, generators_generateUuid as generateUuid, generators_generateV4 as generateV4, generators_generateV7 as generateV7, generators_isValidUlid as isValidUlid, generators_isValidUuid as isValidUuid, generators_parseUlid as parseUlid, generators_parseUuidVersion as parseUuidVersion };
+  export { generators_AMBIGUOUS_CHARS as AMBIGUOUS_CHARS, generators_DATA_TYPES as DATA_TYPES, generators_DEFAULT_OPTIONS as DEFAULT_OPTIONS, generators_DEFAULT_QR_OPTIONS as DEFAULT_QR_OPTIONS, type generators_DataType as DataType, type generators_GeneratedUuid as GeneratedUuid, type generators_PasswordCharsetInfo as PasswordCharsetInfo, type generators_PasswordCrackTimeEstimate as PasswordCrackTimeEstimate, type generators_PasswordEntropyResult as PasswordEntropyResult, type generators_PasswordEntropyStrength as PasswordEntropyStrength, type generators_PasswordOptions as PasswordOptions, type generators_QrErrorLevel as QrErrorLevel, type generators_QrOptions as QrOptions, type generators_QrOutputFormat as QrOutputFormat, type generators_RandomConfig as RandomConfig, generators_SYMBOL_CHARS as SYMBOL_CHARS, generators_ULID_REGEX as ULID_REGEX, type generators_UuidVersion as UuidVersion, generators_checkStrength as checkStrength, generators_estimatePasswordEntropy as estimatePasswordEntropy, generators_generateBulk as generateBulk, generators_generateBulkPasswords as generateBulkPasswords, generators_generateBulkUlids as generateBulkUlids, generators_generateData as generateData, generators_generatePassword as generatePassword, generators_generateQrDataUrl as generateQrDataUrl, generators_generateQrSvg as generateQrSvg, generators_generateSingle as generateSingle, generators_generateUlid as generateUlid, generators_generateUuid as generateUuid, generators_generateV4 as generateV4, generators_generateV7 as generateV7, generators_isValidUlid as isValidUlid, generators_isValidUuid as isValidUuid, generators_parseUlid as parseUlid, generators_parseUuidVersion as parseUuidVersion };
 }
 
-export { AMBIGUOUS_CHARS as A, DATA_TYPES as D, type GeneratedUuid as G, type PasswordOptions as P, type QrErrorLevel as Q, type RandomConfig as R, SYMBOL_CHARS as S, ULID_REGEX as U, DEFAULT_OPTIONS as a, DEFAULT_QR_OPTIONS as b, type DataType as c, type QrOptions as d, type QrOutputFormat as e, type UuidVersion as f, generators as g, checkStrength as h, generateBulk as i, generateBulkPasswords as j, generateBulkUlids as k, generateData as l, generatePassword as m, generateQrDataUrl as n, generateQrSvg as o, generateSingle as p, generateUlid as q, generateUuid as r, generateV4 as s, generateV7 as t, isValidUlid as u, isValidUuid as v, parseUlid as w, parseUuidVersion as x };
+export { AMBIGUOUS_CHARS as A, isValidUuid as B, parseUlid as C, DATA_TYPES as D, parseUuidVersion as E, type GeneratedUuid as G, type PasswordCharsetInfo as P, type QrErrorLevel as Q, type RandomConfig as R, SYMBOL_CHARS as S, ULID_REGEX as U, DEFAULT_OPTIONS as a, DEFAULT_QR_OPTIONS as b, type DataType as c, type PasswordCrackTimeEstimate as d, type PasswordEntropyResult as e, type PasswordEntropyStrength as f, generators as g, type PasswordOptions as h, type QrOptions as i, type QrOutputFormat as j, type UuidVersion as k, checkStrength as l, estimatePasswordEntropy as m, generateBulk as n, generateBulkPasswords as o, generateBulkUlids as p, generateData as q, generatePassword as r, generateQrDataUrl as s, generateQrSvg as t, generateSingle as u, generateUlid as v, generateUuid as w, generateV4 as x, generateV7 as y, isValidUlid as z };

package/dist/{generators-BGtRGpJZ.d.ts → generators-Du8cBesn.d.ts}

@@ -7,6 +7,7 @@
  *  - uuid-generator  : generateV4, generateV7, generateUuid, generateBulk, isValidUuid, parseUuidVersion
  *  - ulid-generator  : generateUlid, generateBulkUlids, parseUlid, isValidUlid
  *  - password-generator : generatePassword, generateBulkPasswords, checkStrength
+ *  - password-entropy-estimator : estimatePasswordEntropy
  *  - random-data     : generateSingle, generateData
  *  - qr-code         : generateQrSvg, generateQrDataUrl
  */
@@ -50,6 +51,43 @@ declare function checkStrength(password: string): {
     label: 'Very Weak' | 'Weak' | 'Fair' | 'Strong' | 'Very Strong';
     color: string;
 };
+interface PasswordCharsetInfo {
+    hasLowercase: boolean;
+    hasUppercase: boolean;
+    hasDigits: boolean;
+    hasSymbols: boolean;
+    hasOther: boolean;
+    poolSize: number;
+}
+interface PasswordCrackTimeEstimate {
+    scenario: string;
+    guessesPerSecond: number;
+    humanReadable: string;
+}
+type PasswordEntropyStrength = 'very-weak' | 'weak' | 'fair' | 'strong' | 'very-strong';
+interface PasswordEntropyResult {
+    length: number;
+    charset: PasswordCharsetInfo;
+    entropyBits: number;
+    strength: PasswordEntropyStrength;
+    crackTimes: PasswordCrackTimeEstimate[];
+    warnings: string[];
+}
+/**
+ * Estimate a password's entropy in bits from the character classes it
+ * actually draws from (lowercase, uppercase, digits, symbols, other/Unicode),
+ * then derive a strength label and crack-time estimates at a few realistic
+ * guess rates. This is the classic pool-size x length method, the same
+ * approach used by most public entropy calculators: it measures resistance
+ * to brute force over the theoretical character space, not real-world
+ * guessability against a breach-database or dictionary attack — a common
+ * word with substitutions can score high here while being easy to guess in
+ * practice, which is why the pattern-based warnings below exist alongside
+ * the raw entropy figure rather than folded into it.
+ */
+declare function estimatePasswordEntropy(password: string): PasswordEntropyResult | {
+    error: string;
+};
 type DataType = 'name' | 'email' | 'uuid' | 'phone' | 'date' | 'number' | 'boolean' | 'color' | 'url' | 'ipv4' | 'sentence' | 'paragraph';
 interface RandomConfig {
     type: DataType;
@@ -86,6 +124,10 @@ declare const generators_DEFAULT_OPTIONS: typeof DEFAULT_OPTIONS;
 declare const generators_DEFAULT_QR_OPTIONS: typeof DEFAULT_QR_OPTIONS;
 type generators_DataType = DataType;
 type generators_GeneratedUuid = GeneratedUuid;
+type generators_PasswordCharsetInfo = PasswordCharsetInfo;
+type generators_PasswordCrackTimeEstimate = PasswordCrackTimeEstimate;
+type generators_PasswordEntropyResult = PasswordEntropyResult;
+type generators_PasswordEntropyStrength = PasswordEntropyStrength;
 type generators_PasswordOptions = PasswordOptions;
 type generators_QrErrorLevel = QrErrorLevel;
 type generators_QrOptions = QrOptions;
@@ -95,6 +137,7 @@ declare const generators_SYMBOL_CHARS: typeof SYMBOL_CHARS;
 declare const generators_ULID_REGEX: typeof ULID_REGEX;
 type generators_UuidVersion = UuidVersion;
 declare const generators_checkStrength: typeof checkStrength;
+declare const generators_estimatePasswordEntropy: typeof estimatePasswordEntropy;
 declare const generators_generateBulk: typeof generateBulk;
 declare const generators_generateBulkPasswords: typeof generateBulkPasswords;
 declare const generators_generateBulkUlids: typeof generateBulkUlids;
@@ -112,7 +155,7 @@ declare const generators_isValidUuid: typeof isValidUuid;
 declare const generators_parseUlid: typeof parseUlid;
 declare const generators_parseUuidVersion: typeof parseUuidVersion;
 declare namespace generators {
-  export { generators_AMBIGUOUS_CHARS as AMBIGUOUS_CHARS, generators_DATA_TYPES as DATA_TYPES, generators_DEFAULT_OPTIONS as DEFAULT_OPTIONS, generators_DEFAULT_QR_OPTIONS as DEFAULT_QR_OPTIONS, type generators_DataType as DataType, type generators_GeneratedUuid as GeneratedUuid, type generators_PasswordOptions as PasswordOptions, type generators_QrErrorLevel as QrErrorLevel, type generators_QrOptions as QrOptions, type generators_QrOutputFormat as QrOutputFormat, type generators_RandomConfig as RandomConfig, generators_SYMBOL_CHARS as SYMBOL_CHARS, generators_ULID_REGEX as ULID_REGEX, type generators_UuidVersion as UuidVersion, generators_checkStrength as checkStrength, generators_generateBulk as generateBulk, generators_generateBulkPasswords as generateBulkPasswords, generators_generateBulkUlids as generateBulkUlids, generators_generateData as generateData, generators_generatePassword as generatePassword, generators_generateQrDataUrl as generateQrDataUrl, generators_generateQrSvg as generateQrSvg, generators_generateSingle as generateSingle, generators_generateUlid as generateUlid, generators_generateUuid as generateUuid, generators_generateV4 as generateV4, generators_generateV7 as generateV7, generators_isValidUlid as isValidUlid, generators_isValidUuid as isValidUuid, generators_parseUlid as parseUlid, generators_parseUuidVersion as parseUuidVersion };
+  export { generators_AMBIGUOUS_CHARS as AMBIGUOUS_CHARS, generators_DATA_TYPES as DATA_TYPES, generators_DEFAULT_OPTIONS as DEFAULT_OPTIONS, generators_DEFAULT_QR_OPTIONS as DEFAULT_QR_OPTIONS, type generators_DataType as DataType, type generators_GeneratedUuid as GeneratedUuid, type generators_PasswordCharsetInfo as PasswordCharsetInfo, type generators_PasswordCrackTimeEstimate as PasswordCrackTimeEstimate, type generators_PasswordEntropyResult as PasswordEntropyResult, type generators_PasswordEntropyStrength as PasswordEntropyStrength, type generators_PasswordOptions as PasswordOptions, type generators_QrErrorLevel as QrErrorLevel, type generators_QrOptions as QrOptions, type generators_QrOutputFormat as QrOutputFormat, type generators_RandomConfig as RandomConfig, generators_SYMBOL_CHARS as SYMBOL_CHARS, generators_ULID_REGEX as ULID_REGEX, type generators_UuidVersion as UuidVersion, generators_checkStrength as checkStrength, generators_estimatePasswordEntropy as estimatePasswordEntropy, generators_generateBulk as generateBulk, generators_generateBulkPasswords as generateBulkPasswords, generators_generateBulkUlids as generateBulkUlids, generators_generateData as generateData, generators_generatePassword as generatePassword, generators_generateQrDataUrl as generateQrDataUrl, generators_generateQrSvg as generateQrSvg, generators_generateSingle as generateSingle, generators_generateUlid as generateUlid, generators_generateUuid as generateUuid, generators_generateV4 as generateV4, generators_generateV7 as generateV7, generators_isValidUlid as isValidUlid, generators_isValidUuid as isValidUuid, generators_parseUlid as parseUlid, generators_parseUuidVersion as parseUuidVersion };
 }
 
-export { AMBIGUOUS_CHARS as A, DATA_TYPES as D, type GeneratedUuid as G, type PasswordOptions as P, type QrErrorLevel as Q, type RandomConfig as R, SYMBOL_CHARS as S, ULID_REGEX as U, DEFAULT_OPTIONS as a, DEFAULT_QR_OPTIONS as b, type DataType as c, type QrOptions as d, type QrOutputFormat as e, type UuidVersion as f, generators as g, checkStrength as h, generateBulk as i, generateBulkPasswords as j, generateBulkUlids as k, generateData as l, generatePassword as m, generateQrDataUrl as n, generateQrSvg as o, generateSingle as p, generateUlid as q, generateUuid as r, generateV4 as s, generateV7 as t, isValidUlid as u, isValidUuid as v, parseUlid as w, parseUuidVersion as x };
+export { AMBIGUOUS_CHARS as A, isValidUuid as B, parseUlid as C, DATA_TYPES as D, parseUuidVersion as E, type GeneratedUuid as G, type PasswordCharsetInfo as P, type QrErrorLevel as Q, type RandomConfig as R, SYMBOL_CHARS as S, ULID_REGEX as U, DEFAULT_OPTIONS as a, DEFAULT_QR_OPTIONS as b, type DataType as c, type PasswordCrackTimeEstimate as d, type PasswordEntropyResult as e, type PasswordEntropyStrength as f, generators as g, type PasswordOptions as h, type QrOptions as i, type QrOutputFormat as j, type UuidVersion as k, checkStrength as l, estimatePasswordEntropy as m, generateBulk as n, generateBulkPasswords as o, generateBulkUlids as p, generateData as q, generatePassword as r, generateQrDataUrl as s, generateQrSvg as t, generateSingle as u, generateUlid as v, generateUuid as w, generateV4 as x, generateV7 as y, isValidUlid as z };

package/dist/index.cjs

@@ -53,6 +53,7 @@ __export(json_exports, {
   inferGoType: () => inferGoType,
   inferPythonType: () => inferPythonType,
   inferType: () => inferType,
+  jsonSchemaToTypescript: () => jsonSchemaToTypescript,
   jsonToCsv: () => jsonToCsv,
   jsonToGo: () => jsonToGo,
   jsonToPython: () => jsonToPython,
@@ -1340,6 +1341,105 @@ function resolveJsonPointer(json, pointer) {
   }
   return { pointer, found: true, value: current, tokens };
 }
+function _schemaRefName(ref) {
+  const parts = ref.split("/");
+  return _capitalize(parts[parts.length - 1] || "Ref");
+}
+function _schemaLiteralType(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value === null) return "null";
+  return JSON.stringify(value);
+}
+function _safePropertyKey(key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+function _schemaToTsType(schema, name, interfaces) {
+  if (schema.$ref) return _schemaRefName(schema.$ref);
+  if (schema.const !== void 0) return _schemaLiteralType(schema.const);
+  if (schema.enum) return schema.enum.map(_schemaLiteralType).join(" | ");
+  if (schema.oneOf) return schema.oneOf.map((s, i) => _schemaToTsType(s, `${name}Variant${i}`, interfaces)).join(" | ");
+  if (schema.anyOf) return schema.anyOf.map((s, i) => _schemaToTsType(s, `${name}Variant${i}`, interfaces)).join(" | ");
+  if (schema.allOf) return schema.allOf.map((s, i) => _schemaToTsType(s, `${name}Part${i}`, interfaces)).join(" & ");
+  const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+  const nullable = types.includes("null");
+  const nonNullTypes = types.filter((t) => t !== "null");
+  const primaryType = nonNullTypes[0] ?? (schema.properties || schema.additionalProperties !== void 0 ? "object" : void 0);
+  let result;
+  switch (primaryType) {
+    case "string":
+      result = "string";
+      break;
+    case "number":
+    case "integer":
+      result = "number";
+      break;
+    case "boolean":
+      result = "boolean";
+      break;
+    case "array": {
+      const itemsSchema = Array.isArray(schema.items) ? schema.items[0] : schema.items;
+      const itemType = itemsSchema ? _schemaToTsType(itemsSchema, `${name}Item`, interfaces) : "unknown";
+      result = `${itemType}[]`;
+      break;
+    }
+    case "object": {
+      _buildSchemaInterface(schema, name, interfaces);
+      result = name;
+      break;
+    }
+    default:
+      result = "unknown";
+  }
+  return nullable ? `${result} | null` : result;
+}
+function _buildSchemaInterface(schema, name, interfaces) {
+  if (interfaces.has(name)) return;
+  const required = new Set(schema.required ?? []);
+  const lines = [`interface ${name} {`];
+  for (const [key, propSchema] of Object.entries(schema.properties ?? {})) {
+    if (propSchema.description) lines.push(`  /** ${propSchema.description} */`);
+    const optional = required.has(key) ? "" : "?";
+    const propType = _schemaToTsType(propSchema, _capitalize(key), interfaces);
+    lines.push(`  ${_safePropertyKey(key)}${optional}: ${propType};`);
+  }
+  if (schema.additionalProperties === true) {
+    lines.push("  [key: string]: unknown;");
+  } else if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    const addType = _schemaToTsType(schema.additionalProperties, `${name}Value`, interfaces);
+    lines.push(`  [key: string]: ${addType};`);
+  }
+  lines.push("}");
+  interfaces.set(name, lines.join("\n"));
+}
+function jsonSchemaToTypescript(schemaJson, options) {
+  let schema;
+  try {
+    schema = JSON.parse(schemaJson);
+  } catch {
+    return { error: "Invalid JSON input" };
+  }
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+    return { error: "Schema must be a JSON object" };
+  }
+  const rootName = options?.rootName ?? "Root";
+  const typedSchema = schema;
+  const interfaces = /* @__PURE__ */ new Map();
+  const defs = { ...typedSchema.$defs ?? {}, ...typedSchema.definitions ?? {} };
+  for (const [defName, defSchema] of Object.entries(defs)) {
+    const defTypeName = _capitalize(defName);
+    const defType = _schemaToTsType(defSchema, defTypeName, interfaces);
+    if (!interfaces.has(defTypeName)) {
+      interfaces.set(defTypeName, `type ${defTypeName} = ${defType};`);
+    }
+  }
+  const rootType = _schemaToTsType(typedSchema, rootName, interfaces);
+  const parts = [...interfaces.values()];
+  if (!interfaces.has(rootName)) {
+    parts.push(`type ${rootName} = ${rootType};`);
+  }
+  return parts.join("\n\n");
+}
 
 // src/tools/encoding.ts
 var encoding_exports = {};
@@ -5849,6 +5949,7 @@ __export(generators_exports, {
   SYMBOL_CHARS: () => SYMBOL_CHARS,
   ULID_REGEX: () => ULID_REGEX,
   checkStrength: () => checkStrength,
+  estimatePasswordEntropy: () => estimatePasswordEntropy,
   generateBulk: () => generateBulk,
   generateBulkPasswords: () => generateBulkPasswords,
   generateBulkUlids: () => generateBulkUlids,
@@ -6065,6 +6166,111 @@ function checkStrength(password) {
     color: levels[score].color
   };
 }
+var _SYMBOL_POOL_CHARS = " !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
+var _SYMBOL_POOL_SET = new Set(_SYMBOL_POOL_CHARS.split(""));
+function _hasSymbolChar(password) {
+  for (const ch of password) {
+    if (_SYMBOL_POOL_SET.has(ch)) return true;
+  }
+  return false;
+}
+function _hasSequentialRun(password, minRun) {
+  let ascRun = 1;
+  let descRun = 1;
+  for (let i = 1; i < password.length; i++) {
+    const prev = password.charCodeAt(i - 1);
+    const curr = password.charCodeAt(i);
+    if (curr === prev + 1) {
+      ascRun++;
+      descRun = 1;
+    } else if (curr === prev - 1) {
+      descRun++;
+      ascRun = 1;
+    } else {
+      ascRun = 1;
+      descRun = 1;
+    }
+    if (ascRun >= minRun || descRun >= minRun) return true;
+  }
+  return false;
+}
+function _formatCrackDuration(seconds) {
+  if (!isFinite(seconds)) return "effectively never";
+  if (seconds < 1) return "instantly";
+  const units = [
+    ["century", 315576e4],
+    ["year", 31557600],
+    ["month", 2629800],
+    ["day", 86400],
+    ["hour", 3600],
+    ["minute", 60],
+    ["second", 1]
+  ];
+  for (const [name, unitSeconds] of units) {
+    if (seconds >= unitSeconds) {
+      const value = seconds / unitSeconds;
+      if (name === "century" && value > 1e3) return "longer than the age of the universe";
+      const rounded = value >= 100 ? Math.round(value) : Math.round(value * 10) / 10;
+      const plural = name === "century" ? "centuries" : `${name}s`;
+      return `${rounded} ${rounded === 1 ? name : plural}`;
+    }
+  }
+  return "instantly";
+}
+function estimatePasswordEntropy(password) {
+  if (!password) return { error: "Password is required" };
+  const hasLowercase = /[a-z]/.test(password);
+  const hasUppercase = /[A-Z]/.test(password);
+  const hasDigits = /[0-9]/.test(password);
+  const hasSymbols = _hasSymbolChar(password);
+  const hasOther = /[^\x20-\x7e]/.test(password);
+  let poolSize = 0;
+  if (hasLowercase) poolSize += 26;
+  if (hasUppercase) poolSize += 26;
+  if (hasDigits) poolSize += 10;
+  if (hasSymbols) poolSize += _SYMBOL_POOL_CHARS.length;
+  if (hasOther) poolSize += 100;
+  const entropyBits = Math.round(password.length * Math.log2(poolSize) * 100) / 100;
+  let strength;
+  if (entropyBits < 28) strength = "very-weak";
+  else if (entropyBits < 36) strength = "weak";
+  else if (entropyBits < 60) strength = "fair";
+  else if (entropyBits < 128) strength = "strong";
+  else strength = "very-strong";
+  const averageGuesses = Math.pow(2, entropyBits) / 2;
+  const scenarios = [
+    { scenario: "Online, throttled (100 guesses/hour)", guessesPerSecond: 100 / 3600 },
+    { scenario: "Online, unthrottled (10 guesses/sec)", guessesPerSecond: 10 },
+    { scenario: "Offline, slow hash e.g. bcrypt (10k guesses/sec)", guessesPerSecond: 1e4 },
+    { scenario: "Offline, fast hash / GPU cluster (10B guesses/sec)", guessesPerSecond: 1e10 }
+  ];
+  const crackTimes = scenarios.map((s) => ({
+    scenario: s.scenario,
+    guessesPerSecond: s.guessesPerSecond,
+    humanReadable: _formatCrackDuration(averageGuesses / s.guessesPerSecond)
+  }));
+  const warnings = [];
+  if (password.length < 8) {
+    warnings.push("Shorter than 8 characters \u2014 most sites and cracking tools treat this as trivially weak regardless of entropy.");
+  }
+  if (/(.)\1{2,}/.test(password)) {
+    warnings.push('Contains a repeated character run (e.g. "aaa"), which is easier to guess than the entropy figure implies.');
+  }
+  if (_hasSequentialRun(password, 3)) {
+    warnings.push('Contains a sequential run (e.g. "abc" or "321"), which is easier to guess than the entropy figure implies.');
+  }
+  if (poolSize <= 26) {
+    warnings.push("Uses only one character class \u2014 mixing in uppercase, digits, or symbols raises the character pool and entropy.");
+  }
+  return {
+    length: password.length,
+    charset: { hasLowercase, hasUppercase, hasDigits, hasSymbols, hasOther, poolSize },
+    entropyBits,
+    strength,
+    crackTimes,
+    warnings
+  };
+}
 var DATA_TYPES = [
   { value: "name", label: "Full Name", example: "John Smith" },
   { value: "email", label: "Email Address", example: "john.smith@gmail.com" },

package/dist/index.d.cts

@@ -1,9 +1,9 @@
-export { j as json } from './json-DEVFIpsC.cjs';
+export { j as json } from './json-Ta9JykSB.cjs';
 export { e as encoding } from './encoding-Dk3wpmb3.cjs';
 export { h as hashing } from './hashing-CnetQFD_.cjs';
 export { t as text } from './text-D1fySkCB.cjs';
 export { d as data } from './data-XRb0D7Zn.cjs';
-export { g as generators } from './generators-BGtRGpJZ.cjs';
+export { g as generators } from './generators-Du8cBesn.cjs';
 export { t as time } from './time-KqJjdqII.cjs';
 export { u as units } from './units-COt5uI20.cjs';
 export { n as network } from './network-D7Epuerc.cjs';

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-export { j as json } from './json-DEVFIpsC.js';
+export { j as json } from './json-Ta9JykSB.js';
 export { e as encoding } from './encoding-Dk3wpmb3.js';
 export { h as hashing } from './hashing-CnetQFD_.js';
 export { t as text } from './text-D1fySkCB.js';
 export { d as data } from './data-XRb0D7Zn.js';
-export { g as generators } from './generators-BGtRGpJZ.js';
+export { g as generators } from './generators-Du8cBesn.js';
 export { t as time } from './time-KqJjdqII.js';
 export { u as units } from './units-COt5uI20.js';
 export { n as network } from './network-D7Epuerc.js';

package/dist/index.js

@@ -7,12 +7,12 @@ export { color_exports as color } from './chunk-BPVAB4P2.js';
 export { css_exports as css } from './chunk-6YPV2AB5.js';
 export { misc_exports as misc } from './chunk-GX7H6TAX.js';
 export { ai_agent_exports as ai_agent } from './chunk-265NPGKH.js';
-export { json_exports as json } from './chunk-WO3LJMVV.js';
+export { json_exports as json } from './chunk-WVEKRKGU.js';
 export { encoding_exports as encoding } from './chunk-DOWQZUTP.js';
 export { hashing_exports as hashing } from './chunk-GEFVMGZR.js';
 export { text_exports as text } from './chunk-AFEZ6N4A.js';
 export { data_exports as data } from './chunk-66QHV5KW.js';
-export { generators_exports as generators } from './chunk-2CJSLYWI.js';
+export { generators_exports as generators } from './chunk-3TYWIX3B.js';
 export { time_exports as time } from './chunk-IEPWZERQ.js';
 import './chunk-MLKGABMK.js';
 

package/dist/{json-DEVFIpsC.d.ts → json-Ta9JykSB.d.cts}

@@ -13,6 +13,7 @@
  *   - json-to-go       : jsonToGo, parseStructs, toPascalCase, inferGoType
  *   - json-to-python   : jsonToPython, toSnakeCase, inferPythonType
  *   - json-to-zod      : jsonToZod
+ *   - json-schema-to-typescript : jsonSchemaToTypescript
  */
 type ParseStatus = 'idle' | 'valid' | 'error';
 interface JsonParseResult {
@@ -170,6 +171,36 @@ interface JsonPointerResult {
  * traversal, no external calls.
  */
 declare function resolveJsonPointer(json: string, pointer: string): JsonPointerResult;
+interface JsonSchemaLike {
+    type?: string | string[];
+    properties?: Record<string, JsonSchemaLike>;
+    required?: string[];
+    items?: JsonSchemaLike | JsonSchemaLike[];
+    enum?: unknown[];
+    const?: unknown;
+    oneOf?: JsonSchemaLike[];
+    anyOf?: JsonSchemaLike[];
+    allOf?: JsonSchemaLike[];
+    $ref?: string;
+    additionalProperties?: boolean | JsonSchemaLike;
+    description?: string;
+    definitions?: Record<string, JsonSchemaLike>;
+    $defs?: Record<string, JsonSchemaLike>;
+    [key: string]: unknown;
+}
+interface JsonSchemaToTsOptions {
+    rootName?: string;
+}
+/**
+ * Convert a JSON Schema document into TypeScript interfaces/types. Unlike
+ * jsonToTypescript (which infers types from an example data payload), this
+ * reads the schema's declared `type`/`enum`/`required` keywords directly, so
+ * optional vs. required fields and enum/union types come through accurately
+ * instead of being guessed from a single example value.
+ */
+declare function jsonSchemaToTypescript(schemaJson: string, options?: JsonSchemaToTsOptions): string | {
+    error: string;
+};
 
 type json_ConvertOptions = ConvertOptions;
 type json_CsvOptions = CsvOptions;
@@ -181,6 +212,8 @@ type json_JsonDiffResult = JsonDiffResult;
 type json_JsonParseResult = JsonParseResult;
 type json_JsonPathResult = JsonPathResult;
 type json_JsonPointerResult = JsonPointerResult;
+type json_JsonSchemaLike = JsonSchemaLike;
+type json_JsonSchemaToTsOptions = JsonSchemaToTsOptions;
 type json_ParseStatus = ParseStatus;
 type json_PythonClass = PythonClass;
 type json_PythonField = PythonField;
@@ -199,6 +232,7 @@ declare const json_getJsonStats: typeof getJsonStats;
 declare const json_inferGoType: typeof inferGoType;
 declare const json_inferPythonType: typeof inferPythonType;
 declare const json_inferType: typeof inferType;
+declare const json_jsonSchemaToTypescript: typeof jsonSchemaToTypescript;
 declare const json_jsonToCsv: typeof jsonToCsv;
 declare const json_jsonToGo: typeof jsonToGo;
 declare const json_jsonToPython: typeof jsonToPython;
@@ -216,7 +250,7 @@ declare const json_validateJsonPath: typeof validateJsonPath;
 declare const json_validateJsonString: typeof validateJsonString;
 declare const json_yamlToJson: typeof yamlToJson;
 declare namespace json {
-  export { type json_ConvertOptions as ConvertOptions, type json_CsvOptions as CsvOptions, type json_DiffNode as DiffNode, type json_DiffType as DiffType, type json_GoField as GoField, type json_GoStruct as GoStruct, type json_JsonDiffResult as JsonDiffResult, type json_JsonParseResult as JsonParseResult, type json_JsonPathResult as JsonPathResult, type json_JsonPointerResult as JsonPointerResult, type json_ParseStatus as ParseStatus, type json_PythonClass as PythonClass, type json_PythonField as PythonField, type json_PythonMode as PythonMode, type json_ValidationError as ValidationError, type json_ValidationResult as ValidationResult, type json_ZodOptions as ZodOptions, json_csvToJson as csvToJson, json_detectFormat as detectFormat, json_diffJson as diffJson, json_evaluateJsonPath as evaluateJsonPath, json_formatDiffLine as formatDiffLine, json_formatJson as formatJson, json_generateExample as generateExample, json_getJsonStats as getJsonStats, json_inferGoType as inferGoType, json_inferPythonType as inferPythonType, json_inferType as inferType, json_jsonToCsv as jsonToCsv, json_jsonToGo as jsonToGo, json_jsonToPython as jsonToPython, json_jsonToTypescript as jsonToTypescript, json_jsonToYaml as jsonToYaml, json_jsonToZod as jsonToZod, json_minifyJson as minifyJson, json_parseJson as parseJson, json_parseStructs as parseStructs, json_resolveJsonPointer as resolveJsonPointer, json_toPascalCase as toPascalCase, json_toSnakeCase as toSnakeCase, json_validateJson as validateJson, json_validateJsonPath as validateJsonPath, json_validateJsonString as validateJsonString, json_yamlToJson as yamlToJson };
+  export { type json_ConvertOptions as ConvertOptions, type json_CsvOptions as CsvOptions, type json_DiffNode as DiffNode, type json_DiffType as DiffType, type json_GoField as GoField, type json_GoStruct as GoStruct, type json_JsonDiffResult as JsonDiffResult, type json_JsonParseResult as JsonParseResult, type json_JsonPathResult as JsonPathResult, type json_JsonPointerResult as JsonPointerResult, type json_JsonSchemaLike as JsonSchemaLike, type json_JsonSchemaToTsOptions as JsonSchemaToTsOptions, type json_ParseStatus as ParseStatus, type json_PythonClass as PythonClass, type json_PythonField as PythonField, type json_PythonMode as PythonMode, type json_ValidationError as ValidationError, type json_ValidationResult as ValidationResult, type json_ZodOptions as ZodOptions, json_csvToJson as csvToJson, json_detectFormat as detectFormat, json_diffJson as diffJson, json_evaluateJsonPath as evaluateJsonPath, json_formatDiffLine as formatDiffLine, json_formatJson as formatJson, json_generateExample as generateExample, json_getJsonStats as getJsonStats, json_inferGoType as inferGoType, json_inferPythonType as inferPythonType, json_inferType as inferType, json_jsonSchemaToTypescript as jsonSchemaToTypescript, json_jsonToCsv as jsonToCsv, json_jsonToGo as jsonToGo, json_jsonToPython as jsonToPython, json_jsonToTypescript as jsonToTypescript, json_jsonToYaml as jsonToYaml, json_jsonToZod as jsonToZod, json_minifyJson as minifyJson, json_parseJson as parseJson, json_parseStructs as parseStructs, json_resolveJsonPointer as resolveJsonPointer, json_toPascalCase as toPascalCase, json_toSnakeCase as toSnakeCase, json_validateJson as validateJson, json_validateJsonPath as validateJsonPath, json_validateJsonString as validateJsonString, json_yamlToJson as yamlToJson };
 }
 
-export { jsonToYaml as A, jsonToZod as B, type ConvertOptions as C, type DiffNode as D, minifyJson as E, parseJson as F, type GoField as G, parseStructs as H, resolveJsonPointer as I, type JsonDiffResult as J, toPascalCase as K, toSnakeCase as L, validateJson as M, validateJsonPath as N, validateJsonString as O, type ParseStatus as P, yamlToJson as Q, type ValidationError as V, type ZodOptions as Z, type CsvOptions as a, type DiffType as b, type GoStruct as c, type JsonParseResult as d, type JsonPathResult as e, type JsonPointerResult as f, type PythonClass as g, type PythonField as h, type PythonMode as i, json as j, type ValidationResult as k, csvToJson as l, detectFormat as m, diffJson as n, evaluateJsonPath as o, formatDiffLine as p, formatJson as q, generateExample as r, getJsonStats as s, inferGoType as t, inferPythonType as u, inferType as v, jsonToCsv as w, jsonToGo as x, jsonToPython as y, jsonToTypescript as z };
+export { jsonToGo as A, jsonToPython as B, type ConvertOptions as C, type DiffNode as D, jsonToTypescript as E, jsonToYaml as F, type GoField as G, jsonToZod as H, minifyJson as I, type JsonDiffResult as J, parseJson as K, parseStructs as L, resolveJsonPointer as M, toPascalCase as N, toSnakeCase as O, type ParseStatus as P, validateJson as Q, validateJsonPath as R, validateJsonString as S, yamlToJson as T, type ValidationError as V, type ZodOptions as Z, type CsvOptions as a, type DiffType as b, type GoStruct as c, type JsonParseResult as d, type JsonPathResult as e, type JsonPointerResult as f, type JsonSchemaLike as g, type JsonSchemaToTsOptions as h, type PythonClass as i, json as j, type PythonField as k, type PythonMode as l, type ValidationResult as m, csvToJson as n, detectFormat as o, diffJson as p, evaluateJsonPath as q, formatDiffLine as r, formatJson as s, generateExample as t, getJsonStats as u, inferGoType as v, inferPythonType as w, inferType as x, jsonSchemaToTypescript as y, jsonToCsv as z };

package/dist/{json-DEVFIpsC.d.cts → json-Ta9JykSB.d.ts}

@@ -13,6 +13,7 @@
  *   - json-to-go       : jsonToGo, parseStructs, toPascalCase, inferGoType
  *   - json-to-python   : jsonToPython, toSnakeCase, inferPythonType
  *   - json-to-zod      : jsonToZod
+ *   - json-schema-to-typescript : jsonSchemaToTypescript
  */
 type ParseStatus = 'idle' | 'valid' | 'error';
 interface JsonParseResult {
@@ -170,6 +171,36 @@ interface JsonPointerResult {
  * traversal, no external calls.
  */
 declare function resolveJsonPointer(json: string, pointer: string): JsonPointerResult;
+interface JsonSchemaLike {
+    type?: string | string[];
+    properties?: Record<string, JsonSchemaLike>;
+    required?: string[];
+    items?: JsonSchemaLike | JsonSchemaLike[];
+    enum?: unknown[];
+    const?: unknown;
+    oneOf?: JsonSchemaLike[];
+    anyOf?: JsonSchemaLike[];
+    allOf?: JsonSchemaLike[];
+    $ref?: string;
+    additionalProperties?: boolean | JsonSchemaLike;
+    description?: string;
+    definitions?: Record<string, JsonSchemaLike>;
+    $defs?: Record<string, JsonSchemaLike>;
+    [key: string]: unknown;
+}
+interface JsonSchemaToTsOptions {
+    rootName?: string;
+}
+/**
+ * Convert a JSON Schema document into TypeScript interfaces/types. Unlike
+ * jsonToTypescript (which infers types from an example data payload), this
+ * reads the schema's declared `type`/`enum`/`required` keywords directly, so
+ * optional vs. required fields and enum/union types come through accurately
+ * instead of being guessed from a single example value.
+ */
+declare function jsonSchemaToTypescript(schemaJson: string, options?: JsonSchemaToTsOptions): string | {
+    error: string;
+};
 
 type json_ConvertOptions = ConvertOptions;
 type json_CsvOptions = CsvOptions;
@@ -181,6 +212,8 @@ type json_JsonDiffResult = JsonDiffResult;
 type json_JsonParseResult = JsonParseResult;
 type json_JsonPathResult = JsonPathResult;
 type json_JsonPointerResult = JsonPointerResult;
+type json_JsonSchemaLike = JsonSchemaLike;
+type json_JsonSchemaToTsOptions = JsonSchemaToTsOptions;
 type json_ParseStatus = ParseStatus;
 type json_PythonClass = PythonClass;
 type json_PythonField = PythonField;
@@ -199,6 +232,7 @@ declare const json_getJsonStats: typeof getJsonStats;
 declare const json_inferGoType: typeof inferGoType;
 declare const json_inferPythonType: typeof inferPythonType;
 declare const json_inferType: typeof inferType;
+declare const json_jsonSchemaToTypescript: typeof jsonSchemaToTypescript;
 declare const json_jsonToCsv: typeof jsonToCsv;
 declare const json_jsonToGo: typeof jsonToGo;
 declare const json_jsonToPython: typeof jsonToPython;
@@ -216,7 +250,7 @@ declare const json_validateJsonPath: typeof validateJsonPath;
 declare const json_validateJsonString: typeof validateJsonString;
 declare const json_yamlToJson: typeof yamlToJson;
 declare namespace json {
-  export { type json_ConvertOptions as ConvertOptions, type json_CsvOptions as CsvOptions, type json_DiffNode as DiffNode, type json_DiffType as DiffType, type json_GoField as GoField, type json_GoStruct as GoStruct, type json_JsonDiffResult as JsonDiffResult, type json_JsonParseResult as JsonParseResult, type json_JsonPathResult as JsonPathResult, type json_JsonPointerResult as JsonPointerResult, type json_ParseStatus as ParseStatus, type json_PythonClass as PythonClass, type json_PythonField as PythonField, type json_PythonMode as PythonMode, type json_ValidationError as ValidationError, type json_ValidationResult as ValidationResult, type json_ZodOptions as ZodOptions, json_csvToJson as csvToJson, json_detectFormat as detectFormat, json_diffJson as diffJson, json_evaluateJsonPath as evaluateJsonPath, json_formatDiffLine as formatDiffLine, json_formatJson as formatJson, json_generateExample as generateExample, json_getJsonStats as getJsonStats, json_inferGoType as inferGoType, json_inferPythonType as inferPythonType, json_inferType as inferType, json_jsonToCsv as jsonToCsv, json_jsonToGo as jsonToGo, json_jsonToPython as jsonToPython, json_jsonToTypescript as jsonToTypescript, json_jsonToYaml as jsonToYaml, json_jsonToZod as jsonToZod, json_minifyJson as minifyJson, json_parseJson as parseJson, json_parseStructs as parseStructs, json_resolveJsonPointer as resolveJsonPointer, json_toPascalCase as toPascalCase, json_toSnakeCase as toSnakeCase, json_validateJson as validateJson, json_validateJsonPath as validateJsonPath, json_validateJsonString as validateJsonString, json_yamlToJson as yamlToJson };
+  export { type json_ConvertOptions as ConvertOptions, type json_CsvOptions as CsvOptions, type json_DiffNode as DiffNode, type json_DiffType as DiffType, type json_GoField as GoField, type json_GoStruct as GoStruct, type json_JsonDiffResult as JsonDiffResult, type json_JsonParseResult as JsonParseResult, type json_JsonPathResult as JsonPathResult, type json_JsonPointerResult as JsonPointerResult, type json_JsonSchemaLike as JsonSchemaLike, type json_JsonSchemaToTsOptions as JsonSchemaToTsOptions, type json_ParseStatus as ParseStatus, type json_PythonClass as PythonClass, type json_PythonField as PythonField, type json_PythonMode as PythonMode, type json_ValidationError as ValidationError, type json_ValidationResult as ValidationResult, type json_ZodOptions as ZodOptions, json_csvToJson as csvToJson, json_detectFormat as detectFormat, json_diffJson as diffJson, json_evaluateJsonPath as evaluateJsonPath, json_formatDiffLine as formatDiffLine, json_formatJson as formatJson, json_generateExample as generateExample, json_getJsonStats as getJsonStats, json_inferGoType as inferGoType, json_inferPythonType as inferPythonType, json_inferType as inferType, json_jsonSchemaToTypescript as jsonSchemaToTypescript, json_jsonToCsv as jsonToCsv, json_jsonToGo as jsonToGo, json_jsonToPython as jsonToPython, json_jsonToTypescript as jsonToTypescript, json_jsonToYaml as jsonToYaml, json_jsonToZod as jsonToZod, json_minifyJson as minifyJson, json_parseJson as parseJson, json_parseStructs as parseStructs, json_resolveJsonPointer as resolveJsonPointer, json_toPascalCase as toPascalCase, json_toSnakeCase as toSnakeCase, json_validateJson as validateJson, json_validateJsonPath as validateJsonPath, json_validateJsonString as validateJsonString, json_yamlToJson as yamlToJson };
 }
 
-export { jsonToYaml as A, jsonToZod as B, type ConvertOptions as C, type DiffNode as D, minifyJson as E, parseJson as F, type GoField as G, parseStructs as H, resolveJsonPointer as I, type JsonDiffResult as J, toPascalCase as K, toSnakeCase as L, validateJson as M, validateJsonPath as N, validateJsonString as O, type ParseStatus as P, yamlToJson as Q, type ValidationError as V, type ZodOptions as Z, type CsvOptions as a, type DiffType as b, type GoStruct as c, type JsonParseResult as d, type JsonPathResult as e, type JsonPointerResult as f, type PythonClass as g, type PythonField as h, type PythonMode as i, json as j, type ValidationResult as k, csvToJson as l, detectFormat as m, diffJson as n, evaluateJsonPath as o, formatDiffLine as p, formatJson as q, generateExample as r, getJsonStats as s, inferGoType as t, inferPythonType as u, inferType as v, jsonToCsv as w, jsonToGo as x, jsonToPython as y, jsonToTypescript as z };
+export { jsonToGo as A, jsonToPython as B, type ConvertOptions as C, type DiffNode as D, jsonToTypescript as E, jsonToYaml as F, type GoField as G, jsonToZod as H, minifyJson as I, type JsonDiffResult as J, parseJson as K, parseStructs as L, resolveJsonPointer as M, toPascalCase as N, toSnakeCase as O, type ParseStatus as P, validateJson as Q, validateJsonPath as R, validateJsonString as S, yamlToJson as T, type ValidationError as V, type ZodOptions as Z, type CsvOptions as a, type DiffType as b, type GoStruct as c, type JsonParseResult as d, type JsonPathResult as e, type JsonPointerResult as f, type JsonSchemaLike as g, type JsonSchemaToTsOptions as h, type PythonClass as i, json as j, type PythonField as k, type PythonMode as l, type ValidationResult as m, csvToJson as n, detectFormat as o, diffJson as p, evaluateJsonPath as q, formatDiffLine as r, formatJson as s, generateExample as t, getJsonStats as u, inferGoType as v, inferPythonType as w, inferType as x, jsonSchemaToTypescript as y, jsonToCsv as z };

package/dist/tools/generators.cjs

@@ -207,6 +207,111 @@ function checkStrength(password) {
     color: levels[score].color
   };
 }
+var _SYMBOL_POOL_CHARS = " !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
+var _SYMBOL_POOL_SET = new Set(_SYMBOL_POOL_CHARS.split(""));
+function _hasSymbolChar(password) {
+  for (const ch of password) {
+    if (_SYMBOL_POOL_SET.has(ch)) return true;
+  }
+  return false;
+}
+function _hasSequentialRun(password, minRun) {
+  let ascRun = 1;
+  let descRun = 1;
+  for (let i = 1; i < password.length; i++) {
+    const prev = password.charCodeAt(i - 1);
+    const curr = password.charCodeAt(i);
+    if (curr === prev + 1) {
+      ascRun++;
+      descRun = 1;
+    } else if (curr === prev - 1) {
+      descRun++;
+      ascRun = 1;
+    } else {
+      ascRun = 1;
+      descRun = 1;
+    }
+    if (ascRun >= minRun || descRun >= minRun) return true;
+  }
+  return false;
+}
+function _formatCrackDuration(seconds) {
+  if (!isFinite(seconds)) return "effectively never";
+  if (seconds < 1) return "instantly";
+  const units = [
+    ["century", 315576e4],
+    ["year", 31557600],
+    ["month", 2629800],
+    ["day", 86400],
+    ["hour", 3600],
+    ["minute", 60],
+    ["second", 1]
+  ];
+  for (const [name, unitSeconds] of units) {
+    if (seconds >= unitSeconds) {
+      const value = seconds / unitSeconds;
+      if (name === "century" && value > 1e3) return "longer than the age of the universe";
+      const rounded = value >= 100 ? Math.round(value) : Math.round(value * 10) / 10;
+      const plural = name === "century" ? "centuries" : `${name}s`;
+      return `${rounded} ${rounded === 1 ? name : plural}`;
+    }
+  }
+  return "instantly";
+}
+function estimatePasswordEntropy(password) {
+  if (!password) return { error: "Password is required" };
+  const hasLowercase = /[a-z]/.test(password);
+  const hasUppercase = /[A-Z]/.test(password);
+  const hasDigits = /[0-9]/.test(password);
+  const hasSymbols = _hasSymbolChar(password);
+  const hasOther = /[^\x20-\x7e]/.test(password);
+  let poolSize = 0;
+  if (hasLowercase) poolSize += 26;
+  if (hasUppercase) poolSize += 26;
+  if (hasDigits) poolSize += 10;
+  if (hasSymbols) poolSize += _SYMBOL_POOL_CHARS.length;
+  if (hasOther) poolSize += 100;
+  const entropyBits = Math.round(password.length * Math.log2(poolSize) * 100) / 100;
+  let strength;
+  if (entropyBits < 28) strength = "very-weak";
+  else if (entropyBits < 36) strength = "weak";
+  else if (entropyBits < 60) strength = "fair";
+  else if (entropyBits < 128) strength = "strong";
+  else strength = "very-strong";
+  const averageGuesses = Math.pow(2, entropyBits) / 2;
+  const scenarios = [
+    { scenario: "Online, throttled (100 guesses/hour)", guessesPerSecond: 100 / 3600 },
+    { scenario: "Online, unthrottled (10 guesses/sec)", guessesPerSecond: 10 },
+    { scenario: "Offline, slow hash e.g. bcrypt (10k guesses/sec)", guessesPerSecond: 1e4 },
+    { scenario: "Offline, fast hash / GPU cluster (10B guesses/sec)", guessesPerSecond: 1e10 }
+  ];
+  const crackTimes = scenarios.map((s) => ({
+    scenario: s.scenario,
+    guessesPerSecond: s.guessesPerSecond,
+    humanReadable: _formatCrackDuration(averageGuesses / s.guessesPerSecond)
+  }));
+  const warnings = [];
+  if (password.length < 8) {
+    warnings.push("Shorter than 8 characters \u2014 most sites and cracking tools treat this as trivially weak regardless of entropy.");
+  }
+  if (/(.)\1{2,}/.test(password)) {
+    warnings.push('Contains a repeated character run (e.g. "aaa"), which is easier to guess than the entropy figure implies.');
+  }
+  if (_hasSequentialRun(password, 3)) {
+    warnings.push('Contains a sequential run (e.g. "abc" or "321"), which is easier to guess than the entropy figure implies.');
+  }
+  if (poolSize <= 26) {
+    warnings.push("Uses only one character class \u2014 mixing in uppercase, digits, or symbols raises the character pool and entropy.");
+  }
+  return {
+    length: password.length,
+    charset: { hasLowercase, hasUppercase, hasDigits, hasSymbols, hasOther, poolSize },
+    entropyBits,
+    strength,
+    crackTimes,
+    warnings
+  };
+}
 var DATA_TYPES = [
   { value: "name", label: "Full Name", example: "John Smith" },
   { value: "email", label: "Email Address", example: "john.smith@gmail.com" },
@@ -503,6 +608,7 @@ exports.DEFAULT_QR_OPTIONS = DEFAULT_QR_OPTIONS;
 exports.SYMBOL_CHARS = SYMBOL_CHARS;
 exports.ULID_REGEX = ULID_REGEX;
 exports.checkStrength = checkStrength;
+exports.estimatePasswordEntropy = estimatePasswordEntropy;
 exports.generateBulk = generateBulk;
 exports.generateBulkPasswords = generateBulkPasswords;
 exports.generateBulkUlids = generateBulkUlids;

package/dist/tools/generators.d.cts

@@ -1 +1 @@
-export { A as AMBIGUOUS_CHARS, D as DATA_TYPES, a as DEFAULT_OPTIONS, b as DEFAULT_QR_OPTIONS, c as DataType, G as GeneratedUuid, P as PasswordOptions, Q as QrErrorLevel, d as QrOptions, e as QrOutputFormat, R as RandomConfig, S as SYMBOL_CHARS, U as ULID_REGEX, f as UuidVersion, h as checkStrength, i as generateBulk, j as generateBulkPasswords, k as generateBulkUlids, l as generateData, m as generatePassword, n as generateQrDataUrl, o as generateQrSvg, p as generateSingle, q as generateUlid, r as generateUuid, s as generateV4, t as generateV7, u as isValidUlid, v as isValidUuid, w as parseUlid, x as parseUuidVersion } from '../generators-BGtRGpJZ.cjs';
+export { A as AMBIGUOUS_CHARS, D as DATA_TYPES, a as DEFAULT_OPTIONS, b as DEFAULT_QR_OPTIONS, c as DataType, G as GeneratedUuid, P as PasswordCharsetInfo, d as PasswordCrackTimeEstimate, e as PasswordEntropyResult, f as PasswordEntropyStrength, h as PasswordOptions, Q as QrErrorLevel, i as QrOptions, j as QrOutputFormat, R as RandomConfig, S as SYMBOL_CHARS, U as ULID_REGEX, k as UuidVersion, l as checkStrength, m as estimatePasswordEntropy, n as generateBulk, o as generateBulkPasswords, p as generateBulkUlids, q as generateData, r as generatePassword, s as generateQrDataUrl, t as generateQrSvg, u as generateSingle, v as generateUlid, w as generateUuid, x as generateV4, y as generateV7, z as isValidUlid, B as isValidUuid, C as parseUlid, E as parseUuidVersion } from '../generators-Du8cBesn.cjs';

package/dist/tools/generators.d.ts

@@ -1 +1 @@
-export { A as AMBIGUOUS_CHARS, D as DATA_TYPES, a as DEFAULT_OPTIONS, b as DEFAULT_QR_OPTIONS, c as DataType, G as GeneratedUuid, P as PasswordOptions, Q as QrErrorLevel, d as QrOptions, e as QrOutputFormat, R as RandomConfig, S as SYMBOL_CHARS, U as ULID_REGEX, f as UuidVersion, h as checkStrength, i as generateBulk, j as generateBulkPasswords, k as generateBulkUlids, l as generateData, m as generatePassword, n as generateQrDataUrl, o as generateQrSvg, p as generateSingle, q as generateUlid, r as generateUuid, s as generateV4, t as generateV7, u as isValidUlid, v as isValidUuid, w as parseUlid, x as parseUuidVersion } from '../generators-BGtRGpJZ.js';
+export { A as AMBIGUOUS_CHARS, D as DATA_TYPES, a as DEFAULT_OPTIONS, b as DEFAULT_QR_OPTIONS, c as DataType, G as GeneratedUuid, P as PasswordCharsetInfo, d as PasswordCrackTimeEstimate, e as PasswordEntropyResult, f as PasswordEntropyStrength, h as PasswordOptions, Q as QrErrorLevel, i as QrOptions, j as QrOutputFormat, R as RandomConfig, S as SYMBOL_CHARS, U as ULID_REGEX, k as UuidVersion, l as checkStrength, m as estimatePasswordEntropy, n as generateBulk, o as generateBulkPasswords, p as generateBulkUlids, q as generateData, r as generatePassword, s as generateQrDataUrl, t as generateQrSvg, u as generateSingle, v as generateUlid, w as generateUuid, x as generateV4, y as generateV7, z as isValidUlid, B as isValidUuid, C as parseUlid, E as parseUuidVersion } from '../generators-Du8cBesn.js';

package/dist/tools/generators.js

@@ -1,2 +1,2 @@
-export { AMBIGUOUS_CHARS, DATA_TYPES, DEFAULT_OPTIONS, DEFAULT_QR_OPTIONS, SYMBOL_CHARS, ULID_REGEX, checkStrength, generateBulk, generateBulkPasswords, generateBulkUlids, generateData, generatePassword, generateQrDataUrl, generateQrSvg, generateSingle, generateUlid, generateUuid, generateV4, generateV7, isValidUlid, isValidUuid, parseUlid, parseUuidVersion } from '../chunk-2CJSLYWI.js';
+export { AMBIGUOUS_CHARS, DATA_TYPES, DEFAULT_OPTIONS, DEFAULT_QR_OPTIONS, SYMBOL_CHARS, ULID_REGEX, checkStrength, estimatePasswordEntropy, generateBulk, generateBulkPasswords, generateBulkUlids, generateData, generatePassword, generateQrDataUrl, generateQrSvg, generateSingle, generateUlid, generateUuid, generateV4, generateV7, isValidUlid, isValidUuid, parseUlid, parseUuidVersion } from '../chunk-3TYWIX3B.js';
 import '../chunk-MLKGABMK.js';

package/dist/tools/json.cjs

@@ -1293,6 +1293,105 @@ function resolveJsonPointer(json, pointer) {
   }
   return { pointer, found: true, value: current, tokens };
 }
+function _schemaRefName(ref) {
+  const parts = ref.split("/");
+  return _capitalize(parts[parts.length - 1] || "Ref");
+}
+function _schemaLiteralType(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value === null) return "null";
+  return JSON.stringify(value);
+}
+function _safePropertyKey(key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+}
+function _schemaToTsType(schema, name, interfaces) {
+  if (schema.$ref) return _schemaRefName(schema.$ref);
+  if (schema.const !== void 0) return _schemaLiteralType(schema.const);
+  if (schema.enum) return schema.enum.map(_schemaLiteralType).join(" | ");
+  if (schema.oneOf) return schema.oneOf.map((s, i) => _schemaToTsType(s, `${name}Variant${i}`, interfaces)).join(" | ");
+  if (schema.anyOf) return schema.anyOf.map((s, i) => _schemaToTsType(s, `${name}Variant${i}`, interfaces)).join(" | ");
+  if (schema.allOf) return schema.allOf.map((s, i) => _schemaToTsType(s, `${name}Part${i}`, interfaces)).join(" & ");
+  const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+  const nullable = types.includes("null");
+  const nonNullTypes = types.filter((t) => t !== "null");
+  const primaryType = nonNullTypes[0] ?? (schema.properties || schema.additionalProperties !== void 0 ? "object" : void 0);
+  let result;
+  switch (primaryType) {
+    case "string":
+      result = "string";
+      break;
+    case "number":
+    case "integer":
+      result = "number";
+      break;
+    case "boolean":
+      result = "boolean";
+      break;
+    case "array": {
+      const itemsSchema = Array.isArray(schema.items) ? schema.items[0] : schema.items;
+      const itemType = itemsSchema ? _schemaToTsType(itemsSchema, `${name}Item`, interfaces) : "unknown";
+      result = `${itemType}[]`;
+      break;
+    }
+    case "object": {
+      _buildSchemaInterface(schema, name, interfaces);
+      result = name;
+      break;
+    }
+    default:
+      result = "unknown";
+  }
+  return nullable ? `${result} | null` : result;
+}
+function _buildSchemaInterface(schema, name, interfaces) {
+  if (interfaces.has(name)) return;
+  const required = new Set(schema.required ?? []);
+  const lines = [`interface ${name} {`];
+  for (const [key, propSchema] of Object.entries(schema.properties ?? {})) {
+    if (propSchema.description) lines.push(`  /** ${propSchema.description} */`);
+    const optional = required.has(key) ? "" : "?";
+    const propType = _schemaToTsType(propSchema, _capitalize(key), interfaces);
+    lines.push(`  ${_safePropertyKey(key)}${optional}: ${propType};`);
+  }
+  if (schema.additionalProperties === true) {
+    lines.push("  [key: string]: unknown;");
+  } else if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    const addType = _schemaToTsType(schema.additionalProperties, `${name}Value`, interfaces);
+    lines.push(`  [key: string]: ${addType};`);
+  }
+  lines.push("}");
+  interfaces.set(name, lines.join("\n"));
+}
+function jsonSchemaToTypescript(schemaJson, options) {
+  let schema;
+  try {
+    schema = JSON.parse(schemaJson);
+  } catch {
+    return { error: "Invalid JSON input" };
+  }
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+    return { error: "Schema must be a JSON object" };
+  }
+  const rootName = options?.rootName ?? "Root";
+  const typedSchema = schema;
+  const interfaces = /* @__PURE__ */ new Map();
+  const defs = { ...typedSchema.$defs ?? {}, ...typedSchema.definitions ?? {} };
+  for (const [defName, defSchema] of Object.entries(defs)) {
+    const defTypeName = _capitalize(defName);
+    const defType = _schemaToTsType(defSchema, defTypeName, interfaces);
+    if (!interfaces.has(defTypeName)) {
+      interfaces.set(defTypeName, `type ${defTypeName} = ${defType};`);
+    }
+  }
+  const rootType = _schemaToTsType(typedSchema, rootName, interfaces);
+  const parts = [...interfaces.values()];
+  if (!interfaces.has(rootName)) {
+    parts.push(`type ${rootName} = ${rootType};`);
+  }
+  return parts.join("\n\n");
+}
 
 exports.csvToJson = csvToJson;
 exports.detectFormat = detectFormat;
@@ -1305,6 +1404,7 @@ exports.getJsonStats = getJsonStats;
 exports.inferGoType = inferGoType;
 exports.inferPythonType = inferPythonType;
 exports.inferType = inferType;
+exports.jsonSchemaToTypescript = jsonSchemaToTypescript;
 exports.jsonToCsv = jsonToCsv;
 exports.jsonToGo = jsonToGo;
 exports.jsonToPython = jsonToPython;

package/dist/tools/json.d.cts

@@ -1 +1 @@
-export { C as ConvertOptions, a as CsvOptions, D as DiffNode, b as DiffType, G as GoField, c as GoStruct, J as JsonDiffResult, d as JsonParseResult, e as JsonPathResult, f as JsonPointerResult, P as ParseStatus, g as PythonClass, h as PythonField, i as PythonMode, V as ValidationError, k as ValidationResult, Z as ZodOptions, l as csvToJson, m as detectFormat, n as diffJson, o as evaluateJsonPath, p as formatDiffLine, q as formatJson, r as generateExample, s as getJsonStats, t as inferGoType, u as inferPythonType, v as inferType, w as jsonToCsv, x as jsonToGo, y as jsonToPython, z as jsonToTypescript, A as jsonToYaml, B as jsonToZod, E as minifyJson, F as parseJson, H as parseStructs, I as resolveJsonPointer, K as toPascalCase, L as toSnakeCase, M as validateJson, N as validateJsonPath, O as validateJsonString, Q as yamlToJson } from '../json-DEVFIpsC.cjs';
+export { C as ConvertOptions, a as CsvOptions, D as DiffNode, b as DiffType, G as GoField, c as GoStruct, J as JsonDiffResult, d as JsonParseResult, e as JsonPathResult, f as JsonPointerResult, g as JsonSchemaLike, h as JsonSchemaToTsOptions, P as ParseStatus, i as PythonClass, k as PythonField, l as PythonMode, V as ValidationError, m as ValidationResult, Z as ZodOptions, n as csvToJson, o as detectFormat, p as diffJson, q as evaluateJsonPath, r as formatDiffLine, s as formatJson, t as generateExample, u as getJsonStats, v as inferGoType, w as inferPythonType, x as inferType, y as jsonSchemaToTypescript, z as jsonToCsv, A as jsonToGo, B as jsonToPython, E as jsonToTypescript, F as jsonToYaml, H as jsonToZod, I as minifyJson, K as parseJson, L as parseStructs, M as resolveJsonPointer, N as toPascalCase, O as toSnakeCase, Q as validateJson, R as validateJsonPath, S as validateJsonString, T as yamlToJson } from '../json-Ta9JykSB.cjs';

package/dist/tools/json.d.ts

@@ -1 +1 @@
-export { C as ConvertOptions, a as CsvOptions, D as DiffNode, b as DiffType, G as GoField, c as GoStruct, J as JsonDiffResult, d as JsonParseResult, e as JsonPathResult, f as JsonPointerResult, P as ParseStatus, g as PythonClass, h as PythonField, i as PythonMode, V as ValidationError, k as ValidationResult, Z as ZodOptions, l as csvToJson, m as detectFormat, n as diffJson, o as evaluateJsonPath, p as formatDiffLine, q as formatJson, r as generateExample, s as getJsonStats, t as inferGoType, u as inferPythonType, v as inferType, w as jsonToCsv, x as jsonToGo, y as jsonToPython, z as jsonToTypescript, A as jsonToYaml, B as jsonToZod, E as minifyJson, F as parseJson, H as parseStructs, I as resolveJsonPointer, K as toPascalCase, L as toSnakeCase, M as validateJson, N as validateJsonPath, O as validateJsonString, Q as yamlToJson } from '../json-DEVFIpsC.js';
+export { C as ConvertOptions, a as CsvOptions, D as DiffNode, b as DiffType, G as GoField, c as GoStruct, J as JsonDiffResult, d as JsonParseResult, e as JsonPathResult, f as JsonPointerResult, g as JsonSchemaLike, h as JsonSchemaToTsOptions, P as ParseStatus, i as PythonClass, k as PythonField, l as PythonMode, V as ValidationError, m as ValidationResult, Z as ZodOptions, n as csvToJson, o as detectFormat, p as diffJson, q as evaluateJsonPath, r as formatDiffLine, s as formatJson, t as generateExample, u as getJsonStats, v as inferGoType, w as inferPythonType, x as inferType, y as jsonSchemaToTypescript, z as jsonToCsv, A as jsonToGo, B as jsonToPython, E as jsonToTypescript, F as jsonToYaml, H as jsonToZod, I as minifyJson, K as parseJson, L as parseStructs, M as resolveJsonPointer, N as toPascalCase, O as toSnakeCase, Q as validateJson, R as validateJsonPath, S as validateJsonString, T as yamlToJson } from '../json-Ta9JykSB.js';

package/dist/tools/json.js

@@ -1,2 +1,2 @@
-export { csvToJson, detectFormat, diffJson, evaluateJsonPath, formatDiffLine, formatJson, generateExample, getJsonStats, inferGoType, inferPythonType, inferType, jsonToCsv, jsonToGo, jsonToPython, jsonToTypescript, jsonToYaml, jsonToZod, minifyJson, parseJson, parseStructs, resolveJsonPointer, toPascalCase, toSnakeCase, validateJson, validateJsonPath, validateJsonString, yamlToJson } from '../chunk-WO3LJMVV.js';
+export { csvToJson, detectFormat, diffJson, evaluateJsonPath, formatDiffLine, formatJson, generateExample, getJsonStats, inferGoType, inferPythonType, inferType, jsonSchemaToTypescript, jsonToCsv, jsonToGo, jsonToPython, jsonToTypescript, jsonToYaml, jsonToZod, minifyJson, parseJson, parseStructs, resolveJsonPointer, toPascalCase, toSnakeCase, validateJson, validateJsonPath, validateJsonString, yamlToJson } from '../chunk-WVEKRKGU.js';
 import '../chunk-MLKGABMK.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utilix-tech/sdk",
-  "version": "0.29.0",
+  "version": "0.30.0",
   "description": "154+ developer utility tools for Node.js: JSON, encoding, hashing, color, CSS, network and more. Runs locally, no API key required.",
   "author": "Utilix <hello@utilix.tech>",
   "license": "MIT",