@contractspec/lib.schema 1.44.0

package/dist/JsonSchemaType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonSchemaType.js","names":["z","shape: Record<string, z.ZodType>"],"sources":["../src/JsonSchemaType.ts"],"sourcesContent":["/**\n * JSON Schema wrapper for ContractSpec compatibility.\n *\n * Wraps JSON Schema definitions to implement the SchemaType interface,\n * enabling direct JSON Schema usage in ContractSpec definitions.\n *\n * @module JsonSchemaType\n */\n\nimport * as z from 'zod';\nimport type { SchemaModelType } from './SchemaModelType';\n\n/**\n * JSON Schema definition structure.\n * Supports standard JSON Schema draft-07/2020-12 properties.\n */\nexport interface JsonSchemaDefinition {\n  type?: string | string[];\n  properties?: Record<string, JsonSchemaDefinition>;\n  required?: string[];\n  additionalProperties?: boolean | JsonSchemaDefinition;\n  items?: JsonSchemaDefinition | JsonSchemaDefinition[];\n  enum?: unknown[];\n  const?: unknown;\n  oneOf?: JsonSchemaDefinition[];\n  anyOf?: JsonSchemaDefinition[];\n  allOf?: JsonSchemaDefinition[];\n  $ref?: string;\n  title?: string;\n  description?: string;\n  default?: unknown;\n  format?: string;\n  minimum?: number;\n  maximum?: number;\n  minLength?: number;\n  maxLength?: number;\n  pattern?: string;\n  [key: string]: unknown;\n}\n\n/**\n * Options for JsonSchemaType wrapper.\n */\nexport interface JsonSchemaTypeOptions {\n  /** Name for identification */\n  name?: string;\n}\n\n/**\n * Wrapper to use JSON Schema as a SchemaType.\n * Converts to Zod at runtime for validation.\n *\n * @example\n * ```typescript\n * const CustomFieldsSchema = fromJsonSchema({\n *   type: 'object',\n *   additionalProperties: {\n *     oneOf: [\n *       { type: 'string' },\n *       { type: 'number' },\n *       { type: 'boolean' },\n *     ],\n *   },\n * }, { name: 'CustomFields' });\n * ```\n */\nexport class JsonSchemaType implements SchemaModelType<\n  Record<string, unknown>\n> {\n  private readonly jsonSchema: JsonSchemaDefinition;\n  private readonly options: JsonSchemaTypeOptions;\n\n  constructor(\n    jsonSchema: JsonSchemaDefinition,\n    options: JsonSchemaTypeOptions = {}\n  ) {\n    this.jsonSchema = jsonSchema;\n    this.options = options;\n  }\n\n  /**\n   * Convert JSON Schema to Zod schema for runtime validation.\n   *\n   * Note: This is a simplified conversion. For complex schemas,\n   * consider using a dedicated json-schema-to-zod library.\n   */\n  getZod(): z.ZodType<Record<string, unknown>> {\n    // Handle additionalProperties (dictionary/record types)\n    if (this.jsonSchema.additionalProperties !== undefined) {\n      if (this.jsonSchema.additionalProperties === true) {\n        return z.record(z.string(), z.unknown());\n      }\n      if (typeof this.jsonSchema.additionalProperties === 'object') {\n        // For typed additionalProperties, use union or unknown\n        return z.record(z.string(), z.unknown());\n      }\n      if (this.jsonSchema.additionalProperties === false) {\n        return z.object({}).strict();\n      }\n    }\n\n    // Handle explicit properties\n    if (this.jsonSchema.properties) {\n      const shape: Record<string, z.ZodType> = {};\n      const required = new Set(this.jsonSchema.required ?? []);\n\n      for (const [key, propSchema] of Object.entries(\n        this.jsonSchema.properties\n      )) {\n        const fieldType = this.convertPropertyToZod(propSchema);\n        shape[key] = required.has(key) ? fieldType : fieldType.optional();\n      }\n\n      return z.object(shape).passthrough();\n    }\n\n    // Default: passthrough object\n    return z.object({}).passthrough();\n  }\n\n  /**\n   * Return the original JSON Schema.\n   */\n  getJsonSchema(): JsonSchemaDefinition {\n    return this.jsonSchema;\n  }\n\n  /**\n   * Return GraphQL type info.\n   * JSON Schema types map to JSON scalar in GraphQL.\n   */\n  getPothos(): { type: string; name?: string } {\n    return { type: 'JSON', name: this.options.name };\n  }\n\n  /**\n   * Get the configured name for this schema.\n   */\n  getName(): string | undefined {\n    return this.options.name;\n  }\n\n  /**\n   * Convert a single JSON Schema property to Zod.\n   */\n  private convertPropertyToZod(schema: JsonSchemaDefinition): z.ZodType {\n    const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;\n\n    switch (type) {\n      case 'string':\n        return z.string();\n      case 'number':\n      case 'integer':\n        return z.number();\n      case 'boolean':\n        return z.boolean();\n      case 'array':\n        if (schema.items && !Array.isArray(schema.items)) {\n          return z.array(this.convertPropertyToZod(schema.items));\n        }\n        return z.array(z.unknown());\n      case 'object':\n        if (schema.properties) {\n          return new JsonSchemaType(schema).getZod();\n        }\n        return z.record(z.string(), z.unknown());\n      case 'null':\n        return z.null();\n      default:\n        return z.unknown();\n    }\n  }\n}\n\n/**\n * Helper to create a SchemaType from JSON Schema.\n *\n * @param schema - The JSON Schema definition\n * @param options - Optional configuration\n * @returns A SchemaType-compatible wrapper\n *\n * @example\n * ```typescript\n * const MetadataSchema = fromJsonSchema({\n *   type: 'object',\n *   properties: {\n *     createdAt: { type: 'string', format: 'date-time' },\n *     updatedAt: { type: 'string', format: 'date-time' },\n *   },\n *   required: ['createdAt'],\n * });\n * ```\n */\nexport const fromJsonSchema = (\n  schema: JsonSchemaDefinition,\n  options?: JsonSchemaTypeOptions\n): JsonSchemaType => new JsonSchemaType(schema, options);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,iBAAb,MAAa,eAEX;CACA,AAAiB;CACjB,AAAiB;CAEjB,YACE,YACA,UAAiC,EAAE,EACnC;AACA,OAAK,aAAa;AAClB,OAAK,UAAU;;;;;;;;CASjB,SAA6C;AAE3C,MAAI,KAAK,WAAW,yBAAyB,QAAW;AACtD,OAAI,KAAK,WAAW,yBAAyB,KAC3C,QAAOA,IAAE,OAAOA,IAAE,QAAQ,EAAEA,IAAE,SAAS,CAAC;AAE1C,OAAI,OAAO,KAAK,WAAW,yBAAyB,SAElD,QAAOA,IAAE,OAAOA,IAAE,QAAQ,EAAEA,IAAE,SAAS,CAAC;AAE1C,OAAI,KAAK,WAAW,yBAAyB,MAC3C,QAAOA,IAAE,OAAO,EAAE,CAAC,CAAC,QAAQ;;AAKhC,MAAI,KAAK,WAAW,YAAY;GAC9B,MAAMC,QAAmC,EAAE;GAC3C,MAAM,WAAW,IAAI,IAAI,KAAK,WAAW,YAAY,EAAE,CAAC;AAExD,QAAK,MAAM,CAAC,KAAK,eAAe,OAAO,QACrC,KAAK,WAAW,WACjB,EAAE;IACD,MAAM,YAAY,KAAK,qBAAqB,WAAW;AACvD,UAAM,OAAO,SAAS,IAAI,IAAI,GAAG,YAAY,UAAU,UAAU;;AAGnE,UAAOD,IAAE,OAAO,MAAM,CAAC,aAAa;;AAItC,SAAOA,IAAE,OAAO,EAAE,CAAC,CAAC,aAAa;;;;;CAMnC,gBAAsC;AACpC,SAAO,KAAK;;;;;;CAOd,YAA6C;AAC3C,SAAO;GAAE,MAAM;GAAQ,MAAM,KAAK,QAAQ;GAAM;;;;;CAMlD,UAA8B;AAC5B,SAAO,KAAK,QAAQ;;;;;CAMtB,AAAQ,qBAAqB,QAAyC;AAGpE,UAFa,MAAM,QAAQ,OAAO,KAAK,GAAG,OAAO,KAAK,KAAK,OAAO,MAElE;GACE,KAAK,SACH,QAAOA,IAAE,QAAQ;GACnB,KAAK;GACL,KAAK,UACH,QAAOA,IAAE,QAAQ;GACnB,KAAK,UACH,QAAOA,IAAE,SAAS;GACpB,KAAK;AACH,QAAI,OAAO,SAAS,CAAC,MAAM,QAAQ,OAAO,MAAM,CAC9C,QAAOA,IAAE,MAAM,KAAK,qBAAqB,OAAO,MAAM,CAAC;AAEzD,WAAOA,IAAE,MAAMA,IAAE,SAAS,CAAC;GAC7B,KAAK;AACH,QAAI,OAAO,WACT,QAAO,IAAI,eAAe,OAAO,CAAC,QAAQ;AAE5C,WAAOA,IAAE,OAAOA,IAAE,QAAQ,EAAEA,IAAE,SAAS,CAAC;GAC1C,KAAK,OACH,QAAOA,IAAE,MAAM;GACjB,QACE,QAAOA,IAAE,SAAS;;;;;;;;;;;;;;;;;;;;;;;AAwB1B,MAAa,kBACX,QACA,YACmB,IAAI,eAAe,QAAQ,QAAQ"}

package/dist/ScalarTypeEnum.d.ts

@@ -0,0 +1,33 @@
+import { FieldType } from "./FieldType.js";
+
+//#region src/ScalarTypeEnum.d.ts
+
+/**
+ * Factory functions for common scalar FieldTypes with zod/GraphQL/JSON Schema.
+ */
+declare const ScalarTypeEnum: {
+  readonly String_unsecure: () => FieldType<string>;
+  readonly Int_unsecure: () => FieldType<number>;
+  readonly Float_unsecure: () => FieldType<number>;
+  readonly Boolean: () => FieldType<boolean>;
+  readonly ID: () => FieldType<string>;
+  readonly JSON: () => FieldType<unknown>;
+  readonly JSONObject: () => FieldType<Record<string, unknown>>;
+  readonly Date: () => FieldType<Date, string>;
+  readonly DateTime: () => FieldType<Date, string>;
+  readonly Time: () => FieldType<string>;
+  readonly EmailAddress: () => FieldType<string>;
+  readonly URL: () => FieldType<string>;
+  readonly PhoneNumber: () => FieldType<string>;
+  readonly NonEmptyString: () => FieldType<string>;
+  readonly Locale: () => FieldType<string>;
+  readonly TimeZone: () => FieldType<string>;
+  readonly Latitude: () => FieldType<number>;
+  readonly Longitude: () => FieldType<number>;
+  readonly Currency: () => FieldType<string>;
+  readonly CountryCode: () => FieldType<string>;
+};
+type ScalarTypeEnum = [keyof typeof ScalarTypeEnum];
+//#endregion
+export { ScalarTypeEnum };
+//# sourceMappingURL=ScalarTypeEnum.d.ts.map

package/dist/ScalarTypeEnum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarTypeEnum.d.ts","names":[],"sources":["../src/ScalarTypeEnum.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AAEuB,cAFV,cAEU,EAAA;EAaH,SAAA,eAAA,EAAA,GAAA,GAbG,SAaH,CAAA,MAAA,CAAA;EAgBE,SAAA,YAAA,EAAA,GAAA,GAhBF,SAgBE,CAAA,MAAA,CAAA;EAiBP,SAAA,cAAA,EAAA,GAAA,GAjBO,SAiBP,CAAA,MAAA,CAAA;EAaL,SAAA,OAAA,EAAA,GAAA,GAbK,SAaL,CAAA,OAAA,CAAA;EAeE,SAAA,EAAA,EAAA,GAAA,GAfF,SAeE,CAAA,MAAA,CAAA;EAQgB,SAAA,IAAA,EAAA,GAAA,GARhB,SAQgB,CAAA,OAAA,CAAA;EAAV,SAAA,UAAA,EAAA,GAAA,GAAA,SAAA,CAAU,MAAV,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA;EAQI,SAAA,IAAA,EAAA,GAAA,GAAV,SAAU,CAAA,IAAA,EAAA,MAAA,CAAA;EAAV,SAAA,QAAA,EAAA,GAAA,GAUI,SAVJ,CAUc,IAVd,EAAA,MAAA,CAAA;EAUc,SAAA,IAAA,EAAA,GAAA,GAUd,SAVc,CAAA,MAAA,CAAA;EAAV,SAAA,YAAA,EAAA,GAAA,GAsBI,SAtBJ,CAAA,MAAA,CAAA;EAUJ,SAAA,GAAA,EAAA,GAAA,GAoBD,SApBC,CAAA,MAAA,CAAA;EAYQ,SAAA,WAAA,EAAA,GAAA,GAgBD,SAhBC,CAAA,MAAA,CAAA;EAQT,SAAA,cAAA,EAAA,GAAA,GAgBW,SAhBX,CAAA,MAAA,CAAA;EAQQ,SAAA,MAAA,EAAA,GAAA,GAgBL,SAhBK,CAAA,MAAA,CAAA;EAQG,SAAA,QAAA,EAAA,GAAA,GAgBN,SAhBM,CAAA,MAAA,CAAA;EAQR,SAAA,QAAA,EAAA,GAAA,GAgBE,SAhBF,CAAA,MAAA,CAAA;EAQE,SAAA,SAAA,EAAA,GAAA,GAgBC,SAhBD,CAAA,MAAA,CAAA;EAQA,SAAA,QAAA,EAAA,GAAA,GAgBA,SAhBA,CAAA,MAAA,CAAA;EAQC,SAAA,WAAA,EAAA,GAAA,GAgBE,SAhBF,CAAA,MAAA,CAAA;CAQD;AAQG,KAqBP,cAAA,GArBO,CAAA,MAAA,OAqBwB,cArBxB,CAAA"}

package/dist/ScalarTypeEnum.js

@@ -0,0 +1,237 @@
+import { FieldType } from "./FieldType.js";
+import * as z$1 from "zod";
+import { Kind } from "graphql";
+
+//#region src/ScalarTypeEnum.ts
+const localeRegex = /^[A-Za-z]{2}(?:-[A-Za-z0-9]{2,8})*$/;
+const timezoneRegex = /^(?:UTC|[A-Za-z_]+\/[A-Za-z_]+)$/;
+const phoneRegex = /^[+]?\d[\d\s().-]{3,}$/;
+const currencyRegex = /^[A-Z]{3}$/;
+const countryRegex = /^[A-Z]{2}$/;
+const latMin = -90;
+const latMax = 90;
+const lonMin = -180;
+const lonMax = 180;
+/**
+* Factory functions for common scalar FieldTypes with zod/GraphQL/JSON Schema.
+*/
+const ScalarTypeEnum = {
+	String_unsecure: () => new FieldType({
+		name: "String_unsecure",
+		description: "Unvalidated string scalar",
+		zod: z$1.string(),
+		parseValue: (v) => z$1.string().parse(v),
+		serialize: (v) => String(v),
+		parseLiteral: (ast) => {
+			if (ast.kind !== Kind.STRING) throw new TypeError("Invalid literal");
+			return ast.value;
+		},
+		jsonSchema: { type: "string" }
+	}),
+	Int_unsecure: () => new FieldType({
+		name: "Int_unsecure",
+		description: "Unvalidated integer scalar",
+		zod: z$1.number().int(),
+		parseValue: (v) => {
+			const num = typeof v === "number" ? v : Number(v);
+			return z$1.number().int().parse(num);
+		},
+		serialize: (v) => Math.trunc(typeof v === "number" ? v : Number(v)),
+		parseLiteral: (ast) => {
+			if (ast.kind !== Kind.INT) throw new TypeError("Invalid literal");
+			return Number(ast.value);
+		},
+		jsonSchema: { type: "integer" }
+	}),
+	Float_unsecure: () => new FieldType({
+		name: "Float_unsecure",
+		description: "Unvalidated float scalar",
+		zod: z$1.number(),
+		parseValue: (v) => {
+			const num = typeof v === "number" ? v : Number(v);
+			return z$1.number().parse(num);
+		},
+		serialize: (v) => Number(v),
+		parseLiteral: (ast) => {
+			if (ast.kind !== Kind.FLOAT && ast.kind !== Kind.INT) throw new TypeError("Invalid literal");
+			return Number(ast.value);
+		},
+		jsonSchema: { type: "number" }
+	}),
+	Boolean: () => new FieldType({
+		name: "Boolean",
+		description: "Unvalidated boolean scalar",
+		zod: z$1.boolean(),
+		parseValue: (v) => z$1.coerce.boolean().parse(v),
+		serialize: (v) => Boolean(v),
+		parseLiteral: (ast) => {
+			if (ast.kind !== Kind.BOOLEAN) throw new TypeError("Invalid literal");
+			return ast.value;
+		},
+		jsonSchema: { type: "boolean" }
+	}),
+	ID: () => new FieldType({
+		name: "ID",
+		description: "Unvalidated id scalar",
+		zod: z$1.string(),
+		parseValue: (v) => z$1.string().parse(v),
+		serialize: (v) => String(v),
+		parseLiteral: (ast) => {
+			if (ast.kind !== Kind.STRING) throw new TypeError("Invalid literal");
+			return ast.value;
+		},
+		jsonSchema: { type: "string" }
+	}),
+	JSON: () => new FieldType({
+		name: "JSON",
+		zod: z$1.any(),
+		parseValue: (v) => v,
+		serialize: (v) => v,
+		jsonSchema: {}
+	}),
+	JSONObject: () => new FieldType({
+		name: "JSONObject",
+		zod: z$1.record(z$1.string(), z$1.any()),
+		parseValue: (v) => z$1.record(z$1.string(), z$1.any()).parse(v),
+		serialize: (v) => v ?? {},
+		jsonSchema: { type: "object" }
+	}),
+	Date: () => new FieldType({
+		name: "Date",
+		zod: z$1.date(),
+		parseValue: (v) => v instanceof Date ? v : new Date(String(v)),
+		serialize: (v) => v instanceof Date ? v.toISOString().split("T")[0] : String(v),
+		jsonSchema: {
+			type: "string",
+			format: "date"
+		}
+	}),
+	DateTime: () => new FieldType({
+		name: "DateTime",
+		zod: z$1.date(),
+		parseValue: (v) => v instanceof Date ? v : new Date(String(v)),
+		serialize: (v) => {
+			return v instanceof Date ? v.toISOString() : String(v);
+		},
+		jsonSchema: {
+			type: "string",
+			format: "date-time"
+		}
+	}),
+	Time: () => new FieldType({
+		name: "Time",
+		zod: z$1.string().regex(/^\d{2}:\d{2}(:\d{2})?$/),
+		parseValue: (v) => z$1.string().regex(/^\d{2}:\d{2}(:\d{2})?$/).parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			pattern: "^\\d{2}:\\d{2}(:\\d{2})?$"
+		}
+	}),
+	EmailAddress: () => new FieldType({
+		name: "EmailAddress",
+		zod: z$1.string().email(),
+		parseValue: (v) => z$1.string().email().parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			format: "email"
+		}
+	}),
+	URL: () => new FieldType({
+		name: "URL",
+		zod: z$1.string().url(),
+		parseValue: (v) => z$1.string().url().parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			format: "uri"
+		}
+	}),
+	PhoneNumber: () => new FieldType({
+		name: "PhoneNumber",
+		zod: z$1.string().regex(phoneRegex),
+		parseValue: (v) => z$1.string().regex(phoneRegex).parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			pattern: phoneRegex.source
+		}
+	}),
+	NonEmptyString: () => new FieldType({
+		name: "NonEmptyString",
+		zod: z$1.string().min(1),
+		parseValue: (v) => z$1.string().min(1).parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			minLength: 1
+		}
+	}),
+	Locale: () => new FieldType({
+		name: "Locale",
+		zod: z$1.string().regex(localeRegex),
+		parseValue: (v) => z$1.string().regex(localeRegex).parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			pattern: localeRegex.source
+		}
+	}),
+	TimeZone: () => new FieldType({
+		name: "TimeZone",
+		zod: z$1.string().regex(timezoneRegex),
+		parseValue: (v) => z$1.string().regex(timezoneRegex).parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			pattern: timezoneRegex.source
+		}
+	}),
+	Latitude: () => new FieldType({
+		name: "Latitude",
+		zod: z$1.number().min(latMin).max(latMax),
+		parseValue: (v) => z$1.coerce.number().min(latMin).max(latMax).parse(v),
+		serialize: (v) => Number(v),
+		jsonSchema: {
+			type: "number",
+			minimum: latMin,
+			maximum: latMax
+		}
+	}),
+	Longitude: () => new FieldType({
+		name: "Longitude",
+		zod: z$1.number().min(lonMin).max(lonMax),
+		parseValue: (v) => z$1.coerce.number().min(lonMin).max(lonMax).parse(v),
+		serialize: (v) => Number(v),
+		jsonSchema: {
+			type: "number",
+			minimum: lonMin,
+			maximum: lonMax
+		}
+	}),
+	Currency: () => new FieldType({
+		name: "Currency",
+		zod: z$1.string().regex(currencyRegex),
+		parseValue: (v) => z$1.string().regex(currencyRegex).parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			pattern: currencyRegex.source
+		}
+	}),
+	CountryCode: () => new FieldType({
+		name: "CountryCode",
+		zod: z$1.string().regex(countryRegex),
+		parseValue: (v) => z$1.string().regex(countryRegex).parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			pattern: countryRegex.source
+		}
+	})
+};
+
+//#endregion
+export { ScalarTypeEnum };
+//# sourceMappingURL=ScalarTypeEnum.js.map

