@contractspec/lib.schema 1.57.0 → 1.59.0

package/dist/SchemaModel.js

@@ -1,58 +1,31 @@
-import "./EnumType.js";
-import "./FieldType.js";
-import * as z$1 from "zod";
+// @bun
+// src/SchemaModel.ts
+import * as z from "zod";
 
-//#region src/SchemaModel.ts
-/**
-* Named object model built from FieldType/EnumType/SchemaModel fields.
-* Provides zod and GraphQL input helpers, and supports arrays/optional fields.
-*/
-var SchemaModel = class {
-	constructor(config) {
-		this.config = config;
-	}
-	/**
-	* Build a typed ZodObject from the model fields, preserving each field's
-	* Zod schema and optionality at the type level when possible.
-	*/
-	getZod() {
-		const shape = Object.entries(this.config.fields).reduce((acc, [key, def]) => {
-			const base = def.type.getZod();
-			const withArray = def.isArray ? z$1.array(base) : base;
-			acc[key] = def.isOptional ? withArray.optional() : withArray;
-			return acc;
-		}, {});
-		return z$1.object(shape);
-	}
-	/** Input object name for GraphQL builder adapters. */
-	getPothosInput() {
-		return this.config.name;
-	}
-};
-/**
-* Type guard to check if a value is a SchemaModel (not just any SchemaType).
-* Use this when you need to access SchemaModel-specific properties like `config`.
-*
-* @param model - The model to check
-* @returns True if the model is a SchemaModel instance
-*
-* @example
-* ```typescript
-* if (isSchemaModel(model)) {
-*   // TypeScript knows model.config is available
-*   console.log(model.config.name);
-* }
-* ```
-*/
+class SchemaModel {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getZod() {
+    const shape = Object.entries(this.config.fields).reduce((acc, [key, def]) => {
+      const base = def.type.getZod();
+      const withArray = def.isArray ? z.array(base) : base;
+      acc[key] = def.isOptional ? withArray.optional() : withArray;
+      return acc;
+    }, {});
+    return z.object(shape);
+  }
+  getPothosInput() {
+    return this.config.name;
+  }
+}
 function isSchemaModel(model) {
-	return model !== null && model !== void 0 && "config" in model && typeof model.config === "object" && "name" in model.config;
+  return model !== null && model !== undefined && "config" in model && typeof model.config === "object" && "name" in model.config;
 }
-/**
-* Helper to define a SchemaModel with type inference.
-* Equivalent to `new SchemaModel(config)` but with better ergonomics.
-*/
-const defineSchemaModel = (config) => new SchemaModel(config);
-
-//#endregion
-export { SchemaModel, defineSchemaModel, isSchemaModel };
-//# sourceMappingURL=SchemaModel.js.map
+var defineSchemaModel = (config) => new SchemaModel(config);
+export {
+  isSchemaModel,
+  defineSchemaModel,
+  SchemaModel
+};

package/dist/SchemaModel.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SchemaModel.test.d.ts.map

package/dist/SchemaModel.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaModel.test.d.ts","sourceRoot":"","sources":["../src/SchemaModel.test.ts"],"names":[],"mappings":""}

package/dist/SchemaModelType.d.ts

@@ -1,10 +1,16 @@
-import * as z$1 from "zod";
-
-//#region src/SchemaModelType.d.ts
+/**
+ * Unified schema type interface for ContractSpec.
+ *
+ * This module provides a vendor-agnostic abstraction over different schema
+ * definition approaches (SchemaModel, Zod, JSON Schema, GraphQL scalars).
+ *
+ * @module SchemaType
+ */
+import type * as z from 'zod';
 /**
  * Supported schema output formats for code generation.
  */
-type SchemaFormat = 'contractspec' | 'zod' | 'json-schema' | 'graphql';
+export type SchemaFormat = 'contractspec' | 'zod' | 'json-schema' | 'graphql';
 /**
  * Unified interface for all schema-compatible types.
  * Any type used in ContractSpec schemas must implement this interface.
@@ -19,22 +25,22 @@ type SchemaFormat = 'contractspec' | 'zod' | 'json-schema' | 'graphql';
  * const zodWrapper = fromZod(z.object({ name: z.string() }));
  * ```
  */
-interface SchemaModelType<T = unknown> {
-  /**
-   * Return the Zod schema for runtime validation.
-   * This is the primary method - all schema types must provide Zod conversion.
-   */
-  getZod(): z$1.ZodType<T>;
-  /**
-   * Return GraphQL type info for Pothos/GraphQL integration.
-   * Optional - types without GraphQL representation return undefined.
-   */
-  getPothos?(): unknown;
-  /**
-   * Return JSON Schema representation.
-   * Optional - types without JSON Schema representation return undefined.
-   */
-  getJsonSchema?(): unknown;
+export interface SchemaModelType<T = unknown> {
+    /**
+     * Return the Zod schema for runtime validation.
+     * This is the primary method - all schema types must provide Zod conversion.
+     */
+    getZod(): z.ZodType<T>;
+    /**
+     * Return GraphQL type info for Pothos/GraphQL integration.
+     * Optional - types without GraphQL representation return undefined.
+     */
+    getPothos?(): unknown;
+    /**
+     * Return JSON Schema representation.
+     * Optional - types without JSON Schema representation return undefined.
+     */
+    getJsonSchema?(): unknown;
 }
 /**
  * Type guard to check if a value implements the SchemaType interface.
@@ -49,11 +55,9 @@ interface SchemaModelType<T = unknown> {
  * }
  * ```
  */
-declare function isSchemaType(value: unknown): value is SchemaModelType;
+export declare function isSchemaType(value: unknown): value is SchemaModelType;
 /**
  * Type alias for any SchemaType implementation.
  */
-type AnySchemaType = SchemaModelType<unknown>;
-//#endregion
-export { AnySchemaType, SchemaFormat, SchemaModelType, isSchemaType };
+export type AnySchemaType = SchemaModelType<unknown>;
 //# sourceMappingURL=SchemaModelType.d.ts.map

package/dist/SchemaModelType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SchemaModelType.d.ts","names":[],"sources":["../src/SchemaModelType.ts"],"mappings":";;;;;;KAcY,YAAA;;;;;;;;;AAiDZ;;;;;;UAjCiB,eAAA;EAiCqD;;AAYtE;;EAxCE,MAAA,IAAU,GAAA,CAAE,OAAA,CAAQ,CAAA;EAwCM;;;;EAlC1B,SAAA;;;;;EAMA,aAAA;AAAA;;;;;;;;;;;;;;iBAgBc,YAAA,CAAa,KAAA,YAAiB,KAAA,IAAS,eAAA;;;;KAY3C,aAAA,GAAgB,eAAA"}
+{"version":3,"file":"SchemaModelType.d.ts","sourceRoot":"","sources":["../src/SchemaModelType.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,KAAK,CAAC,MAAM,KAAK,CAAC;AAE9B;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,cAAc,GAAG,KAAK,GAAG,aAAa,GAAG,SAAS,CAAC;AAE9E;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAC1C;;;OAGG;IACH,MAAM,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAEvB;;;OAGG;IACH,SAAS,CAAC,IAAI,OAAO,CAAC;IAEtB;;;OAGG;IACH,aAAa,CAAC,IAAI,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAOrE;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC"}

package/dist/SchemaModelType.js

@@ -1,21 +1,8 @@
-//#region src/SchemaModelType.ts
-/**
-* Type guard to check if a value implements the SchemaType interface.
-*
-* @param value - Value to check
-* @returns True if value has a getZod method
-*
-* @example
-* ```typescript
-* if (isSchemaType(field.type)) {
-*   const zodSchema = field.type.getZod();
-* }
-* ```
-*/
+// @bun
+// src/SchemaModelType.ts
 function isSchemaType(value) {
-	return value !== null && typeof value === "object" && "getZod" in value && typeof value.getZod === "function";
+  return value !== null && typeof value === "object" && "getZod" in value && typeof value.getZod === "function";
 }
-
-//#endregion
-export { isSchemaType };
-//# sourceMappingURL=SchemaModelType.js.map
+export {
+  isSchemaType
+};

package/dist/SchemaModelType.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SchemaModelType.test.d.ts.map

package/dist/SchemaModelType.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaModelType.test.d.ts","sourceRoot":"","sources":["../src/SchemaModelType.test.ts"],"names":[],"mappings":""}

package/dist/ZodSchemaType.d.ts

@@ -1,15 +1,21 @@
-import { SchemaModelType } from "./SchemaModelType.js";
-import * as z$1 from "zod";
-
-//#region src/ZodSchemaType.d.ts
+/**
+ * Zod schema wrapper for ContractSpec compatibility.
+ *
+ * Wraps raw Zod schemas to implement the SchemaType interface,
+ * enabling direct Zod usage in ContractSpec definitions.
+ *
+ * @module ZodSchemaType
+ */
+import * as z from 'zod';
+import type { SchemaModelType } from './SchemaModelType';
 /**
  * Options for ZodSchemaType wrapper.
  */
-interface ZodSchemaTypeOptions {
-  /** Name for GraphQL/JSON Schema representation */
-  name?: string;
-  /** Description for documentation */
-  description?: string;
+export interface ZodSchemaTypeOptions {
+    /** Name for GraphQL/JSON Schema representation */
+    name?: string;
+    /** Description for documentation */
+    description?: string;
 }
 /**
  * Wrapper to use a raw Zod schema as a SchemaType.
@@ -37,34 +43,34 @@ interface ZodSchemaTypeOptions {
  * });
  * ```
  */
-declare class ZodSchemaType<T extends z$1.ZodType> implements SchemaModelType<z$1.infer<T>> {
-  private readonly schema;
-  private readonly options;
-  constructor(schema: T, options?: ZodSchemaTypeOptions);
-  /**
-   * Return the wrapped Zod schema.
-   */
-  getZod(): z$1.ZodType<z$1.infer<T>>;
-  /**
-   * Return JSON Schema representation using Zod's toJSONSchema.
-   */
-  getJsonSchema(): unknown;
-  /**
-   * Return GraphQL type info.
-   * For complex Zod types, defaults to JSON scalar.
-   */
-  getPothos(): {
-    type: string;
-    name?: string;
-  };
-  /**
-   * Get the configured name for this schema.
-   */
-  getName(): string | undefined;
-  /**
-   * Get the configured description for this schema.
-   */
-  getDescription(): string | undefined;
+export declare class ZodSchemaType<T extends z.ZodType> implements SchemaModelType<z.infer<T>> {
+    private readonly schema;
+    private readonly options;
+    constructor(schema: T, options?: ZodSchemaTypeOptions);
+    /**
+     * Return the wrapped Zod schema.
+     */
+    getZod(): z.ZodType<z.infer<T>>;
+    /**
+     * Return JSON Schema representation using Zod's toJSONSchema.
+     */
+    getJsonSchema(): unknown;
+    /**
+     * Return GraphQL type info.
+     * For complex Zod types, defaults to JSON scalar.
+     */
+    getPothos(): {
+        type: string;
+        name?: string;
+    };
+    /**
+     * Get the configured name for this schema.
+     */
+    getName(): string | undefined;
+    /**
+     * Get the configured description for this schema.
+     */
+    getDescription(): string | undefined;
 }
 /**
  * Helper to wrap a raw Zod schema as a SchemaType.
@@ -85,7 +91,5 @@ declare class ZodSchemaType<T extends z$1.ZodType> implements SchemaModelType<z$
  * );
  * ```
  */
-declare const fromZod: <T extends z$1.ZodType>(schema: T, options?: ZodSchemaTypeOptions) => ZodSchemaType<T>;
-//#endregion
-export { ZodSchemaType, ZodSchemaTypeOptions, fromZod };
+export declare const fromZod: <T extends z.ZodType>(schema: T, options?: ZodSchemaTypeOptions) => ZodSchemaType<T>;
 //# sourceMappingURL=ZodSchemaType.d.ts.map

package/dist/ZodSchemaType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ZodSchemaType.d.ts","names":[],"sources":["../src/ZodSchemaType.ts"],"mappings":";;;;;;;UAeiB,oBAAA;EAkCf;EAhCA,IAAA;EAqCgC;EAnChC,WAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BW,aAAA,WAAwB,GAAA,CAAE,OAAA,aAAoB,eAAA,CACzD,GAAA,CAAE,KAAA,CAAM,CAAA;EAAA,iBAES,MAAA;EAAA,iBACA,OAAA;cAEL,MAAA,EAAQ,CAAA,EAAG,OAAA,GAAS,oBAAA;EAqClB;;AAwBhB;EArDE,MAAA,CAAA,GAAU,GAAA,CAAE,OAAA,CAAQ,GAAA,CAAE,KAAA,CAAM,CAAA;EAwD2B;;;EAjDvD,aAAA,CAAA;EAiDe;;;;EAzCf,SAAA,CAAA;IAAe,IAAA;IAAc,IAAA;EAAA;EAuC7B;;;EAhCA,OAAA,CAAA;EAkCe;;;EA3Bf,cAAA,CAAA;AAAA;;;;;;;;;;;;;;;;;;;;cAwBW,OAAA,aAAqB,GAAA,CAAE,OAAA,EAClC,MAAA,EAAQ,CAAA,EACR,OAAA,GAAU,oBAAA,KACT,aAAA,CAAc,CAAA"}
+{"version":3,"file":"ZodSchemaType.d.ts","sourceRoot":"","sources":["../src/ZodSchemaType.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,aAAa,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,CAAE,YAAW,eAAe,CACxE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CACX;IACC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAI;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;gBAEnC,MAAM,EAAE,CAAC,EAAE,OAAO,GAAE,oBAAyB;IAKzD;;OAEG;IACH,MAAM,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAI/B;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;;OAGG;IACH,SAAS,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE;IAI5C;;OAEG;IACH,OAAO,IAAI,MAAM,GAAG,SAAS;IAI7B;;OAEG;IACH,cAAc,IAAI,MAAM,GAAG,SAAS;CAGrC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EACzC,QAAQ,CAAC,EACT,UAAU,oBAAoB,KAC7B,aAAa,CAAC,CAAC,CAAuC,CAAC"}

package/dist/ZodSchemaType.js

@@ -1,103 +1,32 @@
-import * as z$1 from "zod";
+// @bun
+// src/ZodSchemaType.ts
+import * as z from "zod";
 
-//#region src/ZodSchemaType.ts
-/**
-* Zod schema wrapper for ContractSpec compatibility.
-*
-* Wraps raw Zod schemas to implement the SchemaType interface,
-* enabling direct Zod usage in ContractSpec definitions.
-*
-* @module ZodSchemaType
-*/
-/**
-* Wrapper to use a raw Zod schema as a SchemaType.
-* Enables schema definition directly with Zod for maximum flexibility.
-*
-* @template T - The Zod schema type being wrapped
-*
-* @example
-* ```typescript
-* const UserSchema = fromZod(
-*   z.object({
-*     id: z.string().uuid(),
-*     name: z.string().min(1),
-*     email: z.string().email(),
-*   }),
-*   { name: 'User' }
-* );
-*
-* // Use in SchemaModel
-* const CreateUserInput = new SchemaModel({
-*   name: 'CreateUserInput',
-*   fields: {
-*     user: { type: UserSchema, isOptional: false },
-*   },
-* });
-* ```
-*/
-var ZodSchemaType = class {
-	schema;
-	options;
-	constructor(schema, options = {}) {
-		this.schema = schema;
-		this.options = options;
-	}
-	/**
-	* Return the wrapped Zod schema.
-	*/
-	getZod() {
-		return this.schema;
-	}
-	/**
-	* Return JSON Schema representation using Zod's toJSONSchema.
-	*/
-	getJsonSchema() {
-		return z$1.toJSONSchema(this.schema);
-	}
-	/**
-	* Return GraphQL type info.
-	* For complex Zod types, defaults to JSON scalar.
-	*/
-	getPothos() {
-		return {
-			type: "JSON",
-			name: this.options.name
-		};
-	}
-	/**
-	* Get the configured name for this schema.
-	*/
-	getName() {
-		return this.options.name;
-	}
-	/**
-	* Get the configured description for this schema.
-	*/
-	getDescription() {
-		return this.options.description;
-	}
+class ZodSchemaType {
+  schema;
+  options;
+  constructor(schema, options = {}) {
+    this.schema = schema;
+    this.options = options;
+  }
+  getZod() {
+    return this.schema;
+  }
+  getJsonSchema() {
+    return z.toJSONSchema(this.schema);
+  }
+  getPothos() {
+    return { type: "JSON", name: this.options.name };
+  }
+  getName() {
+    return this.options.name;
+  }
+  getDescription() {
+    return this.options.description;
+  }
+}
+var fromZod = (schema, options) => new ZodSchemaType(schema, options);
+export {
+  fromZod,
+  ZodSchemaType
 };
-/**
-* Helper to wrap a raw Zod schema as a SchemaType.
-*
-* @param schema - The Zod schema to wrap
-* @param options - Optional configuration
-* @returns A SchemaType-compatible wrapper
-*
-* @example
-* ```typescript
-* const AddressSchema = fromZod(
-*   z.object({
-*     street: z.string(),
-*     city: z.string(),
-*     country: z.string(),
-*   }),
-*   { name: 'Address', description: 'Physical address' }
-* );
-* ```
-*/
-const fromZod = (schema, options) => new ZodSchemaType(schema, options);
-
-//#endregion
-export { ZodSchemaType, fromZod };
-//# sourceMappingURL=ZodSchemaType.js.map

package/dist/ZodSchemaType.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ZodSchemaType.test.d.ts.map

package/dist/ZodSchemaType.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZodSchemaType.test.d.ts","sourceRoot":"","sources":["../src/ZodSchemaType.test.ts"],"names":[],"mappings":""}

package/dist/browser/EnumType.js

@@ -0,0 +1,40 @@
+// src/EnumType.ts
+import * as z from "zod";
+import { GraphQLEnumType } from "graphql";
+
+class EnumType {
+  name;
+  values;
+  gqlEnum;
+  constructor(name, values) {
+    this.name = name;
+    this.values = values;
+    this.gqlEnum = new GraphQLEnumType({
+      name: this.name,
+      values: Object.fromEntries(values.map((v) => [v, { value: v }]))
+    });
+  }
+  getName() {
+    return this.name;
+  }
+  getEnumValues() {
+    return this.values;
+  }
+  getPothos() {
+    return this.gqlEnum;
+  }
+  getZod() {
+    return z.enum(this.values);
+  }
+  getJson() {
+    return { type: "string", enum: this.values };
+  }
+  getJsonSchema() {
+    return this.getJson();
+  }
+}
+var defineEnum = (name, values) => new EnumType(name, values);
+export {
+  defineEnum,
+  EnumType
+};

package/dist/browser/FieldType.js

@@ -0,0 +1,43 @@
+// src/FieldType.ts
+import { GraphQLScalarType } from "graphql";
+
+class FieldType extends GraphQLScalarType {
+  zodSchema;
+  jsonSchemaDef;
+  constructor(config) {
+    super(config);
+    this.zodSchema = config.zod;
+    this.jsonSchemaDef = config.jsonSchema;
+  }
+  getZod() {
+    return this.zodSchema;
+  }
+  getPothos() {
+    return this;
+  }
+  getJson() {
+    return typeof this.jsonSchemaDef === "function" ? this.jsonSchemaDef() : this.jsonSchemaDef;
+  }
+  getJsonSchemaDef() {
+    return this.jsonSchemaDef;
+  }
+  getJsonSchema() {
+    const deepResolve = (v) => {
+      const value = typeof v === "function" ? v() : v;
+      if (Array.isArray(value))
+        return value.map((item) => deepResolve(item));
+      if (value && typeof value === "object") {
+        const obj = {};
+        for (const [k, val] of Object.entries(value)) {
+          obj[k] = deepResolve(val);
+        }
+        return obj;
+      }
+      return value;
+    };
+    return deepResolve(this.getJson());
+  }
+}
+export {
+  FieldType
+};

package/dist/browser/GraphQLSchemaType.js

@@ -0,0 +1,18 @@
+// src/GraphQLSchemaType.ts
+import { z } from "zod";
+
+class GraphQLSchemaType {
+  typeDef;
+  name;
+  _isSchemaType = true;
+  constructor(typeDef, name) {
+    this.typeDef = typeDef;
+    this.name = name;
+  }
+  getZod() {
+    return z.unknown();
+  }
+}
+export {
+  GraphQLSchemaType
+};

package/dist/browser/JsonSchemaType.js

@@ -0,0 +1,74 @@
+// src/JsonSchemaType.ts
+import * as z from "zod";
+
+class JsonSchemaType {
+  jsonSchema;
+  options;
+  constructor(jsonSchema, options = {}) {
+    this.jsonSchema = jsonSchema;
+    this.options = options;
+  }
+  getZod() {
+    if (this.jsonSchema.additionalProperties !== undefined) {
+      if (this.jsonSchema.additionalProperties === true) {
+        return z.record(z.string(), z.unknown());
+      }
+      if (typeof this.jsonSchema.additionalProperties === "object") {
+        return z.record(z.string(), z.unknown());
+      }
+      if (this.jsonSchema.additionalProperties === false) {
+        return z.object({}).strict();
+      }
+    }
+    if (this.jsonSchema.properties) {
+      const shape = {};
+      const required = new Set(this.jsonSchema.required ?? []);
+      for (const [key, propSchema] of Object.entries(this.jsonSchema.properties)) {
+        const fieldType = this.convertPropertyToZod(propSchema);
+        shape[key] = required.has(key) ? fieldType : fieldType.optional();
+      }
+      return z.object(shape).passthrough();
+    }
+    return z.object({}).passthrough();
+  }
+  getJsonSchema() {
+    return this.jsonSchema;
+  }
+  getPothos() {
+    return { type: "JSON", name: this.options.name };
+  }
+  getName() {
+    return this.options.name;
+  }
+  convertPropertyToZod(schema) {
+    const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+    switch (type) {
+      case "string":
+        return z.string();
+      case "number":
+      case "integer":
+        return z.number();
+      case "boolean":
+        return z.boolean();
+      case "array":
+        if (schema.items && !Array.isArray(schema.items)) {
+          return z.array(this.convertPropertyToZod(schema.items));
+        }
+        return z.array(z.unknown());
+      case "object":
+        if (schema.properties) {
+          return new JsonSchemaType(schema).getZod();
+        }
+        return z.record(z.string(), z.unknown());
+      case "null":
+        return z.null();
+      default:
+        return z.unknown();
+    }
+  }
+}
+var fromJsonSchema = (schema, options) => new JsonSchemaType(schema, options);
+export {
+  fromJsonSchema,
+  JsonSchemaType
+};