@bedrockio/yada 1.10.6 → 1.11.1

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 1.11.1
+
+- Better handling of tuple schemas in `toOpenAi`.
+
+## 1.11.0
+
+- Moved `openai` as `toJSONSchema` option to own method `toOpenAi`.
+- Added `set` to object and array schemas.
+
 ## 1.10.4
 
 - Fixed type errors for rest params.

package/dist/cjs/Schema.js

@@ -7,7 +7,7 @@ exports.default = void 0;
 exports.isSchema = isSchema;
 var _lodash = require("lodash");
 var _errors = require("./errors");
-var _formats = require("./formats");
+var _openai = require("./openai");
 var _utils = require("./utils");
 const INITIAL_TYPES = ['default', 'required', 'type', 'transform', 'empty'];
 const REQUIRED_TYPES = ['default', 'required', 'missing'];
@@ -226,18 +226,15 @@ class Schema {
    * custom (code-based) assertions will not be output.
    * @param {Object} [options]
    * @param {Function} [options.tag] - Allows adding additional custom tags.
-   * @param {'openai'} [options.style] - Constrains schema output. Currently only
-   *   supports OpenAI which will ensure the resulting schema works with the Structured
-   *   Outputs API.
    * @param {boolean} [options.stripExtensions] - Strips out JSON schema extensions.
    */
   toJsonSchema(options) {
     return {
       ...this.getType(),
+      ...this.getFormat(),
       ...this.getDefault(),
       ...this.getEnum(options),
-      ...this.getTags(options),
-      ...this.getFormat(options)
+      ...this.getTags(options)
     };
   }
 
@@ -249,6 +246,16 @@ class Schema {
     return this.toJsonSchema(options);
   }
 
+  /**
+   * Converts the schema to OpenAI's [more strict flavor](https://platform.openai.com/docs/guides/structured-outputs#supported-schemas)
+   * for structured output.
+   */
+  toOpenAi() {
+    return this.transform(schema => {
+      return (0, _openai.toOpenAi)(schema);
+    });
+  }
+
   /**
    * Export JSON schema when invoked by JSON serializer.
    */
@@ -270,11 +277,11 @@ class Schema {
       };
     }
   }
