adorn-api 1.0.42 → 1.0.43

package/README.md

@@ -309,9 +309,9 @@ export const {
 ```
 
 ### 3. Create a CRUD Controller
-
-```typescript
-// user.controller.ts
+
+```typescript
+// user.controller.ts
 import {
   Controller,
   Get,
@@ -375,10 +375,115 @@ export class UserController {
     }
   }
 
-  // Other CRUD operations...
+  // Other CRUD operations...
+}
+```
+
+### Deep Relation Filters
+
+`parseFilter` now accepts nested relation paths, so you can filter deep chains like Alpha → Bravo → Charlie → Delta.
+
+```typescript
+// alpha.entity.ts
+import { BelongsTo, Column, Entity, HasMany, PrimaryKey, col } from "metal-orm";
+import type { BelongsToReference, HasManyCollection } from "metal-orm";
+
+@Entity({ tableName: "alphas" })
+export class Alpha {
+  @PrimaryKey(col.autoIncrement(col.int()))
+  id!: number;
+
+  @Column(col.notNull(col.text()))
+  name!: string;
+
+  @HasMany({ target: () => Bravo, foreignKey: "alphaId" })
+  bravos!: HasManyCollection<Bravo>;
+}
+
+@Entity({ tableName: "bravos" })
+export class Bravo {
+  @PrimaryKey(col.autoIncrement(col.int()))
+  id!: number;
+
+  @Column(col.notNull(col.text()))
+  code!: string;
+
+  @Column(col.notNull(col.int()))
+  alphaId!: number;
+
+  @BelongsTo({ target: () => Alpha, foreignKey: "alphaId" })
+  alpha!: BelongsToReference<Alpha>;
+
+  @HasMany({ target: () => Charlie, foreignKey: "bravoId" })
+  charlies!: HasManyCollection<Charlie>;
+}
+
+@Entity({ tableName: "charlies" })
+export class Charlie {
+  @PrimaryKey(col.autoIncrement(col.int()))
+  id!: number;
+
+  @Column(col.notNull(col.int()))
+  score!: number;
+
+  @Column(col.notNull(col.int()))
+  bravoId!: number;
+
+  @Column(col.int())
+  deltaId?: number | null;
+
+  @BelongsTo({ target: () => Bravo, foreignKey: "bravoId" })
+  bravo!: BelongsToReference<Bravo>;
+
+  @BelongsTo({ target: () => Delta, foreignKey: "deltaId" })
+  delta?: BelongsToReference<Delta>;
+}
+
+@Entity({ tableName: "deltas" })
+export class Delta {
+  @PrimaryKey(col.autoIncrement(col.int()))
+  id!: number;
+
+  @Column(col.notNull(col.text()))
+  name!: string;
 }
 ```
 
+```typescript
+// alpha.controller.ts (filtering)
+import { parseFilter } from "adorn-api";
+import { applyFilter, selectFromEntity, type WhereInput } from "metal-orm";
+import { Alpha } from "./alpha.entity";
+
+const ALPHA_FILTERS = {
+  deltaNameContains: {
+    field: "bravos.some.charlies.some.delta.name",
+    operator: "contains"
+  },
+  deltaIsMissing: {
+    field: "bravos.some.charlies.some.delta",
+    operator: "isEmpty"
+  },
+  charlieScoreGte: {
+    field: "bravos.some.charlies.some.score",
+    operator: "gte"
+  }
+};
+
+const filters = parseFilter(
+  (ctx.query ?? {}) as Record<string, unknown>,
+  ALPHA_FILTERS
+);
+
+const query = applyFilter(
+  selectFromEntity(Alpha),
+  Alpha,
+  filters as WhereInput<typeof Alpha>
+);
+```
+
+Example query string: `?deltaNameContains=core&charlieScoreGte=90`
+
 ### Tree DTOs (Nested Set / MPTT)
 
 Metal ORM's tree helpers map cleanly into Adorn. Use `createMetalTreeDtoClasses` to generate DTOs for tree nodes,
@@ -769,6 +874,7 @@ Check out the `examples/` directory for more comprehensive examples:
 - `restful/` - RESTful API with complete CRUD operations
 - `metal-orm-sqlite/` - Metal ORM integration with SQLite
 - `metal-orm-tree/` - Metal ORM tree (nested set) DTO + OpenAPI integration
+- `metal-orm-deep-filters/` - Deep relation filtering example (Alpha → Bravo → Charlie → Delta)
 - `metal-orm-sqlite-music/` - Complex relations with Metal ORM
 - `streaming/` - SSE and streaming responses
 - `openapi/` - OpenAPI documentation customization

package/dist/adapter/metal-orm/filters.d.ts

@@ -1,25 +1,20 @@
-import type { Filter } from "./types";
+import type { Filter, FilterMapping, FilterOperator, ParseFilterOptions } from "./types";
 /**
  * Parses filter parameters from query parameters.
  * @param query - Query parameters
  * @param mappings - Filter field mappings
  * @returns Parsed filter or undefined
  */
-export declare function parseFilter<T, K extends keyof T>(query: Record<string, unknown> | undefined, mappings: Record<string, {
-    field: K;
-    operator: "equals" | "contains" | "startsWith" | "endsWith" | "gt" | "gte" | "lt" | "lte";
-}>): Filter<T, K> | undefined;
+export declare function parseFilter<T, K extends keyof T>(query: Record<string, unknown> | undefined, mappings: Record<string, FilterMapping>): Filter<T, K> | undefined;
+export declare function parseFilter<T, K extends keyof T>(options: ParseFilterOptions): Filter<T, K> | undefined;
 /**
  * Creates filter mappings for an entity.
  * @param entity - Entity type
  * @param fields - Array of field definitions
  * @returns Filter mappings
  */
-export declare function createFilterMappings<T extends Record<string, unknown>>(entity: T, fields: Array<{
+export declare function createFilterMappings<T extends Record<string, unknown>>(_entity: T, fields: Array<{
     queryKey: string;
-    field: keyof T;
-    operator?: "equals" | "contains" | "startsWith" | "endsWith";
-}>): Record<string, {
-    field: keyof T;
-    operator: "equals" | "contains" | "startsWith" | "endsWith";
-}>;
+    field: (keyof T & string) | string[];
+    operator?: FilterOperator;
+}>): Record<string, FilterMapping>;

package/dist/adapter/metal-orm/filters.js

@@ -2,29 +2,34 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFilter = parseFilter;
 exports.createFilterMappings = createFilterMappings;
-/**
- * Parses filter parameters from query parameters.
- * @param query - Query parameters
- * @param mappings - Filter field mappings
- * @returns Parsed filter or undefined
- */
-function parseFilter(query, mappings) {
-    if (!query) {
+function parseFilter(queryOrOptions, mappings) {
+    const options = mappings ? undefined : queryOrOptions;
+    const query = mappings
+        ? queryOrOptions
+        : options?.query;
+    const fieldMappings = mappings ?? options?.fieldMappings;
+    if (!query || !fieldMappings) {
         return undefined;
     }
     const filter = {};
-    for (const [queryKey, value] of Object.entries(query)) {
-        const mapping = mappings[queryKey];
-        if (!mapping || value === undefined || value === null || value === "") {
+    let hasValues = false;
+    for (const [queryKey, mapping] of Object.entries(fieldMappings)) {
+        if (!mapping) {
+            continue;
+        }
+        const value = getQueryValue(query, queryKey);
+        if (isSkippableValue(value)) {
             continue;
         }
-        const { field, operator } = mapping;
-        if (!filter[field]) {
-            filter[field] = {};
+        const operator = mapping.operator ?? "equals";
+        const fieldPath = normalizePath(mapping.field);
+        if (!fieldPath.length) {
+            continue;
         }
-        filter[field][operator] = value;
+        setFilterValue(filter, fieldPath, operator, value);
+        hasValues = true;
     }
-    return Object.keys(filter).length ? filter : undefined;
+    return hasValues ? filter : undefined;
 }
 /**
  * Creates filter mappings for an entity.
@@ -32,10 +37,95 @@ function parseFilter(query, mappings) {
  * @param fields - Array of field definitions
  * @returns Filter mappings
  */
-function createFilterMappings(entity, fields) {
+function createFilterMappings(_entity, fields) {
     const mappings = {};
     for (const { queryKey, field, operator = "equals" } of fields) {
         mappings[queryKey] = { field, operator };
     }
     return mappings;
 }
+const RELATION_OPERATORS = new Set(["isEmpty", "isNotEmpty"]);
+function normalizePath(path) {
+    if (Array.isArray(path)) {
+        return path.map(String).filter((segment) => segment.length > 0);
+    }
+    return splitPath(path);
+}
+function splitPath(path) {
+    if (!path) {
+        return [];
+    }
+    const normalized = path.replace(/\[(.*?)\]/g, ".$1");
+    return normalized
+        .split(".")
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0);
+}
+function getQueryValue(query, queryKey) {
+    if (queryKey in query) {
+        return query[queryKey];
+    }
+    const path = splitPath(queryKey);
+    if (!path.length) {
+        return undefined;
+    }
+    return getValueAtPath(query, path);
+}
+function getValueAtPath(value, path) {
+    let current = value;
+    for (const segment of path) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (Array.isArray(current)) {
+            const index = Number(segment);
+            if (!Number.isInteger(index)) {
+                return undefined;
+            }
+            current = current[index];
+            continue;
+        }
+        if (typeof current !== "object") {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function isSkippableValue(value) {
+    if (value === undefined || value === null || value === "") {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.length === 0;
+    }
+    return false;
+}
+function setFilterValue(filter, fieldPath, operator, value) {
+    if (!fieldPath.length) {
+        return;
+    }
+    let cursor = filter;
+    if (RELATION_OPERATORS.has(operator)) {
+        for (const segment of fieldPath) {
+            cursor = ensureObject(cursor, segment);
+        }
+        cursor[operator] = value;
+        return;
+    }
+    for (let index = 0; index < fieldPath.length - 1; index += 1) {
+        cursor = ensureObject(cursor, fieldPath[index]);
+    }
+    const fieldKey = fieldPath[fieldPath.length - 1];
+    const fieldTarget = ensureObject(cursor, fieldKey);
+    fieldTarget[operator] = value;
+}
+function ensureObject(container, key) {
+    const existing = container[key];
+    if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+        return existing;
+    }
+    const next = {};
+    container[key] = next;
+    return next;
+}

package/dist/adapter/metal-orm/index.d.ts

@@ -3,8 +3,9 @@ export { parsePagination } from "./pagination";
 export { parseFilter, createFilterMappings } from "./filters";
 export { createPagedQueryDtoClass, createPagedResponseDtoClass, createPagedFilterQueryDtoClass } from "./paged-dtos";
 export { createMetalCrudDtos, createMetalCrudDtoClasses, createNestedCreateDtoClass } from "./crud-dtos";
+export { createMetalTreeDtoClasses } from "./tree-dtos";
 export { createMetalDtoOverrides, type CreateMetalDtoOverridesOptions } from "./convention-overrides";
 export { createErrorDtoClass, StandardErrorDto, SimpleErrorDto, BasicErrorDto } from "./error-dtos";
 export { withSession, parseIdOrThrow, compactUpdates, applyInput, getEntityOrThrow } from "./utils";
 export { validateEntityMetadata, hasValidEntityMetadata } from "./field-builder";
-export type { MetalDtoMode, MetalDtoOptions, MetalDtoTarget, PaginationConfig, PaginationOptions, ParsedPagination, Filter, FilterMapping, FilterFieldMapping, ParseFilterOptions, PagedQueryDtoOptions, PagedResponseDtoOptions, PagedFilterQueryDtoOptions, FilterFieldDef, MetalCrudDtoOptions, MetalCrudDtoClassOptions, MetalCrudDtoDecorators, MetalCrudDtoClasses, MetalCrudDtoClassNames, NestedCreateDtoOptions, ErrorDtoOptions, CreateSessionFn } from "./types";
+export type { MetalDtoMode, MetalDtoOptions, MetalDtoTarget, PaginationConfig, PaginationOptions, ParsedPagination, Filter, FilterMapping, FilterFieldMapping, ParseFilterOptions, PagedQueryDtoOptions, PagedResponseDtoOptions, PagedFilterQueryDtoOptions, FilterFieldDef, MetalCrudDtoOptions, MetalCrudDtoClassOptions, MetalCrudDtoDecorators, MetalCrudDtoClasses, MetalCrudDtoClassNames, NestedCreateDtoOptions, MetalTreeDtoClassOptions, MetalTreeDtoClasses, MetalTreeDtoClassNames, MetalTreeListEntryOptions, ErrorDtoOptions, CreateSessionFn } from "./types";

package/dist/adapter/metal-orm/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasValidEntityMetadata = exports.validateEntityMetadata = exports.getEntityOrThrow = exports.applyInput = exports.compactUpdates = exports.parseIdOrThrow = exports.withSession = exports.BasicErrorDto = exports.SimpleErrorDto = exports.StandardErrorDto = exports.createErrorDtoClass = exports.createMetalDtoOverrides = exports.createNestedCreateDtoClass = exports.createMetalCrudDtoClasses = exports.createMetalCrudDtos = exports.createPagedFilterQueryDtoClass = exports.createPagedResponseDtoClass = exports.createPagedQueryDtoClass = exports.createFilterMappings = exports.parseFilter = exports.parsePagination = exports.MetalDto = void 0;
+exports.hasValidEntityMetadata = exports.validateEntityMetadata = exports.getEntityOrThrow = exports.applyInput = exports.compactUpdates = exports.parseIdOrThrow = exports.withSession = exports.BasicErrorDto = exports.SimpleErrorDto = exports.StandardErrorDto = exports.createErrorDtoClass = exports.createMetalDtoOverrides = exports.createMetalTreeDtoClasses = exports.createNestedCreateDtoClass = exports.createMetalCrudDtoClasses = exports.createMetalCrudDtos = exports.createPagedFilterQueryDtoClass = exports.createPagedResponseDtoClass = exports.createPagedQueryDtoClass = exports.createFilterMappings = exports.parseFilter = exports.parsePagination = exports.MetalDto = void 0;
 // Ensure standard decorator metadata is available for metal-orm transformers.
 const symbolMetadata = Symbol.metadata;
 if (!symbolMetadata) {
@@ -21,6 +21,8 @@ var crud_dtos_1 = require("./crud-dtos");
 Object.defineProperty(exports, "createMetalCrudDtos", { enumerable: true, get: function () { return crud_dtos_1.createMetalCrudDtos; } });
 Object.defineProperty(exports, "createMetalCrudDtoClasses", { enumerable: true, get: function () { return crud_dtos_1.createMetalCrudDtoClasses; } });
 Object.defineProperty(exports, "createNestedCreateDtoClass", { enumerable: true, get: function () { return crud_dtos_1.createNestedCreateDtoClass; } });
+var tree_dtos_1 = require("./tree-dtos");
+Object.defineProperty(exports, "createMetalTreeDtoClasses", { enumerable: true, get: function () { return tree_dtos_1.createMetalTreeDtoClasses; } });
 var convention_overrides_1 = require("./convention-overrides");
 Object.defineProperty(exports, "createMetalDtoOverrides", { enumerable: true, get: function () { return convention_overrides_1.createMetalDtoOverrides; } });
 var error_dtos_1 = require("./error-dtos");

package/dist/adapter/metal-orm/tree-dtos.d.ts

@@ -0,0 +1,2 @@
+import type { MetalTreeDtoClassOptions, MetalTreeDtoClasses } from "./types";
+export declare function createMetalTreeDtoClasses(target: any, options?: MetalTreeDtoClassOptions): MetalTreeDtoClasses;

package/dist/adapter/metal-orm/tree-dtos.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMetalTreeDtoClasses = createMetalTreeDtoClasses;
+const metal_orm_1 = require("metal-orm");
+const schema_1 = require("../../core/schema");
+const metadata_1 = require("../../core/metadata");
+const dto_1 = require("./dto");
+const field_builder_1 = require("./field-builder");
+function createMetalTreeDtoClasses(target, options = {}) {
+    const baseName = options.baseName ?? getTargetName(target);
+    const names = resolveNames(baseName, options.names);
+    const includeTreeMetadata = options.includeTreeMetadata ?? true;
+    const entityDto = options.entityDto ?? createEntityDtoClass(target, {
+        ...(options.entity ?? {}),
+        name: names.entity
+    });
+    const nodeDto = createTreeNodeDtoClass(entityDto, {
+        name: names.node,
+        includeTreeMetadata
+    });
+    const parentKey = resolveParentKey(target, options.parentKey);
+    const parentSchema = resolveParentSchema(target, parentKey, options.entity?.overrides, options.entity?.strict);
+    const nodeResultDto = createTreeNodeResultDtoClass(entityDto, {
+        name: names.nodeResult,
+        includeTreeMetadata,
+        parentSchema
+    });
+    const threadedNodeDto = createThreadedNodeDtoClass(entityDto, {
+        name: names.threadedNode
+    });
+    const keySchema = options.treeListEntry?.keySchema
+        ?? resolvePrimaryKeySchema(target, options.entity?.overrides, options.entity?.strict)
+        ?? schema_1.t.integer();
+    const valueSchema = options.treeListEntry?.valueSchema ?? schema_1.t.string();
+    const treeListEntryDto = createTreeListEntryDtoClass({
+        name: names.treeListEntry,
+        keySchema,
+        valueSchema
+    });
+    const treeListSchema = schema_1.t.array(schema_1.t.ref(treeListEntryDto), {
+        description: `Flat list of ${baseName} tree entries for dropdown/select`
+    });
+    const threadedTreeSchema = schema_1.t.array(schema_1.t.ref(threadedNodeDto), {
+        description: `Threaded tree structure of ${baseName} nodes`
+    });
+    return {
+        entity: entityDto,
+        node: nodeDto,
+        nodeResult: nodeResultDto,
+        threadedNode: threadedNodeDto,
+        treeListEntry: treeListEntryDto,
+        treeListSchema,
+        threadedTreeSchema
+    };
+}
+function createEntityDtoClass(target, options) {
+    const DtoClass = class {
+    };
+    Object.defineProperty(DtoClass, "name", { value: options.name, configurable: true });
+    (0, dto_1.MetalDto)(target, options)(DtoClass);
+    return DtoClass;
+}
+function createTreeNodeDtoClass(entityDto, options) {
+    const TreeNodeDto = class {
+    };
+    Object.defineProperty(TreeNodeDto, "name", { value: options.name, configurable: true });
+    const fields = {
+        entity: { schema: schema_1.t.ref(entityDto) },
+        lft: { schema: schema_1.t.integer(), description: "Left boundary value (nested set)" },
+        rght: { schema: schema_1.t.integer(), description: "Right boundary value (nested set)" },
+        isLeaf: { schema: schema_1.t.boolean(), description: "Whether this node has no children" },
+        isRoot: { schema: schema_1.t.boolean(), description: "Whether this node has no parent" },
+        childCount: { schema: schema_1.t.integer({ minimum: 0 }), description: "Number of descendants" }
+    };
+    if (options.includeTreeMetadata) {
+        fields.depth = {
+            schema: schema_1.t.integer({ minimum: 0 }),
+            optional: true,
+            description: "Depth level (0 = root)"
+        };
+    }
+    (0, metadata_1.registerDto)(TreeNodeDto, {
+        name: options.name,
+        description: "A tree node with nested set boundaries and metadata",
+        fields
+    });
+    return TreeNodeDto;
+}
+function createTreeNodeResultDtoClass(entityDto, options) {
+    const TreeNodeResultDto = class {
+    };
+    Object.defineProperty(TreeNodeResultDto, "name", { value: options.name, configurable: true });
+    const fields = {
+        data: { schema: schema_1.t.ref(entityDto) },
+        lft: { schema: schema_1.t.integer(), description: "Left boundary value (nested set)" },
+        rght: { schema: schema_1.t.integer(), description: "Right boundary value (nested set)" },
+        parentId: { schema: options.parentSchema, description: "Parent identifier (null for roots)" },
+        isLeaf: { schema: schema_1.t.boolean(), description: "Whether this node has no children" },
+        isRoot: { schema: schema_1.t.boolean(), description: "Whether this node has no parent" }
+    };
+    if (options.includeTreeMetadata) {
+        fields.depth = {
+            schema: schema_1.t.integer({ minimum: 0 }),
+            optional: true,
+            description: "Depth level (0 = root)"
+        };
+    }
+    (0, metadata_1.registerDto)(TreeNodeResultDto, {
+        name: options.name,
+        description: "A tree node result with nested set boundaries and metadata",
+        fields
+    });
+    return TreeNodeResultDto;
+}
+function createThreadedNodeDtoClass(entityDto, options) {
+    const ThreadedNodeDto = class {
+    };
+    Object.defineProperty(ThreadedNodeDto, "name", { value: options.name, configurable: true });
+    (0, metadata_1.registerDto)(ThreadedNodeDto, {
+        name: options.name,
+        description: "A node in a threaded tree structure with nested children",
+        fields: {
+            node: { schema: schema_1.t.ref(entityDto) },
+            children: {
+                schema: schema_1.t.array(schema_1.t.ref(ThreadedNodeDto)),
+                description: "Child nodes in the tree hierarchy"
+            }
+        }
+    });
+    return ThreadedNodeDto;
+}
+function createTreeListEntryDtoClass(options) {
+    const TreeListEntryDto = class {
+    };
+    Object.defineProperty(TreeListEntryDto, "name", { value: options.name, configurable: true });
+    (0, metadata_1.registerDto)(TreeListEntryDto, {
+        name: options.name,
+        description: "A tree list entry for dropdown/select rendering",
+        fields: {
+            key: { schema: options.keySchema, description: "The key (usually primary key)" },
+            value: { schema: options.valueSchema, description: "The display value with depth prefix" },
+            depth: { schema: schema_1.t.integer({ minimum: 0 }), description: "The depth level" }
+        }
+    });
+    return TreeListEntryDto;
+}
+function resolveParentKey(target, parentKey) {
+    if (parentKey) {
+        return parentKey;
+    }
+    if (typeof target === "function") {
+        const config = (0, metal_orm_1.getTreeConfig)(target);
+        if (config?.parentKey) {
+            return config.parentKey;
+        }
+    }
+    return "parentId";
+}
+function resolveParentSchema(target, parentKey, overrides, strict) {
+    const fields = (0, field_builder_1.buildFields)(target, {
+        include: [parentKey],
+        overrides,
+        strict
+    });
+    return fields[parentKey]?.schema ?? schema_1.t.nullable(schema_1.t.string());
+}
+function resolvePrimaryKeySchema(target, overrides, strict) {
+    const columns = (0, metal_orm_1.getColumnMap)(target);
+    const primaryKey = Object.keys(columns).find((key) => columns[key]?.primary);
+    if (!primaryKey) {
+        return undefined;
+    }
+    const fields = (0, field_builder_1.buildFields)(target, {
+        include: [primaryKey],
+        overrides,
+        strict
+    });
+    return fields[primaryKey]?.schema;
+}
+function resolveNames(baseName, names) {
+    return {
+        entity: names?.entity ?? `${baseName}Dto`,
+        node: names?.node ?? `${baseName}NodeDto`,
+        nodeResult: names?.nodeResult ?? `${baseName}NodeResultDto`,
+        threadedNode: names?.threadedNode ?? `${baseName}ThreadedNodeDto`,
+        treeListEntry: names?.treeListEntry ?? `${baseName}TreeListEntryDto`
+    };
+}
+function getTargetName(target) {
+    if (typeof target === "function" && target.name) {
+        return target.name;
+    }
+    return "Entity";
+}

package/dist/adapter/metal-orm/types.d.ts

@@ -66,9 +66,9 @@ export interface FilterFieldMapping {
  */
 export interface FilterMapping {
     /** Field name */
-    field: string;
+    field: string | string[];
     /** Filter operator */
-    operator: "equals" | "contains" | "startsWith" | "endsWith" | "gt" | "gte" | "lt" | "lte";
+    operator: FilterOperator;
 }
 /**
  * Options for parsing filters.
@@ -79,12 +79,19 @@ export interface ParseFilterOptions {
     /** Field mappings */
     fieldMappings?: Record<string, FilterMapping>;
 }
+/**
+ * Filter operator.
+ */
+export type FilterOperator = "equals" | "not" | "in" | "notIn" | "contains" | "startsWith" | "endsWith" | "gt" | "gte" | "lt" | "lte" | "isEmpty" | "isNotEmpty";
 /**
  * Filter type for querying.
  */
 export type Filter<T, K extends keyof T> = {
     [P in K]?: {
         equals?: T[P];
+        not?: T[P];
+        in?: Array<T[P]>;
+        notIn?: Array<T[P]>;
         contains?: T[P];
         startsWith?: T[P];
         endsWith?: T[P];
@@ -92,6 +99,7 @@ export type Filter<T, K extends keyof T> = {
         gte?: T[P];
         lt?: T[P];
         lte?: T[P];
+        mode?: "default" | "insensitive";
     };
 };
 /**
@@ -206,6 +214,68 @@ export interface MetalCrudDtoClasses {
     /** Params DTO class */
     params: DtoConstructor;
 }
+/**
+ * Metal Tree DTO class names.
+ */
+export interface MetalTreeDtoClassNames {
+    /** Entity DTO class name */
+    entity?: string;
+    /** Tree node DTO class name */
+    node?: string;
+    /** Tree node result DTO class name */
+    nodeResult?: string;
+    /** Threaded tree node DTO class name */
+    threadedNode?: string;
+    /** Tree list entry DTO class name */
+    treeListEntry?: string;
+}
+/**
+ * Options for tree list entry DTOs.
+ */
+export interface MetalTreeListEntryOptions {
+    /** Schema for list entry key */
+    keySchema?: SchemaNode;
+    /** Schema for list entry value */
+    valueSchema?: SchemaNode;
+}
+/**
+ * Options for Metal Tree DTO classes.
+ */
+export interface MetalTreeDtoClassOptions {
+    /** Base name for DTO classes */
+    baseName?: string;
+    /** Custom class names */
+    names?: MetalTreeDtoClassNames;
+    /** Reuse an existing entity DTO class */
+    entityDto?: DtoConstructor;
+    /** Options for generated entity DTO when entityDto is not provided */
+    entity?: MetalDtoOptions;
+    /** Whether to include depth metadata (default: true) */
+    includeTreeMetadata?: boolean;
+    /** Override the parent key column name */
+    parentKey?: string;
+    /** Tree list entry options */
+    treeListEntry?: MetalTreeListEntryOptions;
+}
+/**
+ * Metal Tree DTO classes.
+ */
+export interface MetalTreeDtoClasses {
+    /** Entity DTO class */
+    entity: DtoConstructor;
+    /** Tree node DTO class */
+    node: DtoConstructor;
+    /** Tree node result DTO class */
+    nodeResult: DtoConstructor;
+    /** Threaded tree node DTO class */
+    threadedNode: DtoConstructor;
+    /** Tree list entry DTO class */
+    treeListEntry: DtoConstructor;
+    /** Tree list schema */
+    treeListSchema: SchemaNode;
+    /** Threaded tree schema */
+    threadedTreeSchema: SchemaNode;
+}
 /**
  * Options for nested create DTOs.
  * @extends MetalDtoOptions