import { AttributeApplication, Expression, FieldHasDefault, FieldIsArray, FieldIsComputed, FieldIsDelegateDiscriminator, FieldIsRelation, GetEnum, GetEnums, GetModelFieldType, GetModelFields, GetModels, GetTypeDefFieldType, GetTypeDefFields, GetTypeDefs, ModelFieldIsOptional, SchemaDef, TypeDefFieldIsArray, TypeDefFieldIsOptional } from "@zenstackhq/schema";
import Decimal from "decimal.js";
import z$1, { z } from "zod";

//#region src/types.d.ts
/**
 * Scalar-only shape returned by the no-options `makeModelSchema` overload.
 * Relation fields are excluded by default — use `include` or `select` to opt in.
 */
type GetModelFieldsShape<Schema extends SchemaDef, Model extends GetModels<Schema>> = { [Field in GetModelFields<Schema, Model> as FieldIsRelation<Schema, Model, Field> extends true ? never : Field]: ZodOptionalAndNullableIf<ZodArrayIf<MapModelFieldToZod<Schema, Model, Field>, FieldIsArray<Schema, Model, Field>>, ModelFieldIsOptional<Schema, Model, Field>> };
/**
 * Full shape including both scalar and relation fields — used internally for
 * type lookups (e.g. resolving relation field Zod types in include/select).
 */
type GetAllModelFieldsShape<Schema extends SchemaDef, Model extends GetModels<Schema>> = GetModelFieldsShape<Schema, Model> & { [Field in GetModelFields<Schema, Model> as FieldIsRelation<Schema, Model, Field> extends true ? Field : never]: ZodNullableIf<z$1.ZodOptional<ZodArrayIf<z$1.ZodObject<GetModelFieldsShape<Schema, GetModelFieldType<Schema, Model, Field> extends GetModels<Schema> ? GetModelFieldType<Schema, Model, Field> : never>, z$1.core.$strict>, FieldIsArray<Schema, Model, Field>>>, ModelFieldIsOptional<Schema, Model, Field>> };
type GetModelCreateFieldsShape<Schema extends SchemaDef, Model extends GetModels<Schema>> = { [Field in GetModelFields<Schema, Model> as FieldIsRelation<Schema, Model, Field> extends true ? never : FieldIsComputed<Schema, Model, Field> extends true ? never : FieldIsDelegateDiscriminator<Schema, Model, Field> extends true ? never : Field]: ZodOptionalIf<ZodOptionalAndNullableIf<ZodArrayIf<MapModelFieldToZod<Schema, Model, Field>, FieldIsArray<Schema, Model, Field>>, ModelFieldIsOptional<Schema, Model, Field>>, FieldHasDefault<Schema, Model, Field>> };
type GetModelUpdateFieldsShape<Schema extends SchemaDef, Model extends GetModels<Schema>> = { [Field in GetModelFields<Schema, Model> as FieldIsRelation<Schema, Model, Field> extends true ? never : FieldIsComputed<Schema, Model, Field> extends true ? never : FieldIsDelegateDiscriminator<Schema, Model, Field> extends true ? never : Field]: z$1.ZodOptional<ZodOptionalAndNullableIf<ZodArrayIf<MapModelFieldToZod<Schema, Model, Field>, FieldIsArray<Schema, Model, Field>>, ModelFieldIsOptional<Schema, Model, Field>>> };
type GetTypeDefFieldsShape<Schema extends SchemaDef, Type extends GetTypeDefs<Schema>> = { [Field in GetTypeDefFields<Schema, Type>]: ZodOptionalAndNullableIf<ZodArrayIf<MapTypeDefFieldToZod<Schema, Type, Field>, TypeDefFieldIsArray<Schema, Type, Field>>, TypeDefFieldIsOptional<Schema, Type, Field>> };
type FieldTypeZodMap = {
  String: z$1.ZodString;
  Int: z$1.ZodNumber;
  BigInt: z$1.ZodBigInt;
  Float: z$1.ZodNumber;
  Decimal: z$1.ZodType<Decimal, Decimal>;
  Boolean: z$1.ZodBoolean;
  DateTime: z$1.ZodDate;
  Bytes: z$1.ZodType<Uint8Array, Uint8Array>;
  Json: JsonZodType;
};
type MapModelFieldToZod<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, FieldType = GetModelFieldType<Schema, Model, Field>> = MapFieldTypeToZod<Schema, FieldType>;
type MapTypeDefFieldToZod<Schema extends SchemaDef, Type extends GetTypeDefs<Schema>, Field extends GetTypeDefFields<Schema, Type>, FieldType = GetTypeDefFieldType<Schema, Type, Field>> = MapFieldTypeToZod<Schema, FieldType>;
type MapFieldTypeToZod<Schema extends SchemaDef, FieldType> = FieldType extends keyof FieldTypeZodMap ? FieldTypeZodMap[FieldType] : FieldType extends GetEnums<Schema> ? EnumZodType<Schema, FieldType> : FieldType extends GetTypeDefs<Schema> ? z$1.ZodObject<GetTypeDefFieldsShape<Schema, FieldType>, z$1.core.$strict> : z$1.ZodUnknown;
type JsonValue = string | number | boolean | JsonObject | JsonArray | null;
type JsonObject = {
  [key: string]: JsonValue;
};
type JsonArray = Array<JsonValue>;
type JsonZodType = z$1.ZodType<JsonValue>;
type EnumZodType<Schema extends SchemaDef, EnumName extends GetEnums<Schema>> = z$1.ZodEnum<{ [Key in keyof GetEnum<Schema, EnumName>]: GetEnum<Schema, EnumName>[Key] }>;
type ZodOptionalAndNullableIf<T extends z$1.ZodType, Condition extends boolean> = Condition extends true ? z$1.ZodOptional<z$1.ZodNullable<T>> : T;
type ZodOptionalIf<T extends z$1.ZodType, Condition extends boolean> = Condition extends true ? z$1.ZodOptional<T> : T;
type ZodNullableIf<T extends z$1.ZodType, Condition extends boolean> = Condition extends true ? z$1.ZodNullable<T> : T;
type ZodArrayIf<T extends z$1.ZodType, Condition extends boolean> = Condition extends true ? z$1.ZodArray<T> : T;
/**
 * The non-relation scalar fields of a model (excludes relation fields and
 * foreign-key fields that back a relation).
 */
type ScalarModelFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = { [Field in GetModelFields<Schema, Model> as FieldIsRelation<Schema, Model, Field> extends true ? never : Field]: Field };
/**
 * The relation fields of a model.
 */
type RelationModelFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = { [Field in GetModelFields<Schema, Model> as FieldIsRelation<Schema, Model, Field> extends true ? Field : never]: Field };
/**
 * For a relation field, resolve the related model name.
 */
type RelatedModel<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelFieldType<Schema, Model, Field> extends GetModels<Schema> ? GetModelFieldType<Schema, Model, Field> : never;
/**
 * Controls which fields are made optional in the generated schema.
 *
 * - `"all"`      — every field in the schema becomes optional.
 * - `"defaults"` — only fields that have a default value (`@default`) or are
 *                  auto-managed (`@updatedAt`) are made optional; all other
 *                  fields retain their original optionality.
 */
type ModelSchemaOptionality = 'all' | 'defaults';
/**
 * ORM-style query options accepted by `makeModelSchema`.
 *
 * Exactly mirrors the `select` / `include` / `omit` vocabulary:
 * - `select`      — pick specific fields (scalars and/or relations). Mutually
 *                   exclusive with `include` and `omit`.
 * - `include`     — start with all scalar fields, then add the named relation
 *                   fields. Can be combined with `omit`.
 * - `omit`        — remove named scalar fields from the default scalar set.
 *                   Can be combined with `include`, mutually exclusive with
 *                   `select`.
 * - `optionality` — when `"all"`, every field becomes optional. When
 *                   `"defaults"`, only fields with a `@default` value or
 *                   `@updatedAt` are made optional.
 */