-  getFormat(options) {
+  getFormat() {
     const {
       format
     } = this.meta;
-    if ((0, _formats.isAllowedFormat)(format, options)) {
+    if (format) {
       return {
         format
       };

package/dist/cjs/array.js

@@ -127,6 +127,27 @@ class ArraySchema extends _TypeSchema.default {
     }
   }
 
+  /**
+   * Sets a path on the schema using a transform function. Deep
+   * fields accept either a string using dot syntax or an array
+   * representing the path.
+   *
+   * @param {string|Array<string>} path The path to set.
+   * @param {Function} fn - Transform function that accepts an instance
+   *   of the schema.
+   */
+  set(path, fn) {
+    const {
+      schema
+    } = this.meta;
+    if (schema.meta.type !== 'object') {
+      throw new Error('Nested object schema required.');
+    }
+    return new ArraySchema({
+      schema: schema.set(path, fn)
+    });
+  }
+
   // Private
 
   toString() {

package/dist/cjs/object.js

@@ -152,6 +152,45 @@ class ObjectSchema extends _TypeSchema.default {
     }
   }
 
+  /**
+   * Sets a path on the schema using a transform function. Deep
+   * fields accept either a string using dot syntax or an array
+   * representing the path.
+   *
+   * @param {string|Array<string>} path The path to set.
+   * @param {Function} fn - Transform function that accepts an instance
+   *   of the schema.
+   */
+  set(path, fn) {
+    if (typeof path === 'string') {
+      path = path.split('.');
+    }
+    const [base, ...rest] = path;
+    const {
+      fields: currentFields
+    } = this.meta;
+    const keys = Object.keys(currentFields);
+    if (!keys.includes(base)) {
+      throw new Error(`Unknown field "${base}".`);
+    }
+    const fields = {};
+    for (let key of keys) {
+      const schema = currentFields[key];
+      if (key === base) {
+        if (rest.length) {
+          fields[key] = schema.set(rest, fn);
+        } else {
+          fields[key] = fn(schema);
+        }
+      } else {
+        fields[key] = schema;
+      }
+    }
+    return new ObjectSchema({
+      fields
+    });
+  }
+
   /**
    * Returns the inner schema of an array field. This only makes
    * sense if the array field holds a single schema, so all other
@@ -362,9 +401,6 @@ class ObjectSchema extends _TypeSchema.default {
   options(options) {
     return super.options(options);
   }
-
-  // Private
-
   toJsonSchema(options) {
     const {
       stripUnknown = false

package/dist/cjs/openai.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toOpenAi = toOpenAi;
+// Confirmed as of: 2026-02-09
+const OPENAI_ALLOWED_FORMATS = ['date-time', 'duration', 'hostname', 'date', 'time', 'email', 'ipv4', 'ipv6', 'uuid'];
+function toOpenAi(schema) {
+  const {
+    type,
+    required,
+    format,
+    tags
+  } = schema.meta;
+  if (type === 'object') {
+    return schema.required();
+  } else if (type === 'array') {
+    const {
+      schemas
+    } = schema.meta;
+    if (schemas) {
+      return schema.toArray().required();
+    } else {
+      return schema.required();
+    }
+  }
+
+  // All fields in OpenAI flavor JSON schema must be required,
+  // so make fields nullable to allow optional behvior.
+  if (!required) {
+    schema = schema.required().nullable();
+  }
+  if (hasInvalidFormat(format)) {
+    schema = schema.clone({
+      format: null
+    });
+  }
+  if (tags) {
+    schema = schema.clone({
+      tags: null
+    });
+  }
+  return schema;
+}
+function hasInvalidFormat(format) {
+  if (!format) {
+    return false;
+  }
+  return !OPENAI_ALLOWED_FORMATS.includes(format);
+}

package/dist/cjs/tuple.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = _default;
+var _lodash = require("lodash");
 var _Schema = _interopRequireDefault(require("./Schema"));
+var _array = _interopRequireDefault(require("./array"));
 var _errors = require("./errors");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class TupleSchema extends _Schema.default {
@@ -77,6 +79,17 @@ class TupleSchema extends _Schema.default {
       loose: true
     });
   }
+  toArray() {
+    const {
+      schemas
+    } = this.meta;
+    const unique = (0, _lodash.uniqBy)(schemas, s => s.meta.type);
+    if (unique.length > 1) {
+      return (0, _array.default)(new _Schema.default().allow(unique));
+    } else {
+      return (0, _array.default)(unique[0]);
+    }
+  }
   toString() {
     return 'tuple';
   }
@@ -86,6 +99,7 @@ class TupleSchema extends _Schema.default {
     } = this.meta;
     return {
       ...super.toJsonSchema(options),
+      items: false,
       prefixItems: schemas.map(schema => {
         return schema.toJsonSchema(options);
       })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/yada",
-  "version": "1.10.6",
+  "version": "1.11.1",
   "description": "Validation library inspired by Joi.",
   "scripts": {
     "test": "jest",
@@ -18,12 +18,12 @@
   "license": "MIT",
   "dependencies": {
     "lodash": "^4.17.21",
-    "validator": "^13.15.20"
+    "validator": "^13.15.26"
   },
   "devDependencies": {
-    "@babel/cli": "^7.20.7",
-    "@babel/core": "^7.20.12",
-    "@babel/preset-env": "^7.20.2",
+    "@babel/cli": "^7.28.3",
+    "@babel/core": "^7.28.5",
+    "@babel/preset-env": "^7.28.5",
     "@bedrockio/eslint-plugin": "^1.2.2",
     "@bedrockio/prettier-config": "^1.1.1",
     "babel-plugin-add-module-exports": "^1.0.4",

package/src/Schema.js

@@ -10,7 +10,7 @@ import {
   ValidationError,
 } from './errors';
 
-import { isAllowedFormat } from './formats';
+import { toOpenAi } from './openai';
 import { canAllowEmptyString } from './utils';
 
 const INITIAL_TYPES = ['default', 'required', 'type', 'transform', 'empty'];
@@ -222,18 +222,15 @@ export default class Schema {
    * custom (code-based) assertions will not be output.
    * @param {Object} [options]
    * @param {Function} [options.tag] - Allows adding additional custom tags.
-   * @param {'openai'} [options.style] - Constrains schema output. Currently only
-   *   supports OpenAI which will ensure the resulting schema works with the Structured
-   *   Outputs API.
    * @param {boolean} [options.stripExtensions] - Strips out JSON schema extensions.
    */
   toJsonSchema(options) {
     return {
       ...this.getType(),
+      ...this.getFormat(),
       ...this.getDefault(),
       ...this.getEnum(options),
       ...this.getTags(options),
-      ...this.getFormat(options),
     };
   }
 
@@ -245,6 +242,16 @@ export default class Schema {
     return this.toJsonSchema(options);
   }
 
+  /**
+   * Converts the schema to OpenAI's [more strict flavor](https://platform.openai.com/docs/guides/structured-outputs#supported-schemas)
+   * for structured output.
+   */
+  toOpenAi() {
+    return this.transform((schema) => {
+      return toOpenAi(schema);
+    });
+  }
+
   /**
    * Export JSON schema when invoked by JSON serializer.
    */
@@ -265,9 +272,9 @@ export default class Schema {
     }
   }
 
-  getFormat(options) {
+  getFormat() {
     const { format } = this.meta;
-    if (isAllowedFormat(format, options)) {
+    if (format) {
       return { format };
     }
   }

package/src/array.js

@@ -125,6 +125,27 @@ class ArraySchema extends TypeSchema {
     }
   }
 
+  /**
+   * Sets a path on the schema using a transform function. Deep
+   * fields accept either a string using dot syntax or an array
+   * representing the path.
+   *
+   * @param {string|Array<string>} path The path to set.
+   * @param {Function} fn - Transform function that accepts an instance
+   *   of the schema.
+   */
+  set(path, fn) {
+    const { schema } = this.meta;
+
+    if (schema.meta.type !== 'object') {
+      throw new Error('Nested object schema required.');
+    }
+
+    return new ArraySchema({
+      schema: schema.set(path, fn),
+    });
+  }
+
   // Private
 
   toString() {

package/src/object.js

@@ -168,6 +168,49 @@ class ObjectSchema extends TypeSchema {
     }
   }
 
+  /**
+   * Sets a path on the schema using a transform function. Deep
+   * fields accept either a string using dot syntax or an array
+   * representing the path.
+   *
+   * @param {string|Array<string>} path The path to set.
+   * @param {Function} fn - Transform function that accepts an instance
+   *   of the schema.
+   */
+  set(path, fn) {
+    if (typeof path === 'string') {
+      path = path.split('.');
+    }
+
+    const [base, ...rest] = path;
+
+    const { fields: currentFields } = this.meta;
+    const keys = Object.keys(currentFields);
+
+    if (!keys.includes(base)) {
+      throw new Error(`Unknown field "${base}".`);
+    }
+
+    const fields = {};
+
+    for (let key of keys) {
+      const schema = currentFields[key];
+      if (key === base) {
+        if (rest.length) {
+          fields[key] = schema.set(rest, fn);
+        } else {
+          fields[key] = fn(schema);
+        }
+      } else {
+        fields[key] = schema;
+      }
+    }
+
+    return new ObjectSchema({
+      fields,
+    });
+  }
+
   /**
    * Returns the inner schema of an array field. This only makes
    * sense if the array field holds a single schema, so all other
@@ -390,8 +433,6 @@ class ObjectSchema extends TypeSchema {
     return super.options(options);
   }
 
-  // Private
-
   toJsonSchema(options) {
     const { stripUnknown = false } = this.meta;
 

package/src/openai.js

@@ -0,0 +1,54 @@
+// Confirmed as of: 2026-02-09
+const OPENAI_ALLOWED_FORMATS = [
+  'date-time',
+  'duration',
+  'hostname',
+  'date',
+  'time',
+  'email',
+  'ipv4',
+  'ipv6',
+  'uuid',
+];
+
+export function toOpenAi(schema) {
+  const { type, required, format, tags } = schema.meta;
+
+  if (type === 'object') {
+    return schema.required();
+  } else if (type === 'array') {
+    const { schemas } = schema.meta;
+    if (schemas) {
+      return schema.toArray().required();
+    } else {
+      return schema.required();
+    }
+  }
+
+  // All fields in OpenAI flavor JSON schema must be required,
+  // so make fields nullable to allow optional behvior.
+  if (!required) {
+    schema = schema.required().nullable();
+  }
+
+  if (hasInvalidFormat(format)) {
+    schema = schema.clone({
+      format: null,
+    });
+  }
+
+  if (tags) {
+    schema = schema.clone({
+      tags: null,
+    });
+  }
+
+  return schema;
+}
+
+function hasInvalidFormat(format) {
+  if (!format) {
+    return false;
+  }
+  return !OPENAI_ALLOWED_FORMATS.includes(format);
+}

package/src/tuple.js

@@ -1,4 +1,7 @@
+import { uniqBy } from 'lodash';
+
 import Schema from './Schema';
+import array from './array';
 import { ArrayError, ElementError, LocalizedError } from './errors';
 
 class TupleSchema extends Schema {
@@ -65,6 +68,16 @@ class TupleSchema extends Schema {
     return this.clone({ loose: true });
   }
 
+  toArray() {
+    const { schemas } = this.meta;
+    const unique = uniqBy(schemas, (s) => s.meta.type);
+    if (unique.length > 1) {
+      return array(new Schema().allow(unique));
+    } else {
+      return array(unique[0]);
+    }
+  }
+
   toString() {
     return 'tuple';
   }
@@ -73,6 +86,7 @@ class TupleSchema extends Schema {
     const { schemas } = this.meta;
     return {
       ...super.toJsonSchema(options),
+      items: false,
       prefixItems: schemas.map((schema) => {
         return schema.toJsonSchema(options);
       }),

package/types/Schema.d.ts

@@ -79,14 +79,10 @@ export default class Schema {
      * custom (code-based) assertions will not be output.
      * @param {Object} [options]
      * @param {Function} [options.tag] - Allows adding additional custom tags.
-     * @param {'openai'} [options.style] - Constrains schema output. Currently only
-     *   supports OpenAI which will ensure the resulting schema works with the Structured
-     *   Outputs API.
      * @param {boolean} [options.stripExtensions] - Strips out JSON schema extensions.
      */
     toJsonSchema(options?: {
         tag?: Function;
-        style?: "openai";
         stripExtensions?: boolean;
     }): any;
     /**
@@ -94,6 +90,11 @@ export default class Schema {
      * @alias toJsonSchema.
      */
     toOpenApi(options: any): any;
+    /**
+     * Converts the schema to OpenAI's [more strict flavor](https://platform.openai.com/docs/guides/structured-outputs#supported-schemas)
+     * for structured output.
+     */
+    toOpenAi(): this;
     /**
      * Export JSON schema when invoked by JSON serializer.
      */
@@ -101,7 +102,7 @@ export default class Schema {
     getType(): {
         type: any;
     };
-    getFormat(options: any): {
+    getFormat(): {
         format: any;
     };
     getDefault(): {

package/types/Schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../src/Schema.js"],"names":[],"mappings":"AAkBA,kDAEC;AAED;IACE,uBAGC;IAFC,kBAAoB;IACpB,SAAgB;IAKlB;;;OAGG;IACH,iBAHW,OAAO,GACL,IAAI,CAUhB;IAED;;;OAGG;IACH,mBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,sBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,uBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,mBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,uBAFa,IAAI,CAIhB;IAED;;;;OAIG;IACH,iBAHW,OAAO,GACL,IAAI,CAIhB;IAED;;OAEG;IACH,uBAFa,IAAI,CAIhB;IAED;;OAEG;IACH,gBAFa,IAAI,CAShB;IAED;;OAEG;IACH,+BAFa,IAAI,CAMhB;IAED;;OAEG;IACH,uBAFa,IAAI,CAIhB;IAED,iDA0CC;IAED;;OAEG;IACH,kBAFa,IAAI,CAOhB;IAED;;;OAGG;IACH,qBAFa,MAAM,CAMlB;IAED;;;;;;;;;;OAUG;IACH,uBANG;QAA2B,GAAG;QACH,KAAK,GAAxB,QAAQ;QAGU,eAAe,GAAjC,OAAO;KACjB,OASA;IAED;;;OAGG;IACH,6BAEC;IAED;;OAEG;IACH,cAEC;IAED;;MAWC;IAED;;MAKC;IAED;;;;MASC;IAED,2BAgDC;IAED,2BAmBC;IAED;;;;;OAKG;IACH,oCAFa,IAAI,CAgBhB;IAED,kBAEC;IAED,YAGC;IAID;;OAEG;IACH,kCAFa,IAAI,CAsDhB;IAED;;OAEG;IACH,4BAFa,IAAI,CAUhB;IAED,oCAKC;IAED,gEAQC;IAED;;OAEG;IACH,yBAFa,IAAI,CAShB;IAED,gCAGC;IAED,qEAYC;CACF"}
+{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../src/Schema.js"],"names":[],"mappings":"AAkBA,kDAEC;AAED;IACE,uBAGC;IAFC,kBAAoB;IACpB,SAAgB;IAKlB;;;OAGG;IACH,iBAHW,OAAO,GACL,IAAI,CAUhB;IAED;;;OAGG;IACH,mBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,sBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,uBAFa,IAAI,CAShB;IAED;;;;OAIG;IACH,mBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,uBAFa,IAAI,CAIhB;IAED;;;;OAIG;IACH,iBAHW,OAAO,GACL,IAAI,CAIhB;IAED;;OAEG;IACH,uBAFa,IAAI,CAIhB;IAED;;OAEG;IACH,gBAFa,IAAI,CAShB;IAED;;OAEG;IACH,+BAFa,IAAI,CAMhB;IAED;;OAEG;IACH,uBAFa,IAAI,CAIhB;IAED,iDA0CC;IAED;;OAEG;IACH,kBAFa,IAAI,CAOhB;IAED;;;OAGG;IACH,qBAFa,MAAM,CAMlB;IAED;;;;;;;OAOG;IACH,uBAHG;QAA2B,GAAG;QACJ,eAAe,GAAjC,OAAO;KACjB,OASA;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,iBAIC;IAED;;OAEG;IACH,cAEC;IAED;;MAWC;IAED;;MAKC;IAED;;;;MASC;IAED,2BAgDC;IAED,2BAmBC;IAED;;;;;OAKG;IACH,oCAFa,IAAI,CAgBhB;IAED,kBAEC;IAED,YAGC;IAID;;OAEG;IACH,kCAFa,IAAI,CAsDhB;IAED;;OAEG;IACH,4BAFa,IAAI,CAUhB;IAED,oCAKC;IAED,gEAQC;IAED;;OAEG;IACH,yBAFa,IAAI,CAShB;IAED,gCAGC;IAED,qEAYC;CACF"}

package/types/array.d.ts

@@ -19,6 +19,16 @@ declare class ArraySchema extends TypeSchema {
      * @returns {this}
      */
     transform(fn: Function, root?: boolean): this;
+    /**
+     * Sets a path on the schema using a transform function. Deep
+     * fields accept either a string using dot syntax or an array
+     * representing the path.
+     *
+     * @param {string|Array<string>} path The path to set.
+     * @param {Function} fn - Transform function that accepts an instance
+     *   of the schema.
+     */
+    set(path: string | Array<string>, fn: Function): ArraySchema;
     toString(): string;
     toJsonSchema(options: any): any;
 }

package/types/array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.js"],"names":[],"mappings":"AAgJA;;;;;GAKG;AACH,0CAHW,GAAC,+BAYX;AA1JD;IACE,uBAGC;IAED,cAoCC;IAED,0BAUC;IAED,uBAUC;IAED,uBAaC;IAED,eAaC;IAED;;;;;OAKG;IACH,yCAFa,IAAI,CAkBhB;IAID,mBAEC;IAED,gCAQC;CACF;uBA5IsB,cAAc"}
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.js"],"names":[],"mappings":"AAqKA;;;;;GAKG;AACH,0CAHW,GAAC,+BAYX;AA/KD;IACE,uBAGC;IAED,cAoCC;IAED,0BAUC;IAED,uBAUC;IAED,uBAaC;IAED,eAaC;IAED;;;;;OAKG;IACH,yCAFa,IAAI,CAkBhB;IAED;;;;;;;;OAQG;IACH,UAJW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,6BAc9B;IAID,mBAEC;IAED,gCAQC;CACF;uBAjKsB,cAAc"}

package/types/object.d.ts

@@ -24,6 +24,16 @@ declare class ObjectSchema extends TypeSchema {
      * @param {string|Array<string>} [path] The path of the field.
      */
     get(path?: string | Array<string>): any;
+    /**
+     * Sets a path on the schema using a transform function. Deep
+     * fields accept either a string using dot syntax or an array
+     * representing the path.
+     *
+     * @param {string|Array<string>} path The path to set.
+     * @param {Function} fn - Transform function that accepts an instance
+     *   of the schema.
+     */
+    set(path: string | Array<string>, fn: Function): ObjectSchema;
     /**
      * Returns the inner schema of an array field. This only makes
      * sense if the array field holds a single schema, so all other

package/types/object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.js"],"names":[],"mappings":"AAsgBA;;;;;;GAMG;AACH,uCAJW,SAAS,gBAQnB;wBAtgBY;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,EAAE;AAD3C;;GAEG;AAEH;IACE,uBAIC;IAED,sBAOC;IAED,cAiHC;IAED;;;;;;OAMG;IACH,WAFW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,OAkB9B;IAED;;;;;;OAMG;IACH,cAFW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,OAc9B;IAED;;;;OAIG;IACH,eAFc,MAAM,EAAA,gBASnB;IAED;;;;OAIG;IACH,eAFc,MAAM,EAAA,gBASnB;IAED;;;;;;;OAOG;IACH,mBAHc,MAAM,EAAA,gBAuBnB;IAED;;OAEG;IACH,2BAQC;IAED;;;;;;OAMG;IACH,yCAFa,IAAI,CAiBhB;IAED;;;;;;OAMG;IACH,cAEC;IAED;;;;;;;;;OASG;IACH,YAFW,SAAS,GAAC,MAAM,gBA+B1B;IAID;;OAEG;IACH,mBAIC;IAED;;OAEG;IACH,qBAIC;IAED;;OAEG;IACH,sBAIC;IAED;;OAEG;IACH,uBAIC;IAED;;;;;;;;;;;OAWG;IACH,kBALG;QAA0B,UAAU,GAA5B,OAAO;QACW,YAAY,GAA9B,OAAO;QACW,aAAa,GAA/B,OAAO;QACW,cAAc,GAAhC,OAAO;KAA0B,QAI3C;IAID,gCAmBC;CACF;mBA5ZgC,UAAU;uBACpB,cAAc"}
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.js"],"names":[],"mappings":"AA+iBA;;;;;;GAMG;AACH,uCAJW,SAAS,gBAQnB;wBA/iBY;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,EAAE;AAD3C;;GAEG;AAEH;IACE,uBAIC;IAED,sBAOC;IAED,cAiHC;IAED;;;;;;OAMG;IACH,WAFW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,OAkB9B;IAED;;;;;;;;OAQG;IACH,UAJW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,8BAoC9B;IAED;;;;;;OAMG;IACH,cAFW,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC,OAc9B;IAED;;;;OAIG;IACH,eAFc,MAAM,EAAA,gBASnB;IAED;;;;OAIG;IACH,eAFc,MAAM,EAAA,gBASnB;IAED;;;;;;;OAOG;IACH,mBAHc,MAAM,EAAA,gBAuBnB;IAED;;OAEG;IACH,2BAQC;IAED;;;;;;OAMG;IACH,yCAFa,IAAI,CAiBhB;IAED;;;;;;OAMG;IACH,cAEC;IAED;;;;;;;;;OASG;IACH,YAFW,SAAS,GAAC,MAAM,gBA+B1B;IAID;;OAEG;IACH,mBAIC;IAED;;OAEG;IACH,qBAIC;IAED;;OAEG;IACH,sBAIC;IAED;;OAEG;IACH,uBAIC;IAED;;;;;;;;;;;OAWG;IACH,kBALG;QAA0B,UAAU,GAA5B,OAAO;QACW,YAAY,GAA9B,OAAO;QACW,aAAa,GAA/B,OAAO;QACW,cAAc,GAAhC,OAAO;KAA0B,QAI3C;IAED,gCAmBC;CACF;mBArcgC,UAAU;uBACpB,cAAc"}

package/types/openai.d.ts

@@ -0,0 +1,2 @@
+export function toOpenAi(schema: any): any;
+//# sourceMappingURL=openai.d.ts.map

package/types/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../src/openai.js"],"names":[],"mappings":"AAaA,2CAiCC"}

package/types/tuple.d.ts

@@ -11,6 +11,60 @@ declare class TupleSchema extends Schema {
     constructor(schemas: any);
     setup(): void;
     loose(): this;
+    toArray(): {
+        setup(): void;
+        length(length: any): /*elided*/ any;
+        min(length: any): /*elided*/ any;
+        max(length: any): /*elided*/ any;
+        latlng(): /*elided*/ any;
+        transform(fn: Function, root?: boolean): /*elided*/ any;
+        set(path: string | Array<string>, fn: Function): /*elided*/ any;
+        toString(): string;
+        toJsonSchema(options: any): any;
+        format(name: any, fn: any): /*elided*/ any;
+        assertions: any[];
+        meta: {};
+        required(allow?: boolean): /*elided*/ any;
+        default(arg: any): /*elided*/ any;
+        custom(fn: Function): /*elided*/ any;
+        missing(fn: Function): /*elided*/ any;
+        strip(strip: any): /*elided*/ any;
+        allow(...set: any[]): /*elided*/ any;
+        reject(...set: any[]): /*elided*/ any;
+        nullable(allow?: boolean): /*elided*/ any;
+        message(message: any): /*elided*/ any;
+        tag(tags: any): /*elided*/ any;
+        description(description: any): /*elided*/ any;
+        options(options: any): /*elided*/ any;
+        validate(value: any, options?: {}): Promise<any>;
+        clone(meta: any): /*elided*/ any;
+        append(schema: any): Schema;
+        toOpenApi(options: any): any;
+        toOpenAi(): /*elided*/ any;
+        toJSON(): any;
+        getType(): {
+            type: any;
+        };
+        getFormat(): {
+            format: any;
+        };
+        getDefault(): {
+            default?: undefined;
+        } | {
+            default: any;
+        };
+        getEnum(options: any): any;
+        getTags(options?: {}): any;
+        inspect(): string;
+        get(): void;
+        assertEnum(set: any, allow: any): /*elided*/ any;
+        assert(type: any, fn: any): /*elided*/ any;
+        pushAssertion(assertion: any): void;
+        canSkipAssertion(value: any, assertion: any, options: any): any;
+        transformValue(fn: any): /*elided*/ any;
+        getSortIndex(type: any): number;
+        runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
+    };
     toJsonSchema(options: any): any;
 }
 export {};

package/types/tuple.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../src/tuple.js"],"names":[],"mappings":"AAkFA;;;;;;GAMG;AACH,6CAJc,MAAM,EAAA,eASnB;mBA9FkB,UAAU;AAG7B;IACE,0BAGC;IAED,cAoDC;IAED,cAEC;IAMD,gCAQC;CACF"}
+{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../src/tuple.js"],"names":[],"mappings":"AAgGA;;;;;;GAMG;AACH,6CAJc,MAAM,EAAA,eASnB;mBA1GkB,UAAU;AAI7B;IACE,0BAGC;IAED,cAoDC;IAED,cAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAQC;IAMD,gCASC;CACF"}

package/dist/cjs/formats.js

@@ -1,28 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isAllowedFormat = isAllowedFormat;
-exports.isOpenAiAllowedFormat = isOpenAiAllowedFormat;
-// Confirmed working as of: 2025-11-11
-// Tested with gpt-5-nano-2025-08-07
-const OPENAI_ALLOWED_FORMATS = ['date-time', 'date', 'time', 'email', 'hostname', 'ipv4', 'ipv6', 'uuid'];
-function isAllowedFormat(format, options = {}) {
-  const {
-    style
-  } = options;
-  if (style === 'openai') {
-    // OpenAI schema inputs will fail on unknown formats.
-    // However these formats also offer useful guides for
-    // the LLM so we want to keep them as much as possible.
-    return isOpenAiAllowedFormat(format);
-  } else if (format) {
-    // JSON Schema has pre-defined types but also allows
-    // custom formats so by default allow any format.
-    return true;
-  }
-}
-function isOpenAiAllowedFormat(format) {
-  return OPENAI_ALLOWED_FORMATS.includes(format);
-}

package/src/formats.js

@@ -1,30 +0,0 @@
-// Confirmed working as of: 2025-11-11
-// Tested with gpt-5-nano-2025-08-07
-const OPENAI_ALLOWED_FORMATS = [
-  'date-time',
-  'date',
-  'time',
-  'email',
-  'hostname',
-  'ipv4',
-  'ipv6',
-  'uuid',
-];
-
-export function isAllowedFormat(format, options = {}) {
-  const { style } = options;
-  if (style === 'openai') {
-    // OpenAI schema inputs will fail on unknown formats.
-    // However these formats also offer useful guides for
-    // the LLM so we want to keep them as much as possible.
-    return isOpenAiAllowedFormat(format);
-  } else if (format) {
-    // JSON Schema has pre-defined types but also allows
-    // custom formats so by default allow any format.
-    return true;
-  }
-}
-
-export function isOpenAiAllowedFormat(format) {
-  return OPENAI_ALLOWED_FORMATS.includes(format);
-}