@zenstackhq/orm 3.6.4 → 3.7.0

package/dist/index.d.cts

@@ -1,5 +1,6 @@
+import { AnyNull, AnyNullClass, DbNull, DbNullClass, JsonArray, JsonNull, JsonNullClass, JsonNullValues, JsonObject, JsonValue } from "./common-types.cjs";
 import * as _$kysely from "kysely";
-import { AddColumnNode, AddConstraintNode, AddIndexNode, AggregateFunctionNode, AliasNode, AliasableExpression, AlterColumnNode, AlterTableNode, AndNode, BinaryOperationNode, CaseNode, CastNode, CheckConstraintNode, CollateNode, ColumnDefinitionNode, ColumnNode, ColumnUpdateNode, CommonTableExpressionNameNode, CommonTableExpressionNode, CreateIndexNode, CreateSchemaNode, CreateTableNode, CreateTypeNode, CreateViewNode, DataTypeNode, DefaultInsertValueNode, DefaultValueNode, DeleteQueryNode, Dialect, DropColumnNode, DropConstraintNode, DropIndexNode, DropSchemaNode, DropTableNode, DropTypeNode, DropViewNode, ExplainNode, Expression, ExpressionBuilder, ExpressionWrapper, FetchNode, ForeignKeyConstraintNode, FromNode, FunctionNode, Generated, GeneratedNode, GroupByItemNode, GroupByNode, HavingNode, IdentifierNode, InsertQueryNode, JSONOperatorChainNode, JSONPathLegNode, JSONPathNode, JSONReferenceNode, JoinNode, Kysely, KyselyConfig, LimitNode, ListNode, MatchedNode, MergeQueryNode, ModifyColumnNode, OffsetNode, OnConflictNode, OnDuplicateKeyNode, OnNode, OperandExpression, OperationNode, OperationNodeVisitor, OperatorNode, OrActionNode, OrNode, OrderByItemNode, OrderByNode, OutputNode, OverNode, ParensNode, PartitionByItemNode, PartitionByNode, PrimaryKeyConstraintNode, PrimitiveValueListNode, QueryId, QueryResult, RawNode, ReferenceNode, ReferencesNode, RefreshMaterializedViewNode, RenameColumnNode, RenameConstraintNode, ReturningNode, RootOperationNode, SchemableIdentifierNode, SelectAllNode, SelectModifierNode, SelectQueryBuilder, SelectQueryNode, SelectionNode, SetOperationNode, SqlBool, TableNode, TopNode, TupleNode, UnaryOperationNode, UniqueConstraintNode, UnknownRow, UpdateQueryNode, UsingNode, ValueListNode, ValueNode, ValuesNode, WhenNode, WhereNode, WithNode } from "kysely";
+import { AddColumnNode, AddConstraintNode, AddIndexNode, AddValueNode, AggregateFunctionNode, AliasNode, AliasableExpression, AlterColumnNode, AlterTableNode, AlterTypeNode, AndNode, BinaryOperationNode, CaseNode, CastNode, CheckConstraintNode, CollateNode, ColumnDefinitionNode, ColumnNode, ColumnUpdateNode, CommonTableExpressionNameNode, CommonTableExpressionNode, CreateIndexNode, CreateSchemaNode, CreateTableNode, CreateTypeNode, CreateViewNode, DataTypeNode, DefaultInsertValueNode, DefaultValueNode, DeleteQueryNode, Dialect, DropColumnNode, DropConstraintNode, DropIndexNode, DropSchemaNode, DropTableNode, DropTypeNode, DropViewNode, ExplainNode, Expression, ExpressionBuilder, ExpressionWrapper, FetchNode, ForeignKeyConstraintNode, FromNode, FunctionNode, Generated, GeneratedNode, GroupByItemNode, GroupByNode, HavingNode, IdentifierNode, InsertQueryNode, JSONOperatorChainNode, JSONPathLegNode, JSONPathNode, JSONReferenceNode, JoinNode, Kysely, KyselyConfig, LimitNode, ListNode, MatchedNode, MergeQueryNode, ModifyColumnNode, OffsetNode, OnConflictNode, OnDuplicateKeyNode, OnNode, OperandExpression, OperationNode, OperationNodeVisitor, OperatorNode, OrActionNode, OrNode, OrderByItemNode, OrderByNode, OutputNode, OverNode, ParensNode, PartitionByItemNode, PartitionByNode, PrimaryKeyConstraintNode, PrimitiveValueListNode, QueryId, QueryResult, RawNode, ReferenceNode, ReferencesNode, RefreshMaterializedViewNode, RenameColumnNode, RenameConstraintNode, RenameValueNode, ReturningNode, RootOperationNode, SchemableIdentifierNode, SelectAllNode, SelectModifierNode, SelectQueryBuilder, SelectQueryNode, SelectionNode, SetOperationNode, SqlBool, TableNode, TopNode, TupleNode, UnaryOperationNode, UniqueConstraintNode, UnknownRow, UpdateQueryNode, UsingNode, ValueListNode, ValueNode, ValuesNode, WhenNode, WhereNode, WithNode } from "kysely";
 import * as _$_zenstackhq_schema0 from "@zenstackhq/schema";
 import { ArrayExpression, BinaryExpression, BindingExpression, BuiltinType, CallExpression, DataSourceProviderType, Expression as Expression$1, FieldDef, FieldExpression, FieldHasDefault, FieldIsArray, FieldIsDelegateDiscriminator, FieldIsRelation, FieldType, ForeignKeyFields, GetEnum, GetEnums, GetModel, GetModelDiscriminator, GetModelField, GetModelFieldType, GetModelFields, GetModels, GetSubModels, GetTypeDefField, GetTypeDefFieldType, GetTypeDefFields, GetTypeDefs, IsDelegateModel, LiteralExpression, MemberExpression, ModelDef, ModelFieldIsOptional, NonRelationFields, NullExpression, ProcedureDef, RelationFieldType, RelationFields, RelationInfo, ScalarFields, SchemaDef, ThisExpression, TypeDefFieldIsArray, TypeDefFieldIsOptional, UnaryExpression, UpdatedAtInfo } from "@zenstackhq/schema";
 import { ZodType, z } from "zod";
@@ -108,32 +109,12 @@ declare class DefaultOperationNodeVisitor extends OperationNodeVisitor {
   protected visitRefreshMaterializedView(node: RefreshMaterializedViewNode): void;
   protected visitOrAction(node: OrActionNode): void;
   protected visitCollate(node: CollateNode): void;
+  protected visitAlterType(node: AlterTypeNode): void;
+  protected visitAddValue(node: AddValueNode): void;
+  protected visitRenameValue(node: RenameValueNode): void;
 }
 type AnyKysely = Kysely<any>;
 //#endregion
-//#region src/common-types.d.ts
-type JsonValue = string | number | boolean | JsonObject | JsonArray;
-type JsonObject = {
-  [key: string]: JsonValue | null;
-};
-type JsonArray = Array<JsonValue | null>;
-type JsonNullValues = DbNull | JsonNull | AnyNull;
-declare class DbNullClass {
-  private __brand;
-}
-declare const DbNull: DbNullClass;
-type DbNull = typeof DbNull;
-declare class JsonNullClass {
-  private __brand;
-}
-declare const JsonNull: JsonNullClass;
-type JsonNull = typeof JsonNull;
-declare class AnyNullClass {
-  private __brand;
-}
-declare const AnyNull: AnyNullClass;
-type AnyNull = typeof AnyNull;
-//#endregion
 //#region src/utils/type-utils.d.ts
 type Optional<T extends object, K extends keyof T = keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 type PartialIf<T, Condition extends boolean> = Condition extends true ? Partial<T> : T;