type ModelSchemaOptions<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
  /**
   * Pick only the listed fields. Values must be `true` (include with
   * default shape) or a nested options object (for relation fields).
   * Only `true` is accepted — ORM convention.
   */
  select: { [Field in GetModelFields<Schema, Model>]?: FieldIsRelation<Schema, Model, Field> extends true ? true | ModelSchemaOptions<Schema, RelatedModel<Schema, Model, Field>> : true };
  include?: never;
  omit?: never;
  /**
   * Controls which fields are made optional.
   * - `"all"`      — every field becomes optional.
   * - `"defaults"` — only fields with `@default` or `@updatedAt` become optional.
   */
  optionality?: ModelSchemaOptionality;
} | {
  select?: never;
  /**
   * Add the listed relation fields on top of the scalar fields.
   * Values must be `true` (default shape) or a nested options object.
   * Only `true` is accepted — ORM convention.
   */
  include?: { [Field in keyof RelationModelFields<Schema, Model>]?: Field extends GetModelFields<Schema, Model> ? true | ModelSchemaOptions<Schema, RelatedModel<Schema, Model, Field>> : never };
  /**
   * Remove the listed scalar fields from the output.
   * Only `true` is accepted — ORM convention.
   */
  omit?: { [Field in keyof ScalarModelFields<Schema, Model>]?: true };
  /**
   * Controls which fields are made optional.
   * - `"all"`      — every field becomes optional.
   * - `"defaults"` — only fields with `@default` or `@updatedAt` become optional.
   */
  optionality?: ModelSchemaOptionality;
};
/**
 * Narrows `Field` so it can safely index `GetModelFieldsShape`. The mapped
 * type uses a `as`-remapping clause, so TypeScript widens the key set and
 * `Field extends GetModelFields<…>` alone is not enough for indexing.
 */
type FieldInShape<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = Field & keyof GetAllModelFieldsShape<Schema, Model>;
/**
 * Zod shape produced when a relation field is included via `include: { field:
 * true }` or `select: { field: true }` — identical to how the existing
 * `makeModelSchema` (no-options) represents relation fields: optional, carries
 * array-ness and nullability from the field definition.
 */
type RelationFieldZodDefault<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetAllModelFieldsShape<Schema, Model>[FieldInShape<Schema, Model, Field>];
/**
 * Zod shape for a relation field included with nested options.  We recurse
 * into `GetModelSchemaShapeWithOptions` for the related model, then re-apply
 * the same optional/array/nullable wrappers as the default relation field.
 */
type RelationFieldZodWithOptions<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Options> = RelatedModel<Schema, Model, Field> extends GetModels<Schema> ? ZodNullableIf<z$1.ZodOptional<ZodArrayIf<z$1.ZodObject<GetModelSchemaShapeWithOptions<Schema, RelatedModel<Schema, Model, Field>, Options>, z$1.core.$strict>, FieldIsArray<Schema, Model, Field>>>, ModelFieldIsOptional<Schema, Model, Field>> : never;
/**
 * Resolve the Zod type for a single field given a select-entry value (`true`
 * or a nested options object).
 */
type SelectEntryToZod<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Value> = Value extends boolean ? GetAllModelFieldsShape<Schema, Model>[FieldInShape<Schema, Model, Field>] : Value extends object ? RelationFieldZodWithOptions<Schema, Model, Field, Value> : never;
/**
 * Build the Zod shape for the `select` branch: only the listed fields,
 * recursing into relations when given nested options.
 */
type BuildSelectShape<Schema extends SchemaDef, Model extends GetModels<Schema>, S extends Record<string, unknown>> = { [Field in keyof S & GetModelFields<Schema, Model>]: SelectEntryToZod<Schema, Model, Field, S[Field]> };
/**
 * Build the Zod shape for the `include` + `omit` branch:
 * - All scalar fields, minus any that appear in `omit` with value `true`.
 * - Plus the relation fields listed in `include`.
 */
type BuildIncludeOmitShape<Schema extends SchemaDef, Model extends GetModels<Schema>, I extends Record<string, unknown> | undefined, O extends Record<string, unknown> | undefined> = { [Field in GetModelFields<Schema, Model> as FieldIsRelation<Schema, Model, Field> extends true ? never : O extends object ? Field extends keyof O ? O[Field] extends true ? never : Field : Field : Field]: GetAllModelFieldsShape<Schema, Model>[FieldInShape<Schema, Model, Field>] } & (I extends object ? { [Field in keyof I & GetModelFields<Schema, Model>]: I[Field] extends object ? RelationFieldZodWithOptions<Schema, Model, Field, I[Field]> : RelationFieldZodDefault<Schema, Model, Field> } : {});
/**
 * Wraps every field in a shape with `z.ZodOptional` when `Optionality` is `"all"`.
 * When `Optionality` is `"defaults"`, only fields that carry a `@default` or
 * `@updatedAt` attribute (as detected by `FieldHasDefault`) are wrapped.
 * When `Optionality` is anything else the shape is returned as-is.
 */
type ApplyOptionality<Shape extends Record<string, z$1.ZodType>, Optionality, Schema extends SchemaDef = never, Model extends GetModels<Schema> = never> = Optionality extends 'all' ? { [K in keyof Shape]: z$1.ZodOptional<Shape[K]> } : Optionality extends 'defaults' ? { [K in keyof Shape]: K extends GetModelFields<Schema, Model> ? FieldHasDefault<Schema, Model, K> extends true ? z$1.ZodOptional<Shape[K]> : Shape[K] : Shape[K] } : Shape;
/**
 * The top-level conditional that maps options → Zod shape.
 *
 * - No options / undefined  → existing `GetModelFieldsShape` (no change).
 * - `{ select: S }`         → `BuildSelectShape` (+ optionality wrapper).
 * - `{ include?, omit? }`   → `BuildIncludeOmitShape` (+ optionality wrapper).
 *
 * `optionality: "defaults"` is inferred statically using `FieldHasDefault`,
 * which inspects the `default` and `updatedAt` fields on `FieldDef` to
 * determine which fields should become optional.
 */
type GetModelSchemaShapeWithOptions<Schema extends SchemaDef, Model extends GetModels<Schema>, Options> = Options extends {
  select: infer S extends Record<string, unknown>;
  optionality?: infer Opt;
} ? ApplyOptionality<BuildSelectShape<Schema, Model, S>, Opt, Schema, Model> : Options extends {
  include?: infer I extends Record<string, unknown> | undefined;
  omit?: infer O extends Record<string, unknown> | undefined;
  optionality?: infer Opt;
} ? ApplyOptionality<BuildIncludeOmitShape<Schema, Model, I, O>, Opt, Schema, Model> : GetModelFieldsShape<Schema, Model>;
//#endregion
//#region src/factory.d.ts
declare function createSchemaFactory<Schema extends SchemaDef>(schema: Schema): SchemaFactory<Schema>;
declare class SchemaFactory<Schema extends SchemaDef> {
  private readonly schema;
  constructor(_schema: Schema);
  makeModelSchema<Model extends GetModels<Schema>>(model: Model): z$1.ZodObject<GetModelFieldsShape<Schema, Model>, z$1.core.$strict>;
  makeModelSchema<Model extends GetModels<Schema>, Options extends ModelSchemaOptions<Schema, Model>>(model: Model, options: Options): z$1.ZodObject<GetModelSchemaShapeWithOptions<Schema, Model, Options>, z$1.core.$strict>;
  /**
   * @deprecated Use `makeModelSchema(model, { optionality: 'defaults' })` instead.
   */
  makeModelCreateSchema<Model extends GetModels<Schema>>(model: Model): z$1.ZodObject<GetModelCreateFieldsShape<Schema, Model>, z$1.core.$strict>;
  /**
   * @deprecated Use `makeModelSchema(model, { optionality: 'all' })` instead.
   */
  makeModelUpdateSchema<Model extends GetModels<Schema>>(model: Model): z$1.ZodObject<GetModelUpdateFieldsShape<Schema, Model>, z$1.core.$strict>;
  /**
   * Applies the `optionality` option to a fields map.
   *
   * - `"all"`      — wraps every field in `z.ZodOptional`.
   * - `"defaults"` — only wraps fields that have a `@default` attribute or
   *                  are `@updatedAt` in `z.ZodOptional`. Fields that are
   *                  already optional (nullable optional) retain their shape;
   *                  we just add the outer optional layer.
   * - `undefined`  — returns the fields map unchanged.
   */
  private applyOptionality;
  /**
   * Internal loose options shape used at runtime (we've already validated the
   * type-level constraints via the overload signatures).
   */
  private buildFieldsWithOptions;
  /**
   * Returns the set of scalar field names that will be present in the
   * resulting schema after applying `options`. Used by `addCustomValidation`
   * to skip `@@validate` rules that reference an absent field.
   *
   * Only scalar fields matter here because `@@validate` conditions are
   * restricted by the ZModel compiler to scalar fields of the same model.
   */
  private buildPresentFields;
  /**
   * Build the inner Zod schema for a relation field, optionally with nested
   * query options.  Does NOT apply cardinality/optional wrappers — the caller
   * does that.
   */
  private makeRelationFieldSchema;
  private makeScalarFieldSchema;
  private makeJsonSchema;
  /**
   * Wraps a schema with `.optional()` and copies any `description` from its
   * metadata onto the resulting `ZodOptional`, so that callers inspecting
   * `.meta()?.description` on shape fields still find the value after
   * optionality has been applied.
   */
  private wrapOptionalPreservingMeta;
  private applyCardinality;
  makeTypeSchema<Type extends GetTypeDefs<Schema>>(type: Type): z$1.ZodObject<GetTypeDefFieldsShape<Schema, Type>, z$1.core.$strict>;
  makeEnumSchema<Enum extends GetEnums<Schema>>(_enum: Enum): z$1.ZodEnum<{ [Key in keyof GetEnum<Schema, Enum>]: GetEnum<Schema, Enum>[Key] }>;
  private getMetaDescription;
  private applyDescription;
}
declare namespace utils_d_exports {
  export { addBigIntValidation, addCustomValidation, addDecimalValidation, addListValidation, addNumberValidation, addStringValidation, collectFieldRefs };
}
declare function addStringValidation(schema: z.ZodString, attributes: readonly AttributeApplication[] | undefined): z.ZodSchema;
declare function addNumberValidation(schema: z.ZodNumber, attributes: readonly AttributeApplication[] | undefined): z.ZodSchema;
declare function addBigIntValidation(schema: z.ZodBigInt, attributes: readonly AttributeApplication[] | undefined): z.ZodSchema;
declare function addDecimalValidation(schema: z.ZodType<Decimal> | z.ZodString, attributes: readonly AttributeApplication[] | undefined, addExtraValidation: boolean): z.ZodSchema;
declare function addListValidation(schema: z.ZodArray<any>, attributes: readonly AttributeApplication[] | undefined): z.ZodSchema;
/**
 * Recursively collects all field names referenced by `kind: 'field'` nodes
 * inside an expression tree.
 */
declare function collectFieldRefs(expr: Expression): Set<string>;
/**
 * Applies `@@validate` rules from `attributes` to `schema` as Zod refinements.
 *
 * When `presentFields` is provided, only rules whose every field reference is
 * present in the set are applied. Rules that reference a field absent from the
 * set are silently skipped — they cannot be evaluated correctly against a
 * partial payload (e.g. when `select` or `omit` has been used).
 *
 * Omit `presentFields` (or pass `undefined`) to apply all rules
 * unconditionally, which is the correct behaviour for full-model schemas.
 *
 * Note: `@@validate` conditions are restricted by the ZModel compiler to
 * scalar fields of the same model only — relation fields are a compile error.
 * A flat field-name set is therefore sufficient.
 */
declare function addCustomValidation(schema: z.ZodSchema, attributes: readonly AttributeApplication[] | undefined, presentFields?: ReadonlySet<string>): z.ZodSchema;
//#endregion
export { type GetModelSchemaShapeWithOptions, type JsonValue, type ModelSchemaOptions, utils_d_exports as ZodUtils, createSchemaFactory };
//# sourceMappingURL=index.d.mts.map