@an5/orm 1.0.7 → 1.0.9

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+export declare const config: any;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+/**
+ * Workspace Configuration for an5Orm
+ * Reads from an5Orm.config.js and environment variables.
+ */
+const path_1 = __importDefault(require("path"));
+let workspaceConfig = {};
+try {
+    const configPath = path_1.default.join(__dirname, '..', 'an5Orm.config.js');
+    workspaceConfig = require(configPath);
+}
+catch { /* ignore */ }
+exports.config = {
+    ...workspaceConfig,
+    llm: workspaceConfig.llm || {
+        providers: [],
+    },
+};
+//# sourceMappingURL=config.js.map

package/dist/errors.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Core error types for AN5 ORM.
+ * Owned by @an5/orm so generated clients can re-export the same class and
+ * `instanceof` checks keep working across the ORM and its clients.
+ */
+export declare class An5ClientKnownRequestError extends Error {
+    code: string;
+    meta?: any;
+    constructor(message: string, { code }: {
+        code: string;
+        clientVersion: string;
+    });
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Core error types for AN5 ORM.
+ * Owned by @an5/orm so generated clients can re-export the same class and
+ * `instanceof` checks keep working across the ORM and its clients.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.An5ClientKnownRequestError = void 0;
+class An5ClientKnownRequestError extends Error {
+    constructor(message, { code }) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.An5ClientKnownRequestError = An5ClientKnownRequestError;
+//# sourceMappingURL=errors.js.map

package/dist/generator/src/code-generator.d.ts

@@ -8,6 +8,7 @@ export declare class CodeGenerator {
     private generateIndexTs;
     private getAllPropertyVariations;
     private getFieldFilterType;
+    private inputType;
     private normalizeType;
     private toCamelCase;
 }

package/dist/generator/src/code-generator.js

@@ -22,15 +22,11 @@ class CodeGenerator {
     }
     generateBaseTs() {
         const baseTs = `
+import { An5ClientKnownRequestError as An5KnownError } from "@an5/orm";
+
 export namespace An5 {
-  export class An5ClientKnownRequestError extends Error {
-    code!: string;
-    meta?: any;
-    constructor(message: string, { code, clientVersion }: { code: string; clientVersion: string }) {
-      super(message);
-      this.code = code;
-    }
-  }
+  export const An5ClientKnownRequestError: typeof An5KnownError = An5KnownError;
+  export type An5ClientKnownRequestError = An5KnownError;
   export type SortOrder = 'asc' | 'desc';
   export type StringFilter = { equals?: string; in?: string[]; notIn?: string[]; lt?: string; lte?: string; gt?: string; gte?: string; contains?: string; startsWith?: string; endsWith?: string; not?: string | StringFilter; };
   export type StringNullableFilter = { equals?: string | null; in?: (string | null)[]; notIn?: (string | null)[]; lt?: string; lte?: string; gt?: string; gte?: string; contains?: string; startsWith?: string; endsWith?: string; not?: string | StringNullableFilter | null; };
@@ -40,11 +36,11 @@ export namespace An5 {
   export type NumberNullableFilter = { equals?: number | null; in?: (number | null)[]; notIn?: (number | null)[]; lt?: number; lte?: number; gt?: number; gte?: number; not?: number | NumberNullableFilter | null; };
   export type BooleanFilter = { equals?: boolean; not?: boolean | BooleanFilter; };
   export type BooleanNullableFilter = { equals?: boolean | null; not?: boolean | BooleanNullableFilter | null; };
-  export type DateTimeFilter = { equals?: Date; in?: Date[]; notIn?: Date[]; lt?: Date; lte?: Date; gt?: Date; gte?: Date; not?: Date | DateTimeFilter; };
-  export type DateTimeNullableFilter = { equals?: Date | null; in?: (Date | null)[]; notIn?: (Date | null)[]; lt?: Date; lte?: Date; gt?: Date; gte?: Date; not?: Date | DateTimeNullableFilter | null; };
+  export type DateTimeFilter = { equals?: Date | string; in?: (Date | string)[]; notIn?: (Date | string)[]; lt?: Date | string; lte?: Date | string; gt?: Date | string; gte?: Date | string; not?: Date | string | DateTimeFilter; };
+  export type DateTimeNullableFilter = { equals?: Date | string | null; in?: ((Date | string) | null)[]; notIn?: ((Date | string) | null)[]; lt?: Date | string; lte?: Date | string; gt?: Date | string; gte?: Date | string; not?: Date | string | DateTimeNullableFilter | null; };
 }
 
-export interface TableClient<T, WhereInput = any, Select = any, Include = any, CreateInput = any, UpdateInput = any, FindManyArgs = any, FindFirstArgs = any, FindUniqueArgs = any, CreateArgs = any, UpdateArgs = any, UpsertArgs = any, DeleteArgs = any> {
+export interface TableClient<T, WhereInput = any, _Select = any, Include = any, CreateInput = any, UpdateInput = any, FindManyArgs = any, FindFirstArgs = any, FindUniqueArgs = any, CreateArgs = any, UpdateArgs = any, UpsertArgs = any, DeleteArgs = any, AggregateArgs = any, GroupByArgs = any> {
   findMany(args?: FindManyArgs): Promise<T[]>;
   vectorSearch(args: { vector: number[]; take?: number; where?: WhereInput; include?: Include; vectorField?: string; distanceMetric?: 'cosine' | 'euclidean' | 'dot'; }): Promise<(T & { distance: number })[]>;
   findFirst(args?: FindFirstArgs): Promise<T | null>;
@@ -56,8 +52,8 @@ export interface TableClient<T, WhereInput = any, Select = any, Include = any, C
   updateMany(args: { where?: WhereInput; data: UpdateInput; }): Promise<{ count: number }>;
   delete(args: DeleteArgs): Promise<T>;
   deleteMany(args?: { where?: WhereInput; }): Promise<{ count: number }>;
-  aggregate(args: any): Promise<any>;
-  groupBy(args: any): Promise<any[]>;
+  aggregate(args: AggregateArgs): Promise<any>;
+  groupBy(args: GroupByArgs): Promise<any[]>;
   upsert(args: UpsertArgs): Promise<T>;
 }
 `;
@@ -88,7 +84,7 @@ export interface TableClient<T, WhereInput = any, Select = any, Include = any, C
         content += `  NOT?: ${model.name}WhereInput | ${model.name}WhereInput[];\n`;
         for (const field of model.fields) {
             const filter = this.getFieldFilterType(field);
-            content += `  ${field.name}?: ${field.type} | ${filter}${field.isOptional ? ' | null' : ''};\n`;
+            content += `  ${field.name}?: ${this.inputType(field.type)} | ${filter}${field.isOptional ? ' | null' : ''};\n`;
         }
         for (const rel of model.relations) {
             if (rel.isArray) {
@@ -116,16 +112,23 @@ export interface TableClient<T, WhereInput = any, Select = any, Include = any, C
             includeRels.push(`_count?: boolean | { select?: { ${model.relations.map(r => `${r.name}?: boolean`).join('; ')} } }`);
         }
         content += `export type ${model.name}Include = { ${includeRels.join('; ')}${includeRels.length > 0 ? ';' : ''} };\n`;
-        content += `export type ${model.name}CreateInput = { ${model.fields.map(f => `${f.name}${f.isOptional || f.hasDefault ? '?' : ''}: ${f.type}${f.isOptional ? ' | null' : ''}`).join('; ')}; ${model.relations.map(r => `${r.name}?: { create?: ${r.type}CreateInput | ${r.type}CreateInput[]; connect?: ${r.type}WhereInput | ${r.type}WhereInput[]; }`).join('; ')} };\n`;
-        content += `export type ${model.name}UpdateInput = { ${model.fields.filter(f => !f.isId).map(f => `${f.name}?: ${f.type === 'number' ? 'number | An5.IntFieldUpdateOperationsInput' : f.type}${f.isOptional ? ' | null' : ''}`).join('; ')}; ${model.relations.map(r => `${r.name}?: { create?: ${r.type}CreateInput | ${r.type}CreateInput[]; connect?: ${r.type}WhereInput | ${r.type}WhereInput[]; set?: ${r.type}WhereInput | ${r.type}WhereInput[]; disconnect?: ${r.type}WhereInput | ${r.type}WhereInput[]; delete?: ${r.type}WhereInput | ${r.type}WhereInput[]; update?: { where: ${r.type}WhereInput; data: ${r.type}UpdateInput; } | { where: ${r.type}WhereInput; data: ${r.type}UpdateInput; }[]; upsert?: { where: ${r.type}WhereInput; create: ${r.type}CreateInput; update: ${r.type}UpdateInput; } | { where: ${r.type}WhereInput; create: ${r.type}CreateInput; update: ${r.type}UpdateInput; }[]; }`).join('; ')} };\n`;
-        content += `export type ${model.name}FindManyArgs = { where?: ${model.name}WhereInput; orderBy?: any; take?: number; skip?: number; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
-        content += `export type ${model.name}FindFirstArgs = { where?: ${model.name}WhereInput; orderBy?: any; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+        content += `export type ${model.name}CreateInput = { ${model.fields.map(f => `${f.name}${f.isOptional || f.hasDefault ? '?' : ''}: ${this.inputType(f.type)}${f.isOptional ? ' | null' : ''}`).join('; ')}; ${model.relations.map(r => `${r.name}?: { create?: ${r.type}CreateInput | ${r.type}CreateInput[]; connect?: ${r.type}WhereInput | ${r.type}WhereInput[]; }`).join('; ')} };\n`;
+        content += `export type ${model.name}UpdateInput = { ${model.fields.filter(f => !f.isId).map(f => `${f.name}?: ${f.type === 'number' ? 'number | An5.IntFieldUpdateOperationsInput' : this.inputType(f.type)}${f.isOptional ? ' | null' : ''}`).join('; ')}; ${model.relations.map(r => `${r.name}?: { create?: ${r.type}CreateInput | ${r.type}CreateInput[]; connect?: ${r.type}WhereInput | ${r.type}WhereInput[]; set?: ${r.type}WhereInput | ${r.type}WhereInput[]; disconnect?: ${r.type}WhereInput | ${r.type}WhereInput[]; delete?: ${r.type}WhereInput | ${r.type}WhereInput[]; update?: { where: ${r.type}WhereInput; data: ${r.type}UpdateInput; } | { where: ${r.type}WhereInput; data: ${r.type}UpdateInput; }[]; upsert?: { where: ${r.type}WhereInput; create: ${r.type}CreateInput; update: ${r.type}UpdateInput; } | { where: ${r.type}WhereInput; create: ${r.type}CreateInput; update: ${r.type}UpdateInput; }[]; }`).join('; ')} };\n`;
+        content += `export type ${model.name}OrderByInput = { ${model.fields.map(f => `${f.name}?: An5.SortOrder`).join('; ')} };\n`;
+        content += `export type ${model.name}FindManyArgs = { where?: ${model.name}WhereInput; orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[]; take?: number; skip?: number; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
+        content += `export type ${model.name}FindFirstArgs = { where?: ${model.name}WhereInput; orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[]; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
         content += `export type ${model.name}FindUniqueArgs = { where?: ${model.name}WhereInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
         content += `export type ${model.name}CreateArgs = { data: ${model.name}CreateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
         content += `export type ${model.name}UpdateArgs = { where: ${model.name}WhereInput; data: ${model.name}UpdateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
         content += `export type ${model.name}UpsertArgs = { where: ${model.name}WhereInput; create: ${model.name}CreateInput; update: ${model.name}UpdateInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
         content += `export type ${model.name}DeleteArgs = { where: ${model.name}WhereInput; include?: ${model.name}Include; select?: ${model.name}Select; };\n`;
-        content += `export type ${model.name}TableClient = TableClient<\n  ${model.name},\n  ${model.name}WhereInput,\n  ${model.name}Select,\n  ${model.name}Include,\n  ${model.name}CreateInput,\n  ${model.name}UpdateInput,\n  ${model.name}FindManyArgs,\n  ${model.name}FindFirstArgs,\n  ${model.name}FindUniqueArgs,\n  ${model.name}CreateArgs,\n  ${model.name}UpdateArgs,\n  ${model.name}UpsertArgs,\n  ${model.name}DeleteArgs\n>;\n`;
+        content += `export type ${model.name}ScalarFieldEnum = ${model.fields.map(f => `'${f.name}'`).join(' | ') || 'never'};\n`;
+        content += `export type ${model.name}AggregateArgs = { where?: ${model.name}WhereInput; _count?: true | { _all?: true; ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; _sum?: { ${model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: true`).join('; ')} }; _avg?: { ${model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: true`).join('; ')} }; _min?: { ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; _max?: { ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; };\n`;
+        const numericHavingFields = model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: An5.NumberFilter | number`).join('; ');
+        const scalarHavingFields = model.fields.map(f => `${f.name}?: any`).join('; ');
+        content += `export type ${model.name}AggregateHavingInput = { _count?: { _all?: An5.NumberFilter | number; ${model.fields.map(f => `${f.name}?: An5.NumberFilter | number`).join('; ')} }; _sum?: { ${numericHavingFields} }; _avg?: { ${numericHavingFields} }; _min?: { ${scalarHavingFields} }; _max?: { ${scalarHavingFields} }; };\n`;
+        content += `export type ${model.name}GroupByArgs = { by: ${model.name}ScalarFieldEnum | ${model.name}ScalarFieldEnum[]; where?: ${model.name}WhereInput; having?: ${model.name}AggregateHavingInput; orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[]; skip?: number; take?: number; _count?: true | { _all?: true; ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; _sum?: { ${model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: true`).join('; ')} }; _avg?: { ${model.fields.filter(f => this.normalizeType(f.type) === 'number').map(f => `${f.name}?: true`).join('; ')} }; _min?: { ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; _max?: { ${model.fields.map(f => `${f.name}?: true`).join('; ')} }; };\n`;
+        content += `export type ${model.name}TableClient = TableClient<\n  ${model.name},\n  ${model.name}WhereInput,\n  ${model.name}Select,\n  ${model.name}Include,\n  ${model.name}CreateInput,\n  ${model.name}UpdateInput,\n  ${model.name}FindManyArgs,\n  ${model.name}FindFirstArgs,\n  ${model.name}FindUniqueArgs,\n  ${model.name}CreateArgs,\n  ${model.name}UpdateArgs,\n  ${model.name}UpsertArgs,\n  ${model.name}DeleteArgs,\n  ${model.name}AggregateArgs,\n  ${model.name}GroupByArgs\n>;\n`;
         fs_1.default.writeFileSync(path_1.default.join(this.outputDir, `${model.name}.ts`), content);
     }
     generateIndexTs(models) {
@@ -157,9 +160,21 @@ export interface TableClient<T, WhereInput = any, Select = any, Include = any, C
             content += `  export type ${model.name}Include = ${model.name}Types.${model.name}Include;\n`;
             content += `  export type ${model.name}CreateInput = ${model.name}Types.${model.name}CreateInput;\n`;
             content += `  export type ${model.name}UpdateInput = ${model.name}Types.${model.name}UpdateInput;\n`;
+            content += `  export type ${model.name}OrderByInput = ${model.name}Types.${model.name}OrderByInput;\n`;
+            content += `  export type ${model.name}FindManyArgs = ${model.name}Types.${model.name}FindManyArgs;\n`;
+            content += `  export type ${model.name}FindFirstArgs = ${model.name}Types.${model.name}FindFirstArgs;\n`;
+            content += `  export type ${model.name}FindUniqueArgs = ${model.name}Types.${model.name}FindUniqueArgs;\n`;
+            content += `  export type ${model.name}CreateArgs = ${model.name}Types.${model.name}CreateArgs;\n`;
+            content += `  export type ${model.name}UpdateArgs = ${model.name}Types.${model.name}UpdateArgs;\n`;
+            content += `  export type ${model.name}UpsertArgs = ${model.name}Types.${model.name}UpsertArgs;\n`;
+            content += `  export type ${model.name}DeleteArgs = ${model.name}Types.${model.name}DeleteArgs;\n`;
+            content += `  export type ${model.name}TableClient = ${model.name}Types.${model.name}TableClient;\n`;
+            content += `  export type ${model.name}ScalarFieldEnum = ${model.name}Types.${model.name}ScalarFieldEnum;\n`;
+            content += `  export type ${model.name}AggregateArgs = ${model.name}Types.${model.name}AggregateArgs;\n`;
+            content += `  export type ${model.name}GroupByArgs = ${model.name}Types.${model.name}GroupByArgs;\n`;
         }
         content += `}\n`;
-        content += `\nexport class An5Client {\n  $connect(): Promise<void> { return Promise.resolve(); }\n  $disconnect(): Promise<void> { return Promise.resolve(); }\n  $transaction<R>(fn: (tx: An5Client) => Promise<R>, options?: { timeout?: number }): Promise<R>;\n  $transaction<R>(list: Promise<R>[]): Promise<R[]>;\n  $transaction(fn: any, options?: any): Promise<any> { return typeof fn === 'function' ? fn(this) : Promise.all(fn); }\n  $queryRaw<T = any>(queryParts: TemplateStringsArray | string, ...values: any[]): Promise<T> { return Promise.resolve([] as any); }\n  $queryRawUnsafe<R = any>(query: string, ...values: any[]): Promise<R> { return Promise.resolve([] as any); }\n  $executeRaw<T = any>(queryParts: TemplateStringsArray | string, ...values: any[]): Promise<any> { return Promise.resolve(0 as any); }\n  $executeRawUnsafe(query: string, ...values: any[]): Promise<number> { return Promise.resolve(0); }\n`;
+        content += `\nexport class An5Client {\n  $connect(): Promise<void> { return Promise.resolve(); }\n  $disconnect(): Promise<void> { return Promise.resolve(); }\n  $transaction<R>(fn: (tx: An5Client) => Promise<R>, options?: { timeout?: number }): Promise<R>;\n  $transaction<R>(list: Promise<R>[]): Promise<R[]>;\n  $transaction(fn: any, _options?: any): Promise<any> { return typeof fn === 'function' ? fn(this) : Promise.all(fn); }\n  $begin(): Promise<An5Client> { return Promise.resolve(this); }\n  $commit(): Promise<void> { return Promise.resolve(); }\n  $rollback(): Promise<void> { return Promise.resolve(); }\n  $queryRaw<T = any>(_queryParts: TemplateStringsArray | string, ..._values: any[]): Promise<T> { return Promise.resolve([] as any); }\n  $queryRawUnsafe<R = any>(_query: string, ..._values: any[]): Promise<R> { return Promise.resolve([] as any); }\n  $executeRaw<_T = any>(_queryParts: TemplateStringsArray | string, ..._values: any[]): Promise<any> { return Promise.resolve(0 as any); }\n  $executeRawUnsafe(_query: string, ..._values: any[]): Promise<number> { return Promise.resolve(0); }\n`;
         const addedProps = new Set();
         for (const model of models) {
             const props = this.getAllPropertyVariations(model.name);
@@ -175,12 +190,16 @@ export interface TableClient<T, WhereInput = any, Select = any, Include = any, C
     }
     getAllPropertyVariations(modelName) {
         const variations = new Set();
+        variations.add(modelName);
         variations.add(this.toCamelCase(modelName));
+        variations.add(modelName + 's');
+        variations.add(this.toCamelCase(modelName) + 's');
         const acronyms = ['LLM', 'AI', 'MCP', 'IT', 'QC', 'HR', 'MR', 'WH', 'SSIS', 'API', 'URL', 'ID', 'JSON'];
         for (const acronym of acronyms) {
             if (modelName.startsWith(acronym)) {
                 variations.add(acronym.toLowerCase() + modelName.slice(acronym.length));
                 variations.add(acronym[0].toLowerCase() + acronym.slice(1) + modelName.slice(acronym.length));
+                variations.add(acronym.toLowerCase() + modelName.slice(acronym.length) + 's');
             }
         }
         return Array.from(variations);
@@ -197,6 +216,11 @@ export interface TableClient<T, WhereInput = any, Select = any, Include = any, C
             return field.isOptional ? 'An5.DateTimeNullableFilter' : 'An5.DateTimeFilter';
         return 'any';
     }
+    // Input positions (create/update/where scalars) accept ISO strings as well
+    // as Date objects — Prisma parity for DateTime fields.
+    inputType(tsType) {
+        return tsType === 'Date' ? 'Date | string' : tsType;
+    }
     normalizeType(type) {
         const lowerType = type.toLowerCase();
         if (['string', 'varchar', 'nvarchar', 'char', 'nchar', 'text', 'ntext', 'xml', 'guid', 'uuid', 'uniqueidentifier', 'sysname', 'hierarchyid', 'geography', 'geometry', 'sql_variant', 'sqlvariant', 'rowversion', 'variant'].includes(lowerType)) {

package/dist/generator/src/dotnet-generator.d.ts

@@ -3,6 +3,8 @@ export declare class DotnetGenerator {
     private outputDir;
     constructor(outputDir: string);
     generate(models: Model[]): void;
+    private getCsFilterType;
+    private generateOrmTypes;
     private generateConfigClass;
     private mapType;
     private generateEntityClass;

package/dist/generator/src/dotnet-generator.js

@@ -18,11 +18,173 @@ class DotnetGenerator {
         for (const model of models) {
             this.generateEntityClass(model);
         }
-        // 2. Generate DbContext / Client metadata file
+        // 2. Generate per-model ORM types (WhereInput, OrderByInput, FindManyArgs, etc.)
+        this.generateOrmTypes(models);
+        // 3. Generate DbContext / Client metadata file
         this.generateDbContext(models);
-        // 3. Generate configuration helper class
+        // 4. Generate configuration helper class
         this.generateConfigClass();
     }
+    getCsFilterType(fieldType, isOptional) {
+        const lower = fieldType.toLowerCase();
+        if (['datetime', 'datetime2', 'smalldatetime', 'date', 'datetimeoffset'].includes(lower))
+            return 'DateTimeFilter';
+        if (['bool', 'boolean', 'bit'].includes(lower))
+            return 'BoolFilter';
+        if (['int', 'integer', 'smallint', 'tinyint', 'number'].includes(lower))
+            return 'IntFilter';
+        if (['bigint', 'long', 'float', 'real', 'double', 'decimal', 'numeric', 'money', 'smallmoney'].includes(lower))
+            return 'NumberFilter';
+        return 'StringFilter';
+    }
+    generateOrmTypes(models) {
+        let content = `// This file is auto-generated. Do not edit directly.
+using System;
+using System.Collections.Generic;
+
+namespace An5Orm
+{
+    // ── Base Filter Types ──────────────────────────────────────────────────────
+
+    /// <summary>Type-safe filter for string fields.</summary>
+    public class StringFilter
+    {
+        public new string Equals { get; set; }
+        public string Not { get; set; }
+        public List<string> In { get; set; }
+        public List<string> NotIn { get; set; }
+        public string Contains { get; set; }
+        public string StartsWith { get; set; }
+        public string EndsWith { get; set; }
+        public string Gt { get; set; }
+        public string Gte { get; set; }
+        public string Lt { get; set; }
+        public string Lte { get; set; }
+    }
+
+    /// <summary>Type-safe filter for integer fields.</summary>
+    public class IntFilter
+    {
+        public new int? Equals { get; set; }
+        public int? Not { get; set; }
+        public List<int> In { get; set; }
+        public List<int> NotIn { get; set; }
+        public int? Gt { get; set; }
+        public int? Gte { get; set; }
+        public int? Lt { get; set; }
+        public int? Lte { get; set; }
+    }
+
+    /// <summary>Type-safe filter for numeric/float fields.</summary>
+    public class NumberFilter
+    {
+        public new double? Equals { get; set; }
+        public double? Not { get; set; }
+        public List<double> In { get; set; }
+        public List<double> NotIn { get; set; }
+        public double? Gt { get; set; }
+        public double? Gte { get; set; }
+        public double? Lt { get; set; }
+        public double? Lte { get; set; }
+    }
+
+    /// <summary>Type-safe filter for boolean fields.</summary>
+    public class BoolFilter
+    {
+        public new bool? Equals { get; set; }
+    }
+
+    /// <summary>Type-safe filter for DateTime fields.</summary>
+    public class DateTimeFilter
+    {
+        public new DateTime? Equals { get; set; }
+        public DateTime? Not { get; set; }
+        public List<DateTime> In { get; set; }
+        public List<DateTime> NotIn { get; set; }
+        public DateTime? Gt { get; set; }
+        public DateTime? Gte { get; set; }
+        public DateTime? Lt { get; set; }
+        public DateTime? Lte { get; set; }
+    }
+
+`;
+        for (const model of models) {
+            const name = this.capitalize(model.name);
+            const csType = (f) => this.mapType(f.type, f.isOptional);
+            content += `    // ── ${name} ORM Types ──────────────────────────────────────────────────────\n\n`;
+            // WhereInput
+            content += `    /// <summary>Type-safe WHERE filter for ${name} queries.</summary>\n`;
+            content += `    public class ${name}WhereInput\n    {\n`;
+            content += `        public List<${name}WhereInput> AND { get; set; }\n`;
+            content += `        public List<${name}WhereInput> OR { get; set; }\n`;
+            content += `        public ${name}WhereInput NOT { get; set; }\n`;
+            for (const f of model.fields) {
+                const ft = this.getCsFilterType(f.type, f.isOptional);
+                content += `        public ${ft} ${this.capitalize(f.name)} { get; set; }\n`;
+            }
+            content += `    }\n\n`;
+            // OrderByInput
+            content += `    /// <summary>Type-safe ORDER BY for ${name} queries.</summary>\n`;
+            content += `    public class ${name}OrderByInput\n    {\n`;
+            for (const f of model.fields) {
+                content += `        public string ${this.capitalize(f.name)} { get; set; } // "asc" or "desc"\n`;
+            }
+            content += `    }\n\n`;
+            // CreateInput
+            content += `    /// <summary>Typed data for creating a new ${name} record.</summary>\n`;
+            content += `    public class ${name}CreateInput\n    {\n`;
+            for (const f of model.fields) {
+                if (!f.isId) {
+                    const ct = this.mapType(f.type, f.isOptional || f.hasDefault);
+                    content += `        public ${ct} ${this.capitalize(f.name)} { get; set; }\n`;
+                }
+            }
+            content += `    }\n\n`;
+            // UpdateInput
+            content += `    /// <summary>Typed data for updating an existing ${name} record.</summary>\n`;
+            content += `    public class ${name}UpdateInput\n    {\n`;
+            for (const f of model.fields) {
+                if (!f.isId) {
+                    const ut = this.mapType(f.type, true); // always nullable for update
+                    content += `        public ${ut} ${this.capitalize(f.name)} { get; set; }\n`;
+                }
+            }
+            content += `    }\n\n`;
+            // FindManyArgs
+            content += `    /// <summary>ORM-style args for ${name}.FindMany().</summary>\n`;
+            content += `    public class ${name}FindManyArgs\n    {\n`;
+            content += `        public ${name}WhereInput Where { get; set; }\n`;
+            content += `        public ${name}OrderByInput OrderBy { get; set; }\n`;
+            content += `        public int? Take { get; set; }\n`;
+            content += `        public int? Skip { get; set; }\n`;
+            content += `        public List<string> Select { get; set; }\n`;
+            content += `    }\n\n`;
+            // FindFirstArgs
+            content += `    /// <summary>ORM-style args for ${name}.FindFirst().</summary>\n`;
+            content += `    public class ${name}FindFirstArgs\n    {\n`;
+            content += `        public ${name}WhereInput Where { get; set; }\n`;
+            content += `        public ${name}OrderByInput OrderBy { get; set; }\n`;
+            content += `        public List<string> Select { get; set; }\n`;
+            content += `    }\n\n`;
+            // FindUniqueArgs
+            content += `    /// <summary>ORM-style args for ${name}.FindUnique().</summary>\n`;
+            content += `    public class ${name}FindUniqueArgs\n    {\n`;
+            content += `        public ${name}WhereInput Where { get; set; }\n`;
+            content += `    }\n\n`;
+            // DeleteManyArgs
+            content += `    /// <summary>ORM-style args for ${name}.DeleteMany().</summary>\n`;
+            content += `    public class ${name}DeleteManyArgs\n    {\n`;
+            content += `        public ${name}WhereInput Where { get; set; }\n`;
+            content += `    }\n\n`;
+            // CountArgs
+            content += `    /// <summary>ORM-style args for ${name}.Count().</summary>\n`;
+            content += `    public class ${name}CountArgs\n    {\n`;
+            content += `        public ${name}WhereInput Where { get; set; }\n`;
+            content += `    }\n\n`;
+        }
+        content += `}\n`;
+        fs_1.default.writeFileSync(path_1.default.join(this.outputDir, 'An5OrmTypes.cs'), content);
+    }
     generateConfigClass() {
         const content = `// This file is auto-generated. Do not edit directly.
 using System;
@@ -119,6 +281,7 @@ using System;
 using System.Collections.Generic;
 using System.Data;
 using System.Reflection;
+using System.Text.Json;
 using Microsoft.Data.SqlClient;
 using An5Orm.Entities;
 
@@ -169,7 +332,9 @@ namespace An5Orm
         // ── Tables / Repositories ──────────────────────────────────────────────
 `;
         for (const model of models) {
-            content += `        public TableClient<${model.name}> ${this.capitalize(model.name)}s => new TableClient<${model.name}>(ConnectionString, "${model.schemaName}.${model.tableName}");\n`;
+            const name = this.capitalize(model.name);
+            content += `        public TableClient<${model.name}> ${name}s => new TableClient<${model.name}>(ConnectionString, "${model.schemaName}.${model.tableName}");\n`;
+            content += `        public TableClient<${model.name}> ${name} => ${name}s;\n`;
         }
         content += `    }
 
@@ -233,6 +398,51 @@ namespace An5Orm
             return cmd;
         }
 
+        public List<T> QueryRaw(string query, Dictionary<string, object> parameters = null)
+        {
+            var list = new List<T>();
+            var conn = An5DbContext.GetActiveConnection(ConnectionString, out bool isTx);
+            try
+            {
+                using (var cmd = CreateCommand(conn, query))
+                {
+                    if (parameters != null)
+                    {
+                        foreach (var kvp in parameters)
+                        {
+                            cmd.Parameters.AddWithValue(kvp.Key.StartsWith("@") ? kvp.Key : "@" + kvp.Key, kvp.Value ?? DBNull.Value);
+                        }
+                    }
+
+                    using (var reader = cmd.ExecuteReader())
+                    {
+                        var properties = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
+                        while (reader.Read())
+                        {
+                            var item = new T();
+                            foreach (var prop in properties)
+                            {
+                                if (HasColumn(reader, prop.Name))
+                                {
+                                    var val = reader[prop.Name];
+                                    if (val != DBNull.Value)
+                                    {
+                                        prop.SetValue(item, val);
+                                    }
+                                }
+                            }
+                            list.Add(item);
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                if (!isTx) conn.Dispose();
+            }
+            return list;
+        }
+
         public List<T> FindMany(string whereClause = null, Dictionary<string, object> parameters = null)
         {
             var list = new List<T>();
@@ -441,15 +651,132 @@ namespace An5Orm
             }
         }
 
+        public int Count(string whereClause = null, Dictionary<string, object> parameters = null)
+        {
+            string query = $"SELECT COUNT(*) FROM {TableName}";
+            if (!string.IsNullOrEmpty(whereClause)) query += $" WHERE {whereClause}";
+            var conn = An5DbContext.GetActiveConnection(ConnectionString, out bool isTx);
+            try
+            {
+                using (var cmd = CreateCommand(conn, query))
+                {
+                    if (parameters != null)
+                    {
+                        foreach (var kvp in parameters)
+                            cmd.Parameters.AddWithValue(kvp.Key.StartsWith("@") ? kvp.Key : "@" + kvp.Key, kvp.Value ?? DBNull.Value);
+                    }
+                    var res = cmd.ExecuteScalar();
+                    return res != null && res != DBNull.Value ? Convert.ToInt32(res) : 0;
+                }
+            }
+            finally { if (!isTx) conn.Dispose(); }
+        }
+
+        public int CreateMany(IEnumerable<T> entities)
+        {
+            int count = 0;
+            foreach (var entity in entities)
+            {
+                Create(entity);
+                count++;
+            }
+            return count;
+        }
+
+        public int UpdateMany(string whereClause, Dictionary<string, object> updateData, Dictionary<string, object> parameters = null)
+        {
+            if (updateData == null || updateData.Count == 0) return 0;
+            var sets = new List<string>();
+            var sqlParams = new List<SqlParameter>();
+            int pIndex = 0;
+            foreach (var kvp in updateData)
+            {
+                string paramName = "@u_" + pIndex++;
+                sets.Add($"{kvp.Key} = {paramName}");
+                sqlParams.Add(new SqlParameter(paramName, kvp.Value ?? DBNull.Value));
+            }
+            string query = $"UPDATE {TableName} SET {string.Join(", ", sets)}";
+            if (!string.IsNullOrEmpty(whereClause)) query += $" WHERE {whereClause}";
+            var conn = An5DbContext.GetActiveConnection(ConnectionString, out bool isTx);
+            try
+            {
+                using (var cmd = CreateCommand(conn, query))
+                {
+                    cmd.Parameters.AddRange(sqlParams.ToArray());
+                    if (parameters != null)
+                    {
+                        foreach (var kvp in parameters)
+                            cmd.Parameters.AddWithValue(kvp.Key.StartsWith("@") ? kvp.Key : "@" + kvp.Key, kvp.Value ?? DBNull.Value);
+                    }
+                    return cmd.ExecuteNonQuery();
+                }
+            }
+            finally { if (!isTx) conn.Dispose(); }
+        }
+
+        public int DeleteMany(string whereClause = null, Dictionary<string, object> parameters = null)
+        {
+            string query = $"DELETE FROM {TableName}";
+            if (!string.IsNullOrEmpty(whereClause)) query += $" WHERE {whereClause}";
+            var conn = An5DbContext.GetActiveConnection(ConnectionString, out bool isTx);
+            try
+            {
+                using (var cmd = CreateCommand(conn, query))
+                {
+                    if (parameters != null)
+                    {
+                        foreach (var kvp in parameters)
+                            cmd.Parameters.AddWithValue(kvp.Key.StartsWith("@") ? kvp.Key : "@" + kvp.Key, kvp.Value ?? DBNull.Value);
+                    }
+                    return cmd.ExecuteNonQuery();
+                }
+            }
+            finally { if (!isTx) conn.Dispose(); }
+        }
+
+        public T Upsert(T entity, string idColumnName = "Id")
+        {
+            var prop = typeof(T).GetProperty(idColumnName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
+            if (prop == null) throw new InvalidOperationException($"Property '{idColumnName}' not found on entity.");
+            var idVal = prop.GetValue(entity);
+            var existing = idVal != null ? FindUnique(idVal) : default;
+            if (existing != null) return Update(entity);
+            return Create(entity);
+        }
+
         public List<T> VectorSearch(List<double> vector, int take = 10, string whereClause = null, Dictionary<string, object> parameters = null, string vectorField = "Embedding", string distanceMetric = "cosine")
         {
+            // 1. Primary path: Native database SQL vector query execution (VECTOR_DISTANCE)
+            try
+            {
+                var dim = vector.Count;
+                var vecJson = JsonSerializer.Serialize(vector);
+                var sql = $"SELECT TOP ({take}) *, VECTOR_DISTANCE('{distanceMetric}', CAST([{vectorField}] AS VECTOR({dim}, float32)), CAST(@query_vector AS VECTOR({dim}, float32))) AS distance FROM {TableName} WITH (NOLOCK)";
+
+                var p = parameters != null ? new Dictionary<string, object>(parameters) : new Dictionary<string, object>();
+                p["query_vector"] = vecJson;
+
+                if (!string.IsNullOrWhiteSpace(whereClause))
+                    sql += $" WHERE [{vectorField}] IS NOT NULL AND ({whereClause})";
+                else
+                    sql += $" WHERE [{vectorField}] IS NOT NULL";
+                sql += " ORDER BY distance ASC";
+
+                var nativeRows = QueryRaw(sql, p);
+                if (nativeRows != null) return nativeRows;
+            }
+            catch
+            {
+                // Fallback to in-memory similarity computation if DB instance lacks native VECTOR_DISTANCE
+            }
+
+            // 2. Secondary fallback: In-memory similarity computation
             var rows = FindMany(whereClause, parameters);
             var results = new List<Tuple<T, double>>();
 
             var propInfo = typeof(T).GetProperty(vectorField, BindingFlags.Public | BindingFlags.Instance);
             if (propInfo == null)
             {
-                // Fallback case-insensitive
                 propInfo = typeof(T).GetProperty(vectorField, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
             }
             if (propInfo == null) return rows;
@@ -479,12 +806,11 @@ namespace An5Orm
             }
 
             results.Sort((a, b) => a.Item2.CompareTo(b.Item2));
-            
+
             var output = new List<T>();
             int limit = Math.Min(take, results.Count);
             for (int i = 0; i < limit; i++)
             {
-                // Set the distance property if the model has a public property named Distance
                 var distanceProp = typeof(T).GetProperty("Distance", BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
                 if (distanceProp != null && distanceProp.PropertyType == typeof(double))
                 {