@@ -151,7 +132,7 @@ type TypeMap = {
   Decimal: Decimal;
   DateTime: Date;
   Bytes: Uint8Array;
-  Json: JsonValue;
+  Json: JsonValue | null;
   Null: null;
   Object: Record<string, unknown>;
   Any: unknown;
@@ -214,6 +195,8 @@ declare const FILTER_PROPERTY_TO_KIND: {
   readonly array_contains: "Json";
   readonly array_starts_with: "Json";
   readonly array_ends_with: "Json";
+  readonly fuzzy: "Fuzzy";
+  readonly fts: "FullText";
   readonly has: "List";
   readonly hasEvery: "List";
   readonly hasSome: "List";
@@ -326,7 +309,7 @@ interface RuntimePlugin<Schema extends SchemaDef, ExtQueryArgs extends ExtQueryA
    */
   result?: ExtResult;
 }
-type AnyPlugin = RuntimePlugin<any, any, any, any>;
+type AnyPlugin = RuntimePlugin<SchemaDef, any, any, any>;
 /**
  * Defines a ZenStack runtime plugin based on type of the given schema.
  *
@@ -756,8 +739,13 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
   abstract get insertIgnoreMethod(): 'onConflict' | 'ignore';
   /**
    * Transforms input value before sending to database.
+   *
+   * `fieldDef` is optional so existing callers that don't have it stay
+   * source-compatible. Dialects can use it to inspect `@db.*` native-type
+   * attributes (e.g. to format `@db.Time` values as `HH:MM:SS` rather than
+   * full ISO timestamps).
    */
-  transformInput(value: unknown, _type: BuiltinType, _forArrayField: boolean): unknown;
+  transformInput(value: unknown, _type: BuiltinType, _forArrayField: boolean, _fieldDef?: FieldDef): unknown;
   /**
    * Transforms output value received from database.
    */
@@ -793,6 +781,11 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
   private buildBytesFilter;
   private buildEnumFilter;
   buildOrderBy(query: SelectQueryBuilder<any, any, any>, model: string, modelAlias: string, orderBy: OrArray<OrderBy<Schema, GetModels<Schema>, boolean, boolean>> | undefined, negated: boolean, take: number | undefined): SelectQueryBuilder<any, any, any>;
+  private applyRelationOrderBy;
+  private applyScalarOrderBy;
+  private applyAggregationOrderBy;
+  private applyFuzzyRelevanceOrderBy;
+  private applyFtsRelevanceOrderBy;
   buildSelectAllFields(model: string, query: SelectQueryBuilder<any, any, any>, omit: Record<string, boolean | undefined> | undefined | null, modelAlias: string): SelectQueryBuilder<any, any, any>;
   shouldOmitField(omit: unknown, model: string, field: string): any;
   protected buildModelSelect(model: GetModels<Schema>, subQueryAlias: string, payload: true | FindArgs<Schema, GetModels<Schema>, any, true>, selectAllFields: boolean): SelectQueryBuilder<any, any, {}>;
@@ -888,7 +881,44 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
    * Builds an ORDER BY clause for a field with NULLS FIRST/LAST support.
    */
   protected abstract buildOrderByField(query: SelectQueryBuilder<any, any, any>, field: Expression<unknown>, sort: SortOrder, nulls: 'first' | 'last'): SelectQueryBuilder<any, any, any>;
+  /**
+   * Builds a fuzzy search filter for a string field using PostgreSQL `pg_trgm`.
+   * The selected SQL form (operator vs. function, with/without `unaccent`) depends
+   * on the resolved options.
+   */
+  abstract buildFuzzyFilter(fieldRef: Expression<any>, options: FuzzyFilterOptions): Expression<SqlBool>;
+  /**
+   * Builds an ORDER BY clause that sorts by fuzzy relevance to a search term.
+   */
+  abstract buildFuzzyRelevanceOrderBy(query: SelectQueryBuilder<any, any, any>, fieldRefs: Expression<any>[], search: string, sort: SortOrder, mode: FuzzyFilterOptions['mode'], unaccent: boolean): SelectQueryBuilder<any, any, any>;
+  /**
+   * Validate the user-provided fuzzy filter payload and apply defaults so dialects
+   * always receive a fully-resolved {@link FuzzyFilterOptions} value.
+   */
+  protected normalizeFuzzyOptions(value: unknown): FuzzyFilterOptions;
+  /**
+   * Builds a full-text-search filter for a string field. Receives the raw
+   * user-supplied filter payload — dialects validate/normalize it themselves
+   * (the shape is provider-specific; only Postgres supports this filter).
+   */
+  abstract buildFullTextFilter(fieldRef: Expression<any>, payload: unknown): Expression<SqlBool>;
+  /**
+   * Builds an ORDER BY clause that sorts by full-text-search relevance to a search term.
+   */
+  abstract buildFtsRelevanceOrderBy(query: SelectQueryBuilder<any, any, any>, fieldRefs: Expression<any>[], search: string, config: string | undefined, sort: SortOrder): SelectQueryBuilder<any, any, any>;
 }
+/**
+ * Resolved options for a fuzzy filter passed to a dialect. `mode` and `unaccent`
+ * are always populated (defaults: `mode='simple'`, `unaccent=false`, applied by
+ * `normalizeFuzzyOptions`); `threshold` is optional and switches the SQL from
+ * operator form (`%`, `<%`, `<<%`) to function form (`similarity() > threshold`).
+ */
+type FuzzyFilterOptions = {
+  search: string;
+  mode: 'simple' | 'word' | 'strictWord';
+  threshold?: number;
+  unaccent: boolean;
+};
 //#endregion
 //#region src/client/crud/validator/validator.d.ts
 type InputValidatorOptions = {
@@ -1111,7 +1141,43 @@ type WhereInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Optio
   OR?: WhereInput<Schema, Model, Options, ScalarOnly>[];
   NOT?: OrArray<WhereInput<Schema, Model, Options, ScalarOnly>>;
 };