package/dist/ScalarTypeEnum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarTypeEnum.js","names":["z"],"sources":["../src/ScalarTypeEnum.ts"],"sourcesContent":["import * as z from 'zod';\nimport { Kind, type ValueNode } from 'graphql';\nimport { FieldType } from './FieldType';\n\n// Helpers to build standard scalars\nconst localeRegex = /^[A-Za-z]{2}(?:-[A-Za-z0-9]{2,8})*$/;\nconst timezoneRegex = /^(?:UTC|[A-Za-z_]+\\/[A-Za-z_]+)$/;\nconst phoneRegex = /^[+]?\\d[\\d\\s().-]{3,}$/;\nconst currencyRegex = /^[A-Z]{3}$/;\nconst countryRegex = /^[A-Z]{2}$/;\nconst latMin = -90;\nconst latMax = 90;\nconst lonMin = -180;\nconst lonMax = 180;\n\n/**\n * Factory functions for common scalar FieldTypes with zod/GraphQL/JSON Schema.\n */\nexport const ScalarTypeEnum = {\n  // primitives (_unsecure)\n  String_unsecure: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'String_unsecure',\n      description: 'Unvalidated string scalar',\n      zod: z.string(),\n      parseValue: (v) => z.string().parse(v),\n      serialize: (v) => String(v),\n      parseLiteral: (ast: ValueNode) => {\n        if (ast.kind !== Kind.STRING) throw new TypeError('Invalid literal');\n        return ast.value;\n      },\n      jsonSchema: { type: 'string' },\n    }),\n  Int_unsecure: (): FieldType<number> =>\n    new FieldType<number>({\n      name: 'Int_unsecure',\n      description: 'Unvalidated integer scalar',\n      zod: z.number().int(),\n      parseValue: (v) => {\n        const num = typeof v === 'number' ? v : Number(v as unknown);\n        return z.number().int().parse(num);\n      },\n      serialize: (v) => Math.trunc(typeof v === 'number' ? v : Number(v)),\n      parseLiteral: (ast: ValueNode) => {\n        if (ast.kind !== Kind.INT) throw new TypeError('Invalid literal');\n        return Number(ast.value);\n      },\n      jsonSchema: { type: 'integer' },\n    }),\n  Float_unsecure: (): FieldType<number> =>\n    new FieldType<number>({\n      name: 'Float_unsecure',\n      description: 'Unvalidated float scalar',\n      zod: z.number(),\n      parseValue: (v) => {\n        const num = typeof v === 'number' ? v : Number(v as unknown);\n        return z.number().parse(num);\n      },\n      serialize: (v) => Number(v),\n      parseLiteral: (ast: ValueNode) => {\n        if (ast.kind !== Kind.FLOAT && ast.kind !== Kind.INT)\n          throw new TypeError('Invalid literal');\n        return Number(ast.value);\n      },\n      jsonSchema: { type: 'number' },\n    }),\n  Boolean: (): FieldType<boolean> =>\n    new FieldType<boolean>({\n      name: 'Boolean',\n      description: 'Unvalidated boolean scalar',\n      zod: z.boolean(),\n      parseValue: (v) => z.coerce.boolean().parse(v),\n      serialize: (v) => Boolean(v),\n      parseLiteral: (ast: ValueNode) => {\n        if (ast.kind !== Kind.BOOLEAN) throw new TypeError('Invalid literal');\n        return ast.value;\n      },\n      jsonSchema: { type: 'boolean' },\n    }),\n  ID: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'ID',\n      description: 'Unvalidated id scalar',\n      zod: z.string(),\n      parseValue: (v) => z.string().parse(v),\n      serialize: (v) => String(v),\n      parseLiteral: (ast: ValueNode) => {\n        if (ast.kind !== Kind.STRING) throw new TypeError('Invalid literal');\n        return ast.value;\n      },\n      jsonSchema: { type: 'string' },\n    }),\n\n  // Validated custom scalars\n  JSON: (): FieldType<unknown> =>\n    new FieldType<unknown>({\n      name: 'JSON',\n      zod: z.any(),\n      parseValue: (v) => v,\n      serialize: (v) => v,\n      jsonSchema: {},\n    }),\n  JSONObject: (): FieldType<Record<string, unknown>> =>\n    new FieldType<Record<string, unknown>>({\n      name: 'JSONObject',\n      zod: z.record(z.string(), z.any()),\n      parseValue: (v) => z.record(z.string(), z.any()).parse(v),\n      serialize: (v) => (v ?? {}) as Record<string, unknown>,\n      jsonSchema: { type: 'object' },\n    }),\n  Date: (): FieldType<Date, string> =>\n    new FieldType<Date, string>({\n      name: 'Date',\n      zod: z.date(),\n      parseValue: (v) => (v instanceof Date ? v : new Date(String(v))),\n      serialize: (v) =>\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        v instanceof Date ? v.toISOString().split('T')[0]! : String(v),\n      jsonSchema: { type: 'string', format: 'date' },\n    }),\n  DateTime: (): FieldType<Date, string> =>\n    new FieldType<Date, string>({\n      name: 'DateTime',\n      zod: z.date(),\n      parseValue: (v) => (v instanceof Date ? v : new Date(String(v))),\n      serialize: (v) => {\n        return v instanceof Date ? v.toISOString() : String(v);\n      },\n      jsonSchema: { type: 'string', format: 'date-time' },\n    }),\n  Time: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'Time',\n      zod: z.string().regex(/^\\d{2}:\\d{2}(:\\d{2})?$/),\n      parseValue: (v) =>\n        z\n          .string()\n          .regex(/^\\d{2}:\\d{2}(:\\d{2})?$/)\n          .parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', pattern: '^\\\\d{2}:\\\\d{2}(:\\\\d{2})?$' },\n    }),\n  EmailAddress: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'EmailAddress',\n      zod: z.string().email(),\n      parseValue: (v) => z.string().email().parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', format: 'email' },\n    }),\n  URL: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'URL',\n      zod: z.string().url(),\n      parseValue: (v) => z.string().url().parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', format: 'uri' },\n    }),\n  PhoneNumber: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'PhoneNumber',\n      zod: z.string().regex(phoneRegex),\n      parseValue: (v) => z.string().regex(phoneRegex).parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', pattern: phoneRegex.source },\n    }),\n  NonEmptyString: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'NonEmptyString',\n      zod: z.string().min(1),\n      parseValue: (v) => z.string().min(1).parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', minLength: 1 },\n    }),\n  Locale: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'Locale',\n      zod: z.string().regex(localeRegex),\n      parseValue: (v) => z.string().regex(localeRegex).parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', pattern: localeRegex.source },\n    }),\n  TimeZone: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'TimeZone',\n      zod: z.string().regex(timezoneRegex),\n      parseValue: (v) => z.string().regex(timezoneRegex).parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', pattern: timezoneRegex.source },\n    }),\n  Latitude: (): FieldType<number> =>\n    new FieldType<number>({\n      name: 'Latitude',\n      zod: z.number().min(latMin).max(latMax),\n      parseValue: (v) => z.coerce.number().min(latMin).max(latMax).parse(v),\n      serialize: (v) => Number(v),\n      jsonSchema: { type: 'number', minimum: latMin, maximum: latMax },\n    }),\n  Longitude: (): FieldType<number> =>\n    new FieldType<number>({\n      name: 'Longitude',\n      zod: z.number().min(lonMin).max(lonMax),\n      parseValue: (v) => z.coerce.number().min(lonMin).max(lonMax).parse(v),\n      serialize: (v) => Number(v),\n      jsonSchema: { type: 'number', minimum: lonMin, maximum: lonMax },\n    }),\n  Currency: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'Currency',\n      zod: z.string().regex(currencyRegex),\n      parseValue: (v) => z.string().regex(currencyRegex).parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', pattern: currencyRegex.source },\n    }),\n  CountryCode: (): FieldType<string> =>\n    new FieldType<string>({\n      name: 'CountryCode',\n      zod: z.string().regex(countryRegex),\n      parseValue: (v) => z.string().regex(countryRegex).parse(v),\n      serialize: (v) => String(v),\n      jsonSchema: { type: 'string', pattern: countryRegex.source },\n    }),\n  //   GeoJSON: (): FieldType<Record<string, unknown>, Record<string, unknown>> =>\n  //     new FieldType<Record<string, unknown>, Record<string, unknown>>({\n  //       name: 'GeoJSON',\n  //       zod: z.object({ type: z.string(), coordinates: z.any() }).passthrough(),\n  //       parseValue: (v) =>\n  //         z\n  //           .object({ type: z.string(), coordinates: z.any() })\n  //           .passthrough()\n  //           .parse(v),\n  //       serialize: (v) => v,\n  //       jsonSchema: { type: 'object' },\n  //     }),\n} as const;\nexport type ScalarTypeEnum = [keyof typeof ScalarTypeEnum];\n"],"mappings":"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"}

package/dist/SchemaModel.d.ts

@@ -0,0 +1,92 @@
+import { AnyEnumType } from "./EnumType.js";
+import { AnyFieldType } from "./FieldType.js";
+import { SchemaModelType } from "./SchemaModelType.js";
+import * as z$1 from "zod";
+import { Maybe } from "graphql/jsutils/Maybe";
+
+//#region src/SchemaModel.d.ts
+
+/**
+ * All types that can be used as field types in a SchemaModel.
+ * Supports FieldType, EnumType, nested SchemaModel, or any SchemaType implementation.
+ */
+type FieldLike = AnyFieldType | AnyEnumType | AnySchemaModel | SchemaModelType;
+/** Field configuration for a SchemaModel property. */
+interface SchemaFieldConfig<Type extends FieldLike = FieldLike> {
+  type: Type;
+  isOptional: boolean;
+  /** When present and true, the field is an array */
+  isArray?: true;
+}
+type SchemaModelFieldsAnyConfig<Type extends FieldLike = FieldLike> = Record<string, SchemaFieldConfig<Type>>;
+/** Model definition: name and fields. */
+interface SchemaModelConfig<Fields extends SchemaModelFieldsAnyConfig> {
+  name: string;
+  description?: Maybe<string>;
+  fields: Fields;
+}
+/**
+ * Named object model built from FieldType/EnumType/SchemaModel fields.
+ * Provides zod and GraphQL input helpers, and supports arrays/optional fields.
+ */
+declare class SchemaModel<Fields extends SchemaModelFieldsAnyConfig> implements SchemaModelType {
+  readonly config: SchemaModelConfig<Fields>;
+  constructor(config: SchemaModelConfig<Fields>);
+  /**
+   * Build a typed ZodObject from the model fields, preserving each field's
+   * Zod schema and optionality at the type level when possible.
+   */
+  getZod(): TopLevelZodFromModel<Fields>;
+  /** Input object name for GraphQL builder adapters. */
+  getPothosInput(): string;
+}
+/**
+ * Union of all types that can serve as a schema model.
+ * This is the main type expected by OperationSpec, EventSpec, FormSpec, etc.
+ *
+ * Supports:
+ * - SchemaModel instances (native ContractSpec types)
+ * - Any SchemaType implementation (ZodSchemaType, JsonSchemaType, etc.)
+ */
+type AnySchemaModel = SchemaModel<SchemaModelFieldsAnyConfig> | SchemaModelType;
+/**
+ * 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);
+ * }
+ * ```
+ */
+declare function isSchemaModel(model: AnySchemaModel | null | undefined): model is SchemaModel<SchemaModelFieldsAnyConfig>;
+type ZodSchemaModel<Field extends AnySchemaModel> = z$1.infer<ReturnType<Field['getZod']>>;
+type InferZodFromType<T> = T extends SchemaModel<SchemaModelFieldsAnyConfig> ? z$1.ZodObject<z$1.ZodRawShape> : T extends AnyFieldType ? ReturnType<T['getZod']> : T extends AnyEnumType ? ReturnType<T['getZod']> : T extends SchemaModelType ? ReturnType<T['getZod']> : z$1.ZodUnknown;
+type MaybeArray<Z extends z$1.ZodType, A> = A extends true ? z$1.ZodArray<Z> : Z;
+type MaybeOptional<Z extends z$1.ZodType, O> = O extends true ? z$1.ZodOptional<Z> : Z;
+/**
+ * Helper type: derive the Zod shape from the field config.
+ * Supports nested SchemaModel and arrays, preserving optionality and list-ness.
+ */
+type FieldIsArray<FC> = FC extends {
+  isArray: true;
+} ? true : false;
+type ZodShapeFromFields<F extends SchemaModelFieldsAnyConfig> = { [K in keyof F]: MaybeOptional<MaybeArray<InferZodFromType<F[K]['type']>, FieldIsArray<F[K]>>, F[K]['isOptional']> };
+/**
+ * The top-level Zod schema returned by getZod():
+ * either ZodObject<...> or ZodArray<ZodObject<...>> when config.isArray.
+ */
+type TopLevelZodFromModel<F extends SchemaModelFieldsAnyConfig> = z$1.ZodObject<ZodShapeFromFields<F>>;
+/**
+ * Helper to define a SchemaModel with type inference.
+ * Equivalent to `new SchemaModel(config)` but with better ergonomics.
+ */
+declare const defineSchemaModel: <Fields extends SchemaModelFieldsAnyConfig>(config: SchemaModelConfig<Fields>) => SchemaModel<Fields>;
+//#endregion
+export { AnySchemaModel, SchemaFieldConfig, SchemaModel, SchemaModelConfig, SchemaModelFieldsAnyConfig, TopLevelZodFromModel, ZodSchemaModel, ZodShapeFromFields, defineSchemaModel, isSchemaModel };
+//# sourceMappingURL=SchemaModel.d.ts.map

package/dist/SchemaModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaModel.d.ts","names":[],"sources":["../src/SchemaModel.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AAImD;;KAM9C,SAAA,GAAY,YAAe,GAAA,WAAA,GAAc,cAAd,GAA+B,eAA/B;;AAA+B,UAG9C,iBAH8C,CAAA,aAGf,SAHe,GAGH,SAHG,CAAA,CAAA;EAAe,IAAA,EAItE,IAJsE;EAG7D,UAAA,EAAA,OAAA;EAA+B;EAAY,OAAA,CAAA,EAAA,IAAA;;AAChD,KAMA,0BANA,CAAA,aAMwC,SANxC,GAMoD,SANpD,CAAA,GAOV,MAPU,CAAA,MAAA,EAOK,iBAPL,CAOuB,IAPvB,CAAA,CAAA;AAMZ;AAAoD,UAInC,iBAJmC,CAAA,eAIF,0BAJE,CAAA,CAAA;EAAY,IAAA,EAAA,MAAA;EAC7B,WAAA,CAAA,EAKnB,KALmB,CAAA,MAAA,CAAA;EAAlB,MAAA,EAMP,MANO;;;AAGjB;;;AAGU,cAOG,WAPH,CAAA,eAQO,0BARP,CAAA,YASG,eATH,CAAA;EAAM,SAAA,MAAA,EAUsB,iBAVtB,CAUwC,MAVxC,CAAA;EAOH,WAAA,CAAA,MAAW,EAGc,iBAHd,CAGgC,MAHhC,CAAA;EACP;;;;EAEqB,MAAA,CAAA,CAAA,EAM1B,oBAN0B,CAML,MANK,CAAA;EAML;EAArB,cAAA,CAAA,CAAA,EAAA,MAAA;;;AAgCZ;;;;;AAmBA;;AAEwB,KArBZ,cAAA,GACR,WAoBoB,CApBR,0BAoBQ,CAAA,GAnBpB,eAmBoB;;;AAWxB;;;;;;AAEE;;;;;;;AAKc,iBApBA,aAAA,CAoBA,KAAA,EAnBP,cAmBO,GAAA,IAAA,GAAA,SAAA,CAAA,EAAA,KAAA,IAlBJ,WAkBI,CAlBQ,0BAkBR,CAAA;AACG,KARP,cAQO,CAAA,cARsB,cAQtB,CAAA,GARwC,GAAA,CAAE,KAQ1C,CAPjB,UAOiB,CAPN,KAOM,CAAA,QAAA,CAAA,CAAA,CAAA;KAJd,gBAIG,CAAA,CAAA,CAAA,GAHN,CAGM,SAHI,WAGJ,CAHgB,0BAGhB,CAAA,GAFF,GAAA,CAAE,SAEA,CAFU,GAAA,CAAE,WAEZ,CAAA,GADF,CACE,SADQ,YACR,GAAA,UAAA,CAAW,CAAX,CAAA,QAAA,CAAA,CAAA,GACA,CADA,SACU,WADV,GAEE,UAFF,CAEa,CAFb,CAAA,QAAA,CAAA,CAAA,GAGE,CAHF,SAGY,eAHZ,GAII,UAJJ,CAIe,CAJf,CAAA,QAAA,CAAA,CAAA,GAKI,GAAA,CAAE,UALN;KAOH,UANG,CAAA,UAMkB,GAAA,CAAE,OANpB,EAAA,CAAA,CAAA,GAMkC,CANlC,SAAA,IAAA,GAMmD,GAAA,CAAE,QANrD,CAM8D,CAN9D,CAAA,GAMmE,CANnE;KAOH,aAPa,CAAA,UAOW,GAAA,CAAE,OAPb,EAAA,CAAA,CAAA,GAO2B,CAP3B,SAAA,IAAA,GAQd,GAAA,CAAE,WARY,CAQA,CARA,CAAA,GASd,CATc;;;;;KAeb,YAZkB,CAAA,EAAA,CAAA,GAYC,EAZD,SAAA;EAAX,OAAA,EAAA,IAAA;CACA,GAAA,IAAE,GAAA,KAAA;AAAU,KAaZ,kBAbY,CAAA,UAaiB,0BAbjB,CAAA,GAAA,QAEnB,MAYS,CAZC,GAYG,aAZH,CAaX,UAbW,CAaA,gBAbA,CAaiB,CAbjB,CAamB,CAbnB,CAAA,CAAA,MAAA,CAAA,CAAA,EAagC,YAbhC,CAa6C,CAb7C,CAa+C,CAb/C,CAAA,CAAA,CAAA,EAcX,CAdW,CAcT,CAdS,CAAA,CAAA,YAAA,CAAA,CAAA,EAAW;;;;;AAAkD,KAsBhE,oBAtBgE,CAAA,UAsBjC,0BAtBiC,CAAA,GAuB1E,GAAA,CAAE,SAvBwE,CAuB9D,kBAvB8D,CAuB3C,CAvB2C,CAAA,CAAA;AAAA;;;;AAEtE,cA2BO,iBA3BP,EAAA,CAAA,eA2B2C,0BA3B3C,CAAA,CAAA,MAAA,EA4BI,iBA5BJ,CA4BsB,MA5BtB,CAAA,EAAA,GA6BH,WA7BG,CA6BS,MA7BT,CAAA"}

package/dist/SchemaModel.js

@@ -0,0 +1,58 @@
+import "./EnumType.js";
+import "./FieldType.js";
+import * as z$1 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);
+* }
+* ```
+*/
+function isSchemaModel(model) {
+	return model !== null && model !== void 0 && "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

package/dist/SchemaModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaModel.js","names":["config: SchemaModelConfig<Fields>","base: z.ZodType","z"],"sources":["../src/SchemaModel.ts"],"sourcesContent":["import { type AnyFieldType } from './FieldType';\nimport { type AnyEnumType } from './EnumType';\nimport { type SchemaModelType } from './SchemaModelType';\nimport * as z from 'zod';\nimport type { Maybe } from 'graphql/jsutils/Maybe';\n\n/**\n * All types that can be used as field types in a SchemaModel.\n * Supports FieldType, EnumType, nested SchemaModel, or any SchemaType implementation.\n */\ntype FieldLike = AnyFieldType | AnyEnumType | AnySchemaModel | SchemaModelType;\n\n/** Field configuration for a SchemaModel property. */\nexport interface SchemaFieldConfig<Type extends FieldLike = FieldLike> {\n  type: Type;\n  isOptional: boolean;\n  /** When present and true, the field is an array */\n  isArray?: true;\n}\n\nexport type SchemaModelFieldsAnyConfig<Type extends FieldLike = FieldLike> =\n  Record<string, SchemaFieldConfig<Type>>;\n\n/** Model definition: name and fields. */\nexport interface SchemaModelConfig<Fields extends SchemaModelFieldsAnyConfig> {\n  name: string;\n  description?: Maybe<string>;\n  fields: Fields;\n}\n\n/**\n * Named object model built from FieldType/EnumType/SchemaModel fields.\n * Provides zod and GraphQL input helpers, and supports arrays/optional fields.\n */\nexport class SchemaModel<\n  Fields extends SchemaModelFieldsAnyConfig,\n> implements SchemaModelType {\n  constructor(public readonly config: SchemaModelConfig<Fields>) {}\n\n  /**\n   * Build a typed ZodObject from the model fields, preserving each field's\n   * Zod schema and optionality at the type level when possible.\n   */\n  getZod(): TopLevelZodFromModel<Fields> {\n    const shape = Object.entries(this.config.fields).reduce(\n      (acc, [key, def]) => {\n        const base: z.ZodType = (\n          def.type as unknown as { getZod: () => z.ZodType }\n        ).getZod();\n        const withArray = def.isArray ? z.array(base) : base;\n        (acc as Record<string, z.ZodType>)[key] = def.isOptional\n          ? withArray.optional()\n          : withArray;\n        return acc;\n      },\n      {} as Record<string, z.ZodType>\n    ) as unknown as ZodShapeFromFields<Fields>;\n\n    return z.object(shape) as z.ZodObject<ZodShapeFromFields<Fields>>;\n  }\n\n  /** Input object name for GraphQL builder adapters. */\n  getPothosInput() {\n    return this.config.name;\n  }\n}\n\n/**\n * Union of all types that can serve as a schema model.\n * This is the main type expected by OperationSpec, EventSpec, FormSpec, etc.\n *\n * Supports:\n * - SchemaModel instances (native ContractSpec types)\n * - Any SchemaType implementation (ZodSchemaType, JsonSchemaType, etc.)\n */\nexport type AnySchemaModel =\n  | SchemaModel<SchemaModelFieldsAnyConfig>\n  | SchemaModelType;\n\n/**\n * Type guard to check if a value is a SchemaModel (not just any SchemaType).\n * Use this when you need to access SchemaModel-specific properties like `config`.\n *\n * @param model - The model to check\n * @returns True if the model is a SchemaModel instance\n *\n * @example\n * ```typescript\n * if (isSchemaModel(model)) {\n *   // TypeScript knows model.config is available\n *   console.log(model.config.name);\n * }\n * ```\n */\nexport function isSchemaModel(\n  model: AnySchemaModel | null | undefined\n): model is SchemaModel<SchemaModelFieldsAnyConfig> {\n  return (\n    model !== null &&\n    model !== undefined &&\n    'config' in model &&\n    typeof (model as SchemaModel<SchemaModelFieldsAnyConfig>).config ===\n      'object' &&\n    'name' in (model as SchemaModel<SchemaModelFieldsAnyConfig>).config\n  );\n}\n\nexport type ZodSchemaModel<Field extends AnySchemaModel> = z.infer<\n  ReturnType<Field['getZod']>\n>;\n\ntype InferZodFromType<T> =\n  T extends SchemaModel<SchemaModelFieldsAnyConfig>\n    ? z.ZodObject<z.ZodRawShape>\n    : T extends AnyFieldType\n      ? ReturnType<T['getZod']>\n      : T extends AnyEnumType\n        ? ReturnType<T['getZod']>\n        : T extends SchemaModelType\n          ? ReturnType<T['getZod']>\n          : z.ZodUnknown;\n\ntype MaybeArray<Z extends z.ZodType, A> = A extends true ? z.ZodArray<Z> : Z;\ntype MaybeOptional<Z extends z.ZodType, O> = O extends true\n  ? z.ZodOptional<Z>\n  : Z;\n\n/**\n * Helper type: derive the Zod shape from the field config.\n * Supports nested SchemaModel and arrays, preserving optionality and list-ness.\n */\ntype FieldIsArray<FC> = FC extends { isArray: true } ? true : false;\n\nexport type ZodShapeFromFields<F extends SchemaModelFieldsAnyConfig> = {\n  [K in keyof F]: MaybeOptional<\n    MaybeArray<InferZodFromType<F[K]['type']>, FieldIsArray<F[K]>>,\n    F[K]['isOptional']\n  >;\n};\n\n/**\n * The top-level Zod schema returned by getZod():\n * either ZodObject<...> or ZodArray<ZodObject<...>> when config.isArray.\n */\nexport type TopLevelZodFromModel<F extends SchemaModelFieldsAnyConfig> =\n  z.ZodObject<ZodShapeFromFields<F>>;\n\n/**\n * Helper to define a SchemaModel with type inference.\n * Equivalent to `new SchemaModel(config)` but with better ergonomics.\n */\nexport const defineSchemaModel = <Fields extends SchemaModelFieldsAnyConfig>(\n  config: SchemaModelConfig<Fields>\n): SchemaModel<Fields> => new SchemaModel(config);\n"],"mappings":";;;;;;;;;AAkCA,IAAa,cAAb,MAE6B;CAC3B,YAAY,AAAgBA,QAAmC;EAAnC;;;;;;CAM5B,SAAuC;EACrC,MAAM,QAAQ,OAAO,QAAQ,KAAK,OAAO,OAAO,CAAC,QAC9C,KAAK,CAAC,KAAK,SAAS;GACnB,MAAMC,OACJ,IAAI,KACJ,QAAQ;GACV,MAAM,YAAY,IAAI,UAAUC,IAAE,MAAM,KAAK,GAAG;AAChD,GAAC,IAAkC,OAAO,IAAI,aAC1C,UAAU,UAAU,GACpB;AACJ,UAAO;KAET,EAAE,CACH;AAED,SAAOA,IAAE,OAAO,MAAM;;;CAIxB,iBAAiB;AACf,SAAO,KAAK,OAAO;;;;;;;;;;;;;;;;;;AA+BvB,SAAgB,cACd,OACkD;AAClD,QACE,UAAU,QACV,UAAU,UACV,YAAY,SACZ,OAAQ,MAAkD,WACxD,YACF,UAAW,MAAkD;;;;;;AAgDjE,MAAa,qBACX,WACwB,IAAI,YAAY,OAAO"}

package/dist/SchemaModelType.d.ts

@@ -0,0 +1,60 @@
+import * as z$1 from "zod";
+
+//#region src/SchemaModelType.d.ts
+
+/**
+ * Supported schema output formats for code generation.
+ */
+type SchemaFormat = 'contractspec' | 'zod' | 'json-schema' | 'graphql';
+/**
+ * Unified interface for all schema-compatible types.
+ * Any type used in ContractSpec schemas must implement this interface.
+ *
+ * @template T - The TypeScript type this schema represents
+ *
+ * @example
+ * ```typescript
+ * // All of these implement SchemaType:
+ * const fieldType = ScalarTypeEnum.String_unsecure();
+ * const schemaModel = new SchemaModel({ name: 'User', fields: {...} });
+ * 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;
+}
+/**
+ * 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();
+ * }
+ * ```
+ */
+declare function isSchemaType(value: unknown): value is SchemaModelType;
+/**
+ * Type alias for any SchemaType implementation.
+ */
+type AnySchemaType = SchemaModelType<unknown>;
+//#endregion
+export { AnySchemaType, SchemaFormat, SchemaModelType, isSchemaType };
+//# sourceMappingURL=SchemaModelType.d.ts.map

package/dist/SchemaModelType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaModelType.d.ts","names":[],"sources":["../src/SchemaModelType.ts"],"sourcesContent":[],"mappings":";;;;;;;KAcY,YAAA;;;;;;;;;;;;;;;UAgBK;;;;;YAKL,GAAA,CAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;iBA4BN,YAAA,2BAAuC;;;;KAY3C,aAAA,GAAgB"}

package/dist/SchemaModelType.js

@@ -0,0 +1,21 @@
+//#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();
+* }
+* ```
+*/
+function isSchemaType(value) {
+	return value !== null && typeof value === "object" && "getZod" in value && typeof value.getZod === "function";
+}
+
+//#endregion
+export { isSchemaType };
+//# sourceMappingURL=SchemaModelType.js.map

package/dist/SchemaModelType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaModelType.js","names":[],"sources":["../src/SchemaModelType.ts"],"sourcesContent":["/**\n * Unified schema type interface for ContractSpec.\n *\n * This module provides a vendor-agnostic abstraction over different schema\n * definition approaches (SchemaModel, Zod, JSON Schema, GraphQL scalars).\n *\n * @module SchemaType\n */\n\nimport type * as z from 'zod';\n\n/**\n * Supported schema output formats for code generation.\n */\nexport type SchemaFormat = 'contractspec' | 'zod' | 'json-schema' | 'graphql';\n\n/**\n * Unified interface for all schema-compatible types.\n * Any type used in ContractSpec schemas must implement this interface.\n *\n * @template T - The TypeScript type this schema represents\n *\n * @example\n * ```typescript\n * // All of these implement SchemaType:\n * const fieldType = ScalarTypeEnum.String_unsecure();\n * const schemaModel = new SchemaModel({ name: 'User', fields: {...} });\n * const zodWrapper = fromZod(z.object({ name: z.string() }));\n * ```\n */\nexport interface SchemaModelType<T = unknown> {\n  /**\n   * Return the Zod schema for runtime validation.\n   * This is the primary method - all schema types must provide Zod conversion.\n   */\n  getZod(): z.ZodType<T>;\n\n  /**\n   * Return GraphQL type info for Pothos/GraphQL integration.\n   * Optional - types without GraphQL representation return undefined.\n   */\n  getPothos?(): unknown;\n\n  /**\n   * Return JSON Schema representation.\n   * Optional - types without JSON Schema representation return undefined.\n   */\n  getJsonSchema?(): unknown;\n}\n\n/**\n * Type guard to check if a value implements the SchemaType interface.\n *\n * @param value - Value to check\n * @returns True if value has a getZod method\n *\n * @example\n * ```typescript\n * if (isSchemaType(field.type)) {\n *   const zodSchema = field.type.getZod();\n * }\n * ```\n */\nexport function isSchemaType(value: unknown): value is SchemaModelType {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    'getZod' in value &&\n    typeof (value as SchemaModelType).getZod === 'function'\n  );\n}\n\n/**\n * Type alias for any SchemaType implementation.\n */\nexport type AnySchemaType = SchemaModelType<unknown>;\n"],"mappings":";;;;;;;;;;;;;;AA+DA,SAAgB,aAAa,OAA0C;AACrE,QACE,UAAU,QACV,OAAO,UAAU,YACjB,YAAY,SACZ,OAAQ,MAA0B,WAAW"}