-type FieldFilter<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Options extends QueryOptions<Schema>, WithAggregations extends boolean, AllowedKinds extends FilterKind = GetSlicedFilterKindsForField<Schema, Model, Field, Options>> = Field extends RelationFields<Schema, Model> ? RelationFilter<Schema, Model, Field, Options, AllowedKinds> : FieldIsArray<Schema, Model, Field> extends true ? ArrayFilter<Schema, GetModelFieldType<Schema, Model, Field>, AllowedKinds> : GetModelFieldType<Schema, Model, Field> extends GetEnums<Schema> ? EnumFilter<Schema, GetModelFieldType<Schema, Model, Field>, ModelFieldIsOptional<Schema, Model, Field>, WithAggregations, AllowedKinds> : GetModelFieldType<Schema, Model, Field> extends GetTypeDefs<Schema> ? TypedJsonFilter<Schema, GetModelFieldType<Schema, Model, Field>, FieldIsArray<Schema, Model, Field>, ModelFieldIsOptional<Schema, Model, Field>, AllowedKinds> : PrimitiveFilter<GetModelFieldType<Schema, Model, Field>, ModelFieldIsOptional<Schema, Model, Field>, WithAggregations, AllowedKinds>;
+type FieldFilter<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Options extends QueryOptions<Schema>, WithAggregations extends boolean, AllowedKinds extends FilterKind = GetSlicedFilterKindsForField<Schema, Model, Field, Options>> = Field extends RelationFields<Schema, Model> ? RelationFilter<Schema, Model, Field, Options, AllowedKinds> : FieldIsArray<Schema, Model, Field> extends true ? ArrayFilter<Schema, GetModelFieldType<Schema, Model, Field>, AllowedKinds> : GetModelFieldType<Schema, Model, Field> extends GetEnums<Schema> ? EnumFilter<Schema, GetModelFieldType<Schema, Model, Field>, ModelFieldIsOptional<Schema, Model, Field>, WithAggregations, AllowedKinds> : GetModelFieldType<Schema, Model, Field> extends GetTypeDefs<Schema> ? TypedJsonFilter<Schema, GetModelFieldType<Schema, Model, Field>, FieldIsArray<Schema, Model, Field>, ModelFieldIsOptional<Schema, Model, Field>, AllowedKinds> : GetModelFieldType<Schema, Model, Field> extends 'String' ? AddFullTextFilterIfSupported<Schema, Model, Field, AllowedKinds, AddFuzzyFilterIfSupported<Schema, Model, Field, AllowedKinds, PrimitiveFilter<GetModelFieldType<Schema, Model, Field>, ModelFieldIsOptional<Schema, Model, Field>, WithAggregations, AllowedKinds>>> : PrimitiveFilter<GetModelFieldType<Schema, Model, Field>, ModelFieldIsOptional<Schema, Model, Field>, WithAggregations, AllowedKinds>;
+/**
+ * Conditionally augments a string-field filter with the `fuzzy` operator when:
+ * 1. The `Fuzzy` filter kind is allowed for this field, AND
+ * 2. The schema's provider supports fuzzy search (postgres only), AND
+ * 3. The field is annotated with `@fuzzy` in the ZModel schema.
+ *
+ * Caller is responsible for only invoking this on String-typed fields
+ * (the gate lives in `FieldFilter`).
+ */
+type AddFuzzyFilterIfSupported<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, AllowedKinds extends FilterKind, Base> = 'Fuzzy' extends AllowedKinds ? ProviderSupportsFuzzy<Schema> extends true ? GetModelField<Schema, Model, Field>['fuzzy'] extends true ? Base & {
+  /**
+   * Performs a fuzzy search on the string field. Only available when
+   * the schema's provider is `postgresql` (requires `pg_trgm` extension)
+   * and the field is annotated with `@fuzzy` in the ZModel schema.
+   * See {@link FuzzyFilterPayload} for the full options reference.
+   */
+  fuzzy?: FuzzyFilterPayload;
+} : Base : Base : Base;
+/**
+ * Conditionally augments a string-field filter with the `fts` operator when:
+ * 1. The `FullText` filter kind is allowed for this field, AND
+ * 2. The schema's provider supports full-text search (postgres only), AND
+ * 3. The field is annotated with `@fullText` in the ZModel schema.
+ *
+ * Caller is responsible for only invoking this on String-typed fields
+ * (the gate lives in `FieldFilter`).
+ */
+type AddFullTextFilterIfSupported<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, AllowedKinds extends FilterKind, Base> = 'FullText' extends AllowedKinds ? ProviderSupportsFullText<Schema> extends true ? GetModelField<Schema, Model, Field>['fullText'] extends true ? Base & {
+  /**
+   * Performs a full-text search on the string field. Only available when
+   * the schema's provider is `postgresql` and the field is annotated with
+   * `@fullText` in the ZModel schema.
+   * See {@link FullTextFilterPayload} for the full options reference.
+   */
+  fts?: FullTextFilterPayload;
+} : Base : Base : Base;
 type EnumFilter<Schema extends SchemaDef, T extends GetEnums<Schema>, Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind> = ('Equality' extends AllowedKinds ? NullableIf<keyof GetEnum<Schema, T>, Nullable> : never) | (('Equality' extends AllowedKinds ? {
   /**
    * Checks for equality with the specified enum value.
@@ -1375,8 +1441,8 @@ type JsonFilter<AllowedKinds extends FilterKind = FilterKind> = ('Equality' exte
    */
   array_ends_with?: JsonValue;
 } : {});
-type TypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, Array extends boolean, Optional extends boolean, AllowedKinds extends FilterKind> = XOR<JsonFilter<AllowedKinds>, TypedJsonTypedFilter<Schema, TypeDefName, Array, Optional, AllowedKinds>>;
-type TypedJsonTypedFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, Array extends boolean, Optional extends boolean, AllowedKinds extends FilterKind> = 'Json' extends AllowedKinds ? (Array extends true ? ArrayTypedJsonFilter<Schema, TypeDefName, AllowedKinds> : NonArrayTypedJsonFilter<Schema, TypeDefName, AllowedKinds>) | (Optional extends true ? null | JsonNullValues : never) : {};
+type TypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, Array extends boolean, Optional extends boolean, AllowedKinds extends FilterKind> = (JsonFilter<AllowedKinds> & { [Key in GetTypeDefFields<Schema, TypeDefName>]?: never }) | (TypedJsonTypedFilter<Schema, TypeDefName, Array, AllowedKinds> & { [Key in keyof JsonFilter<AllowedKinds>]?: never }) | (Optional extends true ? null | JsonNullValues : never);
+type TypedJsonTypedFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, Array extends boolean, AllowedKinds extends FilterKind> = 'Json' extends AllowedKinds ? Array extends true ? ArrayTypedJsonFilter<Schema, TypeDefName, AllowedKinds> : NonArrayTypedJsonFilter<Schema, TypeDefName, AllowedKinds> : {};
 type ArrayTypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, AllowedKinds extends FilterKind> = {
   some?: TypedJsonFieldsFilter<Schema, TypeDefName, AllowedKinds>;
   every?: TypedJsonFieldsFilter<Schema, TypeDefName, AllowedKinds>;
@@ -1389,6 +1455,142 @@ type NonArrayTypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTy
 type TypedJsonFieldsFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, AllowedKinds extends FilterKind> = { [Key in GetTypeDefFields<Schema, TypeDefName>]?: GetTypeDefFieldType<Schema, TypeDefName, Key> extends GetTypeDefs<Schema> ? TypedJsonFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsArray<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>, AllowedKinds> : TypeDefFieldIsArray<Schema, TypeDefName, Key> extends true ? ArrayFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>, AllowedKinds> : GetTypeDefFieldType<Schema, TypeDefName, Key> extends GetEnums<Schema> ? EnumFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>, false, AllowedKinds> : PrimitiveFilter<GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>, false, AllowedKinds> };
 type SortOrder = 'asc' | 'desc';
 type NullsOrder = 'first' | 'last';
+type StringFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = { [Key in NonRelationFields<Schema, Model>]: MapModelFieldType<Schema, Model, Key> extends string | null ? Key : never }[NonRelationFields<Schema, Model>];
+/**
+ * String fields that have been annotated with `@fuzzy` and are therefore eligible
+ * for `_fuzzyRelevance` ordering.
+ */
+type FuzzyFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = { [Key in StringFields<Schema, Model>]: GetModelField<Schema, Model, Key>['fuzzy'] extends true ? Key : never }[StringFields<Schema, Model>];
+/**
+ * Payload for the `fuzzy` string filter operator. Performs a fuzzy search using
+ * PostgreSQL `pg_trgm` (only available when the schema's provider is `postgresql`).
+ * Not supported on MySQL or SQLite (throws `NotSupported` at runtime).
+ *
+ * Modes:
+ * - `'simple'` (default): trigram similarity on the whole value (operator `%`,
+ *   function `similarity()`).
+ * - `'word'`: word similarity — checks if the search term is approximately
+ *   contained as a word inside the value (operator `<%`,
+ *   function `word_similarity()`).
+ * - `'strictWord'`: stricter variant of `'word'` (operator `<<%`,
+ *   function `strict_word_similarity()`).
+ *
+ * When `threshold` is provided the function form is used
+ * (`similarity() > threshold`) instead of the operator form, so the
+ * `pg_trgm.*_threshold` session settings are bypassed.
+ *
+ * `unaccent` is opt-in (defaults to `false`) — set it to `true` to make the
+ * comparison accent-insensitive. Enabling it requires the `unaccent` extension
+ * to be installed on the database.
+ */
+type FuzzyFilterPayload = {
+  /**
+   * Search term to match against (must be a non-empty string).
+   */
+  search: string;
+  /**
+   * Matching mode. Defaults to `'simple'`.
+   */
+  mode?: 'simple' | 'word' | 'strictWord';
+  /**
+   * Optional similarity threshold in `[0, 1]`. When provided, the function
+   * form is used and matches require `similarity > threshold`.
+   */
+  threshold?: number;
+  /**
+   * Whether to apply `unaccent()` to both sides. Defaults to `false`.
+   * Set to `true` to enable accent-insensitive matching (requires the
+   * `unaccent` extension on PostgreSQL).
+   */
+  unaccent?: boolean;
+};
+type FuzzyRelevanceOrderBy<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+  /**
+   * Sorts by fuzzy search relevance using PostgreSQL `pg_trgm` similarity functions.
+   * Not supported on MySQL or SQLite (throws `NotSupported` at runtime).
+   * Cannot be combined with cursor-based pagination.
+   */
+  _fuzzyRelevance?: {
+    /**
+     * String fields annotated with `@fuzzy` to compute relevance against (must be non-empty).
+     *
+     * When multiple fields are provided, the row's relevance score is the
+     * greatest per-field similarity, i.e. `GREATEST(similarity(field1, search), similarity(field2, search), ...)`.
+     */
+    fields: [FuzzyFields<Schema, Model>, ...FuzzyFields<Schema, Model>[]];
+    /**
+     * The search term to compute relevance for.
+     */
+    search: string;
+    /**
+     * Fuzzy matching mode used to compute relevance.
+     */
+    mode?: 'simple' | 'word' | 'strictWord';
+    /**
+     * Whether to remove accents before computing relevance.
+     */
+    unaccent?: boolean;
+    /**
+     * Sort direction.
+     */
+    sort: SortOrder;
+  };
+};
+/**
+ * String fields that have been annotated with `@fullText` and are therefore eligible
+ * for `_ftsRelevance` ordering.
+ */
+type FullTextFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = { [Key in StringFields<Schema, Model>]: GetModelField<Schema, Model, Key>['fullText'] extends true ? Key : never }[StringFields<Schema, Model>];
+/**
+ * Payload for the `fts` string filter operator. Performs full-text search using
+ * PostgreSQL `to_tsvector` / `to_tsquery` (postgresql provider only).
+ *
+ * Query syntax follows `to_tsquery`: callers write raw `&` (AND), `|` (OR),
+ * `!` (NOT), `<->` (FOLLOWED BY). Malformed queries throw at SQL execution time.
+ */
+type FullTextFilterPayload = {
+  /**
+   * Search query in `to_tsquery` syntax (must be a non-empty string).
+   */
+  search: string;
+  /**
+   * Postgres text-search configuration (e.g. `'english'`, `'simple'`). When
+   * omitted, the database's `default_text_search_config` setting is used —
+   * the SQL is emitted as `to_tsvector(field) @@ to_tsquery(query)` without
+   * an explicit regconfig argument.
+   */
+  config?: string;
+};
+type FtsRelevanceOrderBy<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+  /**
+   * Sorts by full-text-search relevance using PostgreSQL `ts_rank`.
+   */
+  _ftsRelevance?: {
+    /**
+     * String fields annotated with `@fullText` to compute relevance against (must be non-empty).
+     *
+     * When multiple fields are provided, the fields are concatenated with a
+     * space separator and a single `ts_rank` is computed over the combined
+     * document — i.e. `ts_rank(to_tsvector(concat_ws(' ', f1, f2, ...)), q)`.
+     * This means an AND query (e.g. `'cat & dog'`) matches rows where the
+     * terms appear across different fields, not just within the same field.
+     */
+    fields: [FullTextFields<Schema, Model>, ...FullTextFields<Schema, Model>[]];
+    /**
+     * The search term to compute relevance for (in `to_tsquery` syntax).
+     */
+    search: string;
+    /**
+     * Postgres text-search configuration. When omitted, the database's
+     * `default_text_search_config` setting is used.
+     */
+    config?: string;
+    /**
+     * Sort direction.
+     */
+    sort: SortOrder;
+  };
+};
 type OrderBy<Schema extends SchemaDef, Model extends GetModels<Schema>, WithRelation extends boolean, WithAggregation extends boolean> = { [Key in NonRelationFields<Schema, Model>]?: ModelFieldIsOptional<Schema, Model, Key> extends true ? SortOrder | {
   /**
    * Sort order
@@ -1499,7 +1701,7 @@ type SortAndTakeArgs<Schema extends SchemaDef, Model extends GetModels<Schema>,
   /**
    * Order by clauses
    */
-  orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
+  orderBy?: OrArray<OrderBy<Schema, Model, true, false> & (ProviderSupportsFuzzy<Schema> extends true ? FuzzyRelevanceOrderBy<Schema, Model> : {}) & (ProviderSupportsFullText<Schema> extends true ? FtsRelevanceOrderBy<Schema, Model> : {})>;
   /**
    * Cursor for pagination
    */
@@ -1551,8 +1753,16 @@ type CreateRelationFieldPayload<Schema extends SchemaDef, Model extends GetModel
   connect?: ConnectInput<Schema, Model, Field, Options>;
 }, (FieldIsArray<Schema, Model, Field> extends true ? never : 'createMany') | (RelationModelAllowsCreate<Schema, Model, Field> extends true ? never : 'create' | 'createMany' | 'connectOrCreate')>;
 type CreateRelationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = OptionalWrap<Schema, Model, { [Key in RelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]: CreateRelationFieldPayload<Schema, Model, Key, Options> }>;
-type CreateWithFKInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = CreateScalarPayload<Schema, Model> & CreateFKPayload<Schema, Model> & CreateWithNonOwnedRelationPayload<Schema, Model, Options>;
-type CreateWithRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = CreateScalarPayload<Schema, Model> & CreateRelationPayload<Schema, Model, Options>;
+/**
+ * Create input type that uses FK scalar fields (e.g., `authorId`) instead of
+ * relation objects.
+ */
+type UncheckedCreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = CreateScalarPayload<Schema, Model> & CreateFKPayload<Schema, Model> & CreateWithNonOwnedRelationPayload<Schema, Model, Options>;
+/**
+ * Create input type that uses relation objects (e.g., `author: { connect: … }`)
+ * instead of FK scalar fields.
+ */
+type CheckedCreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = CreateScalarPayload<Schema, Model> & CreateRelationPayload<Schema, Model, Options>;
 type CreateWithNonOwnedRelationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = OptionalWrap<Schema, Model, { [Key in NonOwnedRelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]: CreateRelationFieldPayload<Schema, Model, Key, Options> }>;
 type ConnectOrCreatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = {
   /**
@@ -1574,7 +1784,7 @@ type CreateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>,
    */
   skipDuplicates?: boolean;
 };
-type CreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = XOR<Omit<CreateWithFKInput<Schema, Model, Options>, Without>, Omit<CreateWithRelationInput<Schema, Model, Options>, Without>>;
+type CreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = XOR<Omit<UncheckedCreateInput<Schema, Model, Options>, Without>, Omit<CheckedCreateInput<Schema, Model, Options>, Without>>;
 type NestedCreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = OrArray<CreateInput<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>, FieldIsArray<Schema, Model, Field>>;
 type NestedCreateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = CreateManyInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
 type UpdateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
@@ -1593,7 +1803,7 @@ type UpdateManyPayload<Schema extends SchemaDef, Model extends GetModels<Schema>
   /**
    * The data to update the records with.
    */
-  data: OrArray<UpdateScalarInput<Schema, Model, Without>>;
+  data: OrArray<UpdateScalarInput<Schema, Model, Without> & UpdateFKPayload<Schema, Model, Without>>;
   /**
    * The filter to select records to update.
    */
@@ -1617,7 +1827,8 @@ type UpsertArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Optio
    */
   where: WhereUniqueInput<Schema, Model, Options>;
 } & SelectIncludeOmit<Schema, Model, true, Options, true, ExtResult> & ExtractExtQueryArgs<ExtQueryArgs, 'upsert'>;
-type UpdateScalarInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = Omit<{ [Key in NonRelationFields<Schema, Model> as FieldIsDelegateDiscriminator<Schema, Model, Key> extends true ? never : Key]?: ScalarUpdatePayload<Schema, Model, Key> }, Without>;
+type UpdateScalarInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = Omit<{ [Key in Exclude<NonRelationFields<Schema, Model>, ForeignKeyFields<Schema, Model>> as FieldIsDelegateDiscriminator<Schema, Model, Key> extends true ? never : Key]?: ScalarUpdatePayload<Schema, Model, Key> }, Without>;
+type UpdateFKPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = Omit<{ [Key in ForeignKeyFields<Schema, Model>]?: MapModelFieldType<Schema, Model, Key> }, Without>;
 type ScalarUpdatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends NonRelationFields<Schema, Model>> = ScalarFieldMutationPayload<Schema, Model, Field> | (Field extends NumericFields<Schema, Model> ? {
   /**
    * Sets the field to the specified value.
@@ -1650,7 +1861,18 @@ type ScalarUpdatePayload<Schema extends SchemaDef, Model extends GetModels<Schem
   push?: OrArray<MapModelFieldType<Schema, Model, Field>, true>;
 } : never);
 type UpdateRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = Omit<{ [Key in RelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]?: UpdateRelationFieldPayload<Schema, Model, Key, Options> }, Without>;
-type UpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = UpdateScalarInput<Schema, Model, Without> & UpdateRelationInput<Schema, Model, Options, Without>;
+type UpdateNonOwnedRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = { [Key in NonOwnedRelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]?: UpdateRelationFieldPayload<Schema, Model, Key, Options> };
+/**
+ * Update input type that uses FK scalar fields (e.g., `authorId`) instead of
+ * relation objects.
+ */
+type UncheckedUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = UpdateScalarInput<Schema, Model> & UpdateFKPayload<Schema, Model> & UpdateNonOwnedRelationInput<Schema, Model, Options>;
+/**
+ * Update input type that uses relation objects (e.g., `author: { connect: … }`)
+ * instead of FK scalar fields.
+ */
+type CheckedUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = UpdateScalarInput<Schema, Model> & UpdateRelationInput<Schema, Model, Options>;
+type UpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = XOR<Omit<UncheckedUpdateInput<Schema, Model, Options>, Without>, Omit<CheckedUpdateInput<Schema, Model, Options>, Without>>;
 type UpdateRelationFieldPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? ToManyRelationUpdateInput<Schema, Model, Field, Options> : ToOneRelationUpdateInput<Schema, Model, Field, Options>;
 type ToManyRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = Omit<{
   /**
@@ -1923,6 +2145,62 @@ type GroupByResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Ar
    */
   _max: AggCommonOutput<Max>;
 } : {})>;
+/**
+ * Maps each CRUD operation name to its argument type for a given model.
+ */
+type CrudArgsMap<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
+  findMany: FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
+  findUnique: FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
+  findUniqueOrThrow: FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
+  findFirst: FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
+  findFirstOrThrow: FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
+  create: CreateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
+  createMany: CreateManyArgs<Schema, Model, Options, ExtQueryArgs>;
+  createManyAndReturn: CreateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
+  update: UpdateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
+  updateMany: UpdateManyArgs<Schema, Model, Options, ExtQueryArgs>;
+  updateManyAndReturn: UpdateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
+  upsert: UpsertArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
+  delete: DeleteArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
+  deleteMany: DeleteManyArgs<Schema, Model, Options, ExtQueryArgs>;
+  count: CountArgs<Schema, Model, Options, ExtQueryArgs>;
+  aggregate: AggregateArgs<Schema, Model, Options, ExtQueryArgs>;
+  groupBy: GroupByArgs<Schema, Model, Options, ExtQueryArgs>;
+  exists: ExistsArgs<Schema, Model, Options, ExtQueryArgs>;
+};
+/**
+ * Maps a CRUD operation name to its argument type for a given model.
+ */
+type CrudArgsType<Schema extends SchemaDef, Model extends GetModels<Schema>, Op extends AllCrudOperations, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = CrudArgsMap<Schema, Model, Options, ExtQueryArgs, ExtResult>[Op];
+/**
+ * Maps each CRUD operation name to its return type for a given model + args.
+ */
+type CrudReturnMap<Schema extends SchemaDef, Model extends GetModels<Schema>, Args, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtResult extends ExtResultBase<Schema> = {}> = {
+  findMany: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>[];
+  findUnique: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult> | null;
+  findUniqueOrThrow: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>;
+  findFirst: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult> | null;
+  findFirstOrThrow: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>;
+  create: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>;
+  createMany: BatchResult;
+  createManyAndReturn: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>[];
+  update: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>;
+  updateMany: BatchResult;
+  updateManyAndReturn: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>[];
+  upsert: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>;
+  delete: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>;
+  deleteMany: BatchResult;
+  count: CountResult<Schema, Model, Args>;
+  aggregate: AggregateResult<Schema, Model, Args>;
+  groupBy: Args extends {
+    by: unknown;
+  } ? GroupByResult<Schema, Model, Args> : never;
+  exists: boolean;
+};
+/**
+ * Maps a CRUD operation name to its return type for a given model + args.
+ */
+type CrudReturnType<Schema extends SchemaDef, Model extends GetModels<Schema>, Op extends AllCrudOperations, Args, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtResult extends ExtResultBase<Schema> = {}> = CrudReturnMap<Schema, Model, Args, Options, ExtResult>[Op];
 type ConnectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>> : WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
 type ConnectOrCreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<ConnectOrCreatePayload<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>> : ConnectOrCreatePayload<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>;
 type DisconnectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>, true> : boolean | WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
@@ -2017,6 +2295,8 @@ type HasToManyRelations<Schema extends SchemaDef, Model extends GetModels<Schema
 type EnumValue<Schema extends SchemaDef, Enum extends GetEnums<Schema>> = GetEnum<Schema, Enum>[keyof GetEnum<Schema, Enum>];
 type MapType<Schema extends SchemaDef, T extends string> = T extends keyof TypeMap ? TypeMap[T] : T extends GetModels<Schema> ? ModelResult<Schema, T> : T extends GetTypeDefs<Schema> ? TypeDefResult<Schema, T> : T extends GetEnums<Schema> ? EnumValue<Schema, T> : unknown;
 type ProviderSupportsDistinct<Schema extends SchemaDef> = Schema['provider']['type'] extends 'postgresql' ? true : false;
+type ProviderSupportsFuzzy<Schema extends SchemaDef> = Schema['provider']['type'] extends 'postgresql' ? true : false;
+type ProviderSupportsFullText<Schema extends SchemaDef> = Schema['provider']['type'] extends 'postgresql' ? true : false;
 /**
  * Extracts extended query args for a specific operation.
  */
@@ -2096,13 +2376,9 @@ interface Diagnostics {
 /**
  * A promise that only executes when it's awaited or .then() is called.
  */
-type ZenStackPromise<Schema extends SchemaDef, T> = Promise<T> & {
-  /**
-   * @private
-   * Callable to get a plain promise.
-   */
-  cb: (txClient?: ClientContract<Schema>) => Promise<T>;
-};
+interface ZenStackPromise<T> extends Promise<T> {
+  [Symbol.toStringTag]: 'ZenStackPromise';
+}
 //#endregion
 //#region src/client/contract.d.ts
 type TransactionUnsupportedMethods = (typeof TRANSACTION_UNSUPPORTED_METHODS)[number];
@@ -2116,6 +2392,19 @@ declare enum TransactionIsolationLevel {
   Serializable = "serializable",
   Snapshot = "snapshot"
 }
+/**
+ * Symbol used as a type-only key on `ClientContract` to brand the `ExtQueryArgs`
+ * generic slot. Hidden from member-access autocomplete since symbol keys are
+ * not surfaced. Consumed by `InferExtQueryArgs` to recover the slot.
+ * @internal
+ */
+declare const ExtQueryArgsMarker: unique symbol;
+/**
+ * Symbol used as a type-only key on `ClientContract` to brand the `ExtResult`
+ * generic slot. Consumed by `InferExtResult` to recover the slot.
+ * @internal
+ */
+declare const ExtResultMarker: unique symbol;
 /**
  * ZenStack client interface.
  */
@@ -2127,7 +2416,9 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
   /**
    * The client options.
    */
-  readonly $options: Options;
+  readonly $options: Options; /** @internal type-only brand carrying the `ExtQueryArgs` slot for inference. */
+  readonly [ExtQueryArgsMarker]?: ExtQueryArgs; /** @internal type-only brand carrying the `ExtResult` slot for inference. */
+  readonly [ExtResultMarker]?: ExtResult;
   /**
    * Executes a prepared raw query and returns the number of affected rows.
    * @example
@@ -2135,7 +2426,7 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
    * const result = await db.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
    * ```
    */
-  $executeRaw(query: TemplateStringsArray, ...values: any[]): ZenStackPromise<Schema, number>;
+  $executeRaw(query: TemplateStringsArray, ...values: any[]): ZenStackPromise<number>;
   /**
    * Executes a raw query and returns the number of affected rows.
    * This method is susceptible to SQL injections.
@@ -2144,7 +2435,7 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
    * const result = await db.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
    * ```
    */
-  $executeRawUnsafe(query: string, ...values: any[]): ZenStackPromise<Schema, number>;
+  $executeRawUnsafe(query: string, ...values: any[]): ZenStackPromise<number>;
   /**
    * Performs a prepared raw query and returns the `SELECT` data.
    * @example
@@ -2152,7 +2443,7 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
    * const result = await db.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`
    * ```
    */
-  $queryRaw<T = unknown>(query: TemplateStringsArray, ...values: any[]): ZenStackPromise<Schema, T>;
+  $queryRaw<T = unknown>(query: TemplateStringsArray, ...values: any[]): ZenStackPromise<T>;
   /**
    * Performs a raw query and returns the `SELECT` data.
    * This method is susceptible to SQL injections.
@@ -2161,7 +2452,7 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
    * const result = await db.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
    * ```
    */
-  $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): ZenStackPromise<Schema, T>;
+  $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): ZenStackPromise<T>;
   /**
    * The current user identity. If the client is not bound to any user context, returns `undefined`.
    */
@@ -2228,7 +2519,7 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
    *   db.post.create({ data: { title: 'Hello World', authorId: 1 } }),
    * ]);
    */
-  $transaction<P extends ZenStackPromise<Schema, any>[]>(arg: [...P], options?: {
+  $transaction<P extends ZenStackPromise<any>[]>(arg: [...P], options?: {
     isolationLevel?: TransactionIsolationLevel;
   }): Promise<UnwrapTuplePromises<P>>;
   /**
@@ -2321,7 +2612,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
    * });
    * ```
    */
-  createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
+  createManyAndReturn<T extends CrudArgsType<Schema, Model, 'createManyAndReturn', Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, CrudArgsType<Schema, Model, 'createManyAndReturn', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'createManyAndReturn', T, Options, ExtResult>>;
   /**
    * Updates multiple entities and returns them.
    * @param args - update args. Only scalar fields are allowed for data.
@@ -2344,7 +2635,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
    * });
    * ```
    */
-  updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: Subset<T, UpdateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
+  updateManyAndReturn<T extends CrudArgsType<Schema, Model, 'updateManyAndReturn', Options, ExtQueryArgs, ExtResult>>(args: Subset<T, CrudArgsType<Schema, Model, 'updateManyAndReturn', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'updateManyAndReturn', T, Options, ExtResult>>;
 });
 type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase, ExtResult extends ExtResultBase<Schema> = {}> = {
   /**
@@ -2428,35 +2719,35 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
    * }); // result: `{ _count: { posts: number } }`
    * ```
    */
-  findMany<T extends FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
+  findMany<T extends CrudArgsType<Schema, Model, 'findMany', Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, CrudArgsType<Schema, Model, 'findMany', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'findMany', T, Options, ExtResult>>;
   /**
    * Returns a uniquely identified entity.
    * @param args - query args
    * @returns a single entity or null if not found
    * @see {@link findMany}
    */
-  findUnique<T extends FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
+  findUnique<T extends CrudArgsType<Schema, Model, 'findUnique', Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, CrudArgsType<Schema, Model, 'findUnique', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'findUnique', T, Options, ExtResult>>;
   /**
    * Returns a uniquely identified entity or throws `NotFoundError` if not found.
    * @param args - query args
    * @returns a single entity
    * @see {@link findMany}
    */
-  findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>>;
+  findUniqueOrThrow<T extends CrudArgsType<Schema, Model, 'findUniqueOrThrow', Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, CrudArgsType<Schema, Model, 'findUniqueOrThrow', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'findUniqueOrThrow', T, Options, ExtResult>>;
   /**
    * Returns the first entity.
    * @param args - query args
    * @returns a single entity or null if not found
    * @see {@link findMany}
    */
-  findFirst<T extends FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
+  findFirst<T extends CrudArgsType<Schema, Model, 'findFirst', Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, CrudArgsType<Schema, Model, 'findFirst', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'findFirst', T, Options, ExtResult>>;
   /**
    * Returns the first entity or throws `NotFoundError` if not found.
    * @param args - query args
    * @returns a single entity
    * @see {@link findMany}
    */
-  findFirstOrThrow<T extends FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>>;
+  findFirstOrThrow<T extends CrudArgsType<Schema, Model, 'findFirstOrThrow', Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, CrudArgsType<Schema, Model, 'findFirstOrThrow', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'findFirstOrThrow', T, Options, ExtResult>>;
   /**
    * Creates a new entity.
    * @param args - create args
@@ -2509,7 +2800,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
    * });
    * ```
    */
-  create<T extends CreateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, CreateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>>;
+  create<T extends CrudArgsType<Schema, Model, 'create', Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, CrudArgsType<Schema, Model, 'create', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'create', T, Options, ExtResult>>;
   /**
    * Creates multiple entities. Only scalar fields are allowed.
    * @param args - create args
@@ -2535,7 +2826,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
    * });
    * ```
    */
-  createMany<T extends CreateManyArgs<Schema, Model, Options, ExtQueryArgs>>(args?: SelectSubset<T, CreateManyArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, BatchResult>;
+  createMany<T extends CrudArgsType<Schema, Model, 'createMany', Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, CrudArgsType<Schema, Model, 'createMany', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'createMany', T, Options, ExtResult>>;
   /**
    * Updates a uniquely identified entity.
    * @param args - update args. See {@link findMany} for how to control
@@ -2653,7 +2944,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
    * });
    * ```
    */
-  update<T extends UpdateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, UpdateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>>;
+  update<T extends CrudArgsType<Schema, Model, 'update', Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, CrudArgsType<Schema, Model, 'update', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'update', T, Options, ExtResult>>;
   /**
    * Updates multiple entities.
    * @param args - update args. Only scalar fields are allowed for data.
@@ -2674,7 +2965,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
    *     limit: 10
    * });
    */
-  updateMany<T extends UpdateManyArgs<Schema, Model, Options, ExtQueryArgs>>(args: Subset<T, UpdateManyArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, BatchResult>;
+  updateMany<T extends CrudArgsType<Schema, Model, 'updateMany', Options, ExtQueryArgs, ExtResult>>(args: Subset<T, CrudArgsType<Schema, Model, 'updateMany', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'updateMany', T, Options, ExtResult>>;
   /**
    * Creates or updates an entity.
    * @param args - upsert args
@@ -2695,7 +2986,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
    * });
    * ```
    */
-  upsert<T extends UpsertArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, UpsertArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>>;
+  upsert<T extends CrudArgsType<Schema, Model, 'upsert', Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, CrudArgsType<Schema, Model, 'upsert', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'upsert', T, Options, ExtResult>>;
   /**
    * Deletes a uniquely identifiable entity.
    * @param args - delete args
@@ -2715,7 +3006,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
    * }); // result: `{ id: string; email: string }`
    * ```
    */
-  delete<T extends DeleteArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, DeleteArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>>;
+  delete<T extends CrudArgsType<Schema, Model, 'delete', Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, CrudArgsType<Schema, Model, 'delete', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'delete', T, Options, ExtResult>>;
   /**
    * Deletes multiple entities.
    * @param args - delete args
@@ -2735,7 +3026,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
    * });
    * ```
    */
-  deleteMany<T extends DeleteManyArgs<Schema, Model, Options, ExtQueryArgs>>(args?: Subset<T, DeleteManyArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, BatchResult>;
+  deleteMany<T extends CrudArgsType<Schema, Model, 'deleteMany', Options, ExtQueryArgs, ExtResult>>(args?: Subset<T, CrudArgsType<Schema, Model, 'deleteMany', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'deleteMany', T, Options, ExtResult>>;
   /**
    * Counts rows or field values.
    * @param args - count args
@@ -2754,7 +3045,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
    *     select: { _all: true, email: true }
    * }); // result: `{ _all: number, email: number }`
    */
-  count<T extends CountArgs<Schema, Model, Options, ExtQueryArgs>>(args?: Subset<T, CountArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, Simplify<CountResult<Schema, Model, T>>>;
+  count<T extends CrudArgsType<Schema, Model, 'count', Options, ExtQueryArgs, ExtResult>>(args?: Subset<T, CrudArgsType<Schema, Model, 'count', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Simplify<CrudReturnType<Schema, Model, 'count', T, Options, ExtResult>>>;
   /**
    * Aggregates rows.
    * @param args - aggregation args
@@ -2772,7 +3063,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
    *     _max: { age: true }
    * }); // result: `{ _count: number, _avg: { age: number }, ... }`
    */
-  aggregate<T extends AggregateArgs<Schema, Model, Options, ExtQueryArgs>>(args: Subset<T, AggregateArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, Simplify<AggregateResult<Schema, Model, T>>>;
+  aggregate<T extends CrudArgsType<Schema, Model, 'aggregate', Options, ExtQueryArgs, ExtResult>>(args: Subset<T, CrudArgsType<Schema, Model, 'aggregate', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Simplify<CrudReturnType<Schema, Model, 'aggregate', T, Options, ExtResult>>>;
   /**
    * Groups rows by columns.
    * @param args - groupBy args
@@ -2806,7 +3097,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
    *     having: { country: 'US', age: { _avg: { gte: 18 } } }
    * });
    */
-  groupBy<T extends GroupByArgs<Schema, Model, Options, ExtQueryArgs>>(args: Subset<T, GroupByArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, Simplify<GroupByResult<Schema, Model, T>>>;
+  groupBy<T extends CrudArgsType<Schema, Model, 'groupBy', Options, ExtQueryArgs, ExtResult>>(args: Subset<T, CrudArgsType<Schema, Model, 'groupBy', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Simplify<CrudReturnType<Schema, Model, 'groupBy', T, Options, ExtResult>>>;
   /**
    * Checks if an entity exists.
    * @param args - exists args
@@ -2824,7 +3115,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
    *     where: { posts: { some: { published: true } } },
    * }); // result: `boolean`
    */
-  exists<T extends ExistsArgs<Schema, Model, Options, ExtQueryArgs>>(args?: Subset<T, ExistsArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, boolean>;
+  exists<T extends CrudArgsType<Schema, Model, 'exists', Options, ExtQueryArgs, ExtResult>>(args?: Subset<T, CrudArgsType<Schema, Model, 'exists', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'exists', T, Options, ExtResult>>;
 };
 type OperationsRequiringCreate = 'create' | 'createMany' | 'createManyAndReturn' | 'upsert';
 type ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema> = ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = SliceOperations<AllModelOperations<Schema, Model, Options, ExtQueryArgs, ExtResult>, Schema, Model, Options>;
@@ -2929,6 +3220,8 @@ declare class ZodSchemaFactory<Schema extends SchemaDef, Options extends ClientO
   private makeNumberFilterSchema;
   private makeStringFilterSchema;
   private makeStringModeSchema;
+  private makeFuzzyFilterSchema;
+  private makeFullTextFilterSchema;
   private makeSelectSchema;
   private makeCountSelectionSchema;
   private makeRelationSelectIncludeSchema;
@@ -2981,6 +3274,8 @@ declare class ZodSchemaFactory<Schema extends SchemaDef, Options extends ClientO
   private orArray;
   private isNumericField;
   private get providerSupportsCaseSensitivity();
+  private get providerSupportsFullTextSearch();
+  private get providerSupportsFuzzySearch();
   /**
    * Gets the effective set of allowed FilterKind values for a specific model and field.
    * Respects the precedence: model[field] > model.$all > $all[field] > $all.$all.
@@ -3215,5 +3510,5 @@ declare class MatchingExpressionVisitor extends ExpressionVisitor {
   };
 }
 //#endregion
-export { AfterEntityMutationCallback, AggregateArgs, AggregateResult, AllCrudOperations, AllModelOperations, AllReadOperations, AllWriteOperations, AnyNull, AnyNullClass, AnyPlugin, AuthType, BaseCrudDialect, BatchResult, BeforeEntityMutationCallback, BooleanFilter, BytesFilter, CRUD, CRUD_EXT, ClientConstructor, ClientContract, ClientOptions, ComputedFieldsOptions, CoreCreateOperations, CoreCrudOperations, CoreDeleteOperations, CoreReadOperations, CoreUpdateOperations, CoreWriteOperations, CountArgs, CountResult, CreateArgs, CreateInput, CreateManyAndReturnArgs, CreateManyArgs, CreateManyInput, DateTimeFilter, DbNull, DbNullClass, DefaultModelResult, DeleteArgs, DeleteManyArgs, EntityMutationHooksDef, ExistsArgs, ExtClientMembersBase, ExtQueryArgsBase, ExtResultBase, ExtResultInferenceArgs, ExtResultSelectOmitFields, ExtractExtResult, FilterKind, FindArgs, FindFirstArgs, FindManyArgs, FindUniqueArgs, GetAllIncludedOperations, GetIncludedOperations, GetProcedure, GetProcedureNames, GetProcedureParams, GetQueryOptions, GetSlicedFilterKindsForField, GetSlicedModels, GetSlicedOperations, GetSlicedProcedures, GroupByArgs, GroupByResult, HasComputedFields, HasProcedures, IncludeInput, InputValidator, JsonArray, JsonFilter, JsonNull, JsonNullClass, JsonNullValues, JsonObject, JsonValue, kysely_utils_d_exports as KyselyUtils, MapModelFieldType, ModelAllowsCreate, ModelHasRequiredUnsupportedField, ModelOperations, ModelResult, ModelSlicingOptions, NullsOrder, NumberFilter, ORMError, ORMErrorReason, OmitConfig, OmitInput, OnKyselyQueryArgs, OnKyselyQueryCallback, OnProcedureHookContext, OperationsRequiringCreate, OrderBy, PluginAfterEntityMutationArgs, PluginBeforeEntityMutationArgs, ProcedureEnvelope, ProcedureFunc, ProcedureHandlerFunc, ProcedureOperations, ProceduresOptions, ProceedKyselyQueryFunction, QueryOptions, query_utils_d_exports as QueryUtils, RejectedByPolicyReason, RuntimePlugin, schema_utils_d_exports as SchemaUtils, SelectAwareExtResult, SelectIncludeOmit, SelectInput, SelectSubset, SimplifiedPlainResult, SimplifiedResult, SlicingOptions, SortOrder, StringFilter, Subset, type ToKysely, TransactionClientContract, TransactionIsolationLevel, TypeDefResult, TypedJsonFilter, UpdateArgs, UpdateInput, UpdateManyAndReturnArgs, UpdateManyArgs, UpsertArgs, WhereInput, WhereUniqueInput, ZModelFunction, ZModelFunctionContext, ZenStackClient, type ZenStackPromise, type ZodSchemaFactory, createQuerySchemaFactory, definePlugin, getCrudDialect };
+export { AfterEntityMutationCallback, AggregateArgs, AggregateResult, AllCrudOperations, AllModelOperations, AllReadOperations, AllWriteOperations, AnyNull, AnyNullClass, AnyPlugin, AuthType, BaseCrudDialect, BatchResult, BeforeEntityMutationCallback, BooleanFilter, BytesFilter, CRUD, CRUD_EXT, CheckedCreateInput, CheckedUpdateInput, ClientConstructor, ClientContract, ClientOptions, ComputedFieldsOptions, CoreCreateOperations, CoreCrudOperations, CoreDeleteOperations, CoreReadOperations, CoreUpdateOperations, CoreWriteOperations, CountArgs, CountResult, CreateArgs, CreateInput, CreateManyAndReturnArgs, CreateManyArgs, CreateManyInput, CrudArgsMap, CrudArgsType, CrudReturnMap, CrudReturnType, DateTimeFilter, DbNull, DbNullClass, DefaultModelResult, DeleteArgs, DeleteManyArgs, EntityMutationHooksDef, ExistsArgs, ExtClientMembersBase, ExtQueryArgsBase, ExtQueryArgsMarker, ExtResultBase, ExtResultInferenceArgs, ExtResultMarker, ExtResultSelectOmitFields, ExtractExtResult, FilterKind, FindArgs, FindFirstArgs, FindManyArgs, FindUniqueArgs, FtsRelevanceOrderBy, FullTextFilterPayload, FuzzyFilterPayload, FuzzyRelevanceOrderBy, GetAllIncludedOperations, GetIncludedOperations, GetProcedure, GetProcedureNames, GetProcedureParams, GetQueryOptions, GetSlicedFilterKindsForField, GetSlicedModels, GetSlicedOperations, GetSlicedProcedures, GroupByArgs, GroupByResult, HasComputedFields, HasProcedures, IncludeInput, InputValidator, JsonArray, JsonFilter, JsonNull, JsonNullClass, JsonNullValues, JsonObject, JsonValue, kysely_utils_d_exports as KyselyUtils, MapModelFieldType, ModelAllowsCreate, ModelHasRequiredUnsupportedField, ModelOperations, ModelResult, ModelSlicingOptions, NullsOrder, NumberFilter, ORMError, ORMErrorReason, OmitConfig, OmitInput, OnKyselyQueryArgs, OnKyselyQueryCallback, OnProcedureHookContext, OperationsRequiringCreate, OrderBy, PluginAfterEntityMutationArgs, PluginBeforeEntityMutationArgs, ProcedureEnvelope, ProcedureFunc, ProcedureHandlerFunc, ProcedureOperations, ProceduresOptions, ProceedKyselyQueryFunction, QueryOptions, query_utils_d_exports as QueryUtils, RejectedByPolicyReason, RuntimePlugin, schema_utils_d_exports as SchemaUtils, SelectAwareExtResult, SelectIncludeOmit, SelectInput, SelectSubset, SimplifiedPlainResult, SimplifiedResult, SlicingOptions, SortOrder, StringFilter, Subset, type ToKysely, TransactionClientContract, TransactionIsolationLevel, TypeDefResult, TypedJsonFilter, UncheckedCreateInput, UncheckedUpdateInput, UpdateArgs, UpdateInput, UpdateManyAndReturnArgs, UpdateManyArgs, UpsertArgs, WhereInput, WhereUniqueInput, ZModelFunction, ZModelFunctionContext, ZenStackClient, type ZenStackPromise, type ZodSchemaFactory, createQuerySchemaFactory, definePlugin, getCrudDialect };
 //# sourceMappingURL=index.d.cts.map