@nestjs-odata/core 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,1402 @@
+import * as _$_nestjs_common0 from "@nestjs/common";
+import { ArgumentMetadata, ArgumentsHost, CallHandler, ConfigurableModuleAsyncOptions, DynamicModule, ExceptionFilter, ExecutionContext, NestInterceptor, PipeTransform } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+import { Observable } from "rxjs";
+
+//#region src/batch/batch-types.d.ts
+/**
+ * OData v4 $batch type definitions.
+ *
+ * Per OData v4 Part 1 section 11, a batch request contains multiple
+ * operations in a multipart/mixed body. Operations can be:
+ *   - Individual requests: GET, DELETE, or data modification operations
+ *   - Changesets: groups of data modification operations that must succeed or fail atomically
+ *
+ * These types form the contract between batch-parser.ts and batch-controller.ts.
+ */
+/**
+ * Represents a single parsed sub-request from a batch body.
+ * Produced by parseBatchBody() for individual requests and changeset sub-parts.
+ */
+interface BatchRequestPart {
+  readonly kind: 'request';
+  /** Content-ID header value for referencing the result within a changeset */
+  readonly contentId?: string;
+  /** HTTP method: GET, POST, PATCH, PUT, DELETE */
+  readonly method: string;
+  /** The URL from the embedded HTTP request line */
+  readonly url: string;
+  /** Parsed headers from the embedded HTTP request */
+  readonly headers: Readonly<Record<string, string>>;
+  /** Raw body string for POST/PATCH/PUT requests, undefined for GET/DELETE */
+  readonly body?: string;
+}
+/**
+ * Represents a changeset — a group of data modification operations
+ * that must be executed atomically (all succeed or all roll back).
+ *
+ * Per OData v4 Part 1 section 11.7: changesets cannot contain GET requests.
+ */
+interface BatchChangesetPart {
+  readonly kind: 'changeset';
+  /** The individual sub-requests within this changeset */
+  readonly parts: readonly BatchRequestPart[];
+}
+/**
+ * A part in a batch body — either an individual request or a changeset.
+ */
+type BatchPart = BatchRequestPart | BatchChangesetPart;
+/**
+ * The fully parsed result of a multipart/mixed batch body.
+ */
+interface ParsedBatch {
+  readonly boundary: string;
+  readonly parts: readonly BatchPart[];
+}
+/**
+ * Represents the HTTP response for a single operation within a batch response.
+ */
+interface BatchResponsePart {
+  /** Content-ID from the corresponding request part, if any */
+  readonly contentId?: string;
+  /** HTTP status code for this operation */
+  readonly statusCode: number;
+  /** Response headers for this operation */
+  readonly headers: Readonly<Record<string, string>>;
+  /** Serialized response body, if any */
+  readonly body?: string;
+}
+/**
+ * The complete batch response, ready to be serialized to multipart/mixed.
+ */
+interface BatchResponse {
+  readonly boundary: string;
+  readonly parts: readonly BatchResponsePart[];
+}
+//#endregion
+//#region src/batch/batch-parser.d.ts
+/**
+ * Maximum number of operations allowed in a single batch request (T-05-02).
+ * Prevents unbounded transaction size and DoS via large batches.
+ */
+declare const MAX_BATCH_OPERATIONS = 100;
+/**
+ * Extract the boundary value from a Content-Type header.
+ *
+ * Handles both quoted (boundary="abc") and unquoted (boundary=abc) formats.
+ * Throws ODataValidationError if the boundary parameter is missing.
+ *
+ * @param contentType - The Content-Type header value (e.g., 'multipart/mixed; boundary=batch_abc123')
+ * @returns The boundary string value
+ * @throws ODataValidationError if boundary parameter is missing
+ */
+declare function extractBoundary(contentType: string): string;
+/**
+ * Parse a multipart/mixed batch body into structured BatchPart objects.
+ *
+ * Handles:
+ *   - Individual request parts (kind: 'request')
+ *   - Changesets (kind: 'changeset') containing sub-request parts
+ *   - Both CRLF (\r\n) and LF (\n) line endings
+ *   - Content-ID headers for changeset sub-parts
+ *   - Embedded HTTP request parsing (METHOD URL HTTP/1.1, headers, body)
+ *
+ * Per T-05-02: rejects batches exceeding MAX_BATCH_OPERATIONS operations.
+ *
+ * @param body - The raw request body string
+ * @param boundary - The multipart boundary (from extractBoundary())
+ * @returns ParsedBatch with all parsed parts
+ * @throws ODataValidationError if body is malformed or exceeds limits
+ */
+declare function parseBatchBody(body: string, boundary: string): ParsedBatch;
+//#endregion
+//#region src/parser/ast.d.ts
+/**
+ * OData v4 AST (Abstract Syntax Tree) node types.
+ * All nodes use discriminated unions with a `kind` field as the discriminant.
+ *
+ * Per OData v4 Part 2 Section 5.1.1 — URL Conventions: $filter expressions.
+ */
+/** Binary operator union — all OData v4 binary operators */
+type BinaryOperator = 'eq' | 'ne' | 'lt' | 'le' | 'gt' | 'ge' | 'has' | 'in' | 'and' | 'or' | 'add' | 'sub' | 'mul' | 'div' | 'divby' | 'mod';
+/** Unary operator union */
+type UnaryOperator = 'not' | 'neg';
+/** Lambda operator — collection traversal */
+type LambdaOperator = 'any' | 'all';
+/** Literal kind discriminant */
+type LiteralKind = 'string' | 'number' | 'boolean' | 'null' | 'guid' | 'dateTimeOffset';
+/** Binary expression: left op right (e.g., Price gt 5) */
+interface BinaryExprNode {
+  readonly kind: 'BinaryExpr';
+  readonly operator: BinaryOperator;
+  readonly left: FilterNode;
+  readonly right: FilterNode;
+}
+/** Unary expression: op operand (e.g., not Active) */
+interface UnaryExprNode {
+  readonly kind: 'UnaryExpr';
+  readonly operator: UnaryOperator;
+  readonly operand: FilterNode;
+}
+/** Function call: name(args...) (e.g., contains(Name,'widget')) */
+interface FunctionCallNode {
+  readonly kind: 'FunctionCall';
+  readonly name: string;
+  readonly args: FilterNode[];
+}
+/** Property access: path segments (e.g., Category/Name) */
+interface PropertyAccessNode {
+  readonly kind: 'PropertyAccess';
+  readonly path: string[];
+}
+/** Literal value: string, number, boolean, null, guid, dateTimeOffset */
+interface LiteralNode {
+  readonly kind: 'Literal';
+  readonly literalKind: LiteralKind;
+  readonly value: string | number | boolean | null;
+}
+/**
+ * Lambda expression: collection/lambda(variable:predicate)
+ * e.g., Tags/any(t:t/Name eq 'electronics')
+ * When predicate is null, represents Tags/any() (no predicate variant).
+ */
+interface LambdaExprNode {
+  readonly kind: 'LambdaExpr';
+  readonly operator: LambdaOperator;
+  /** Collection property path (e.g., 'Tags') */
+  readonly collection: string;
+  /** Lambda variable (e.g., 't'), null for zero-arg any() */
+  readonly variable: string | null;
+  /** Lambda predicate expression, null for zero-arg any() */
+  readonly predicate: FilterNode | null;
+}
+/**
+ * Union of all filter expression AST node types.
+ * Use the `kind` discriminant for type narrowing.
+ */
+type FilterNode = BinaryExprNode | UnaryExprNode | FunctionCallNode | PropertyAccessNode | LiteralNode | LambdaExprNode;
+/** Sort direction */
+type OrderByDirection = 'asc' | 'desc';
+/** Single $orderby clause item */
+interface OrderByItem {
+  readonly expression: FilterNode;
+  readonly direction: OrderByDirection;
+}
+/** Parsed $orderby value */
+interface OrderByNode {
+  readonly items: OrderByItem[];
+}
+/** Single $select path item (e.g., Name or Category/Name) */
+interface SelectItem {
+  readonly path: string[];
+}
+/** Parsed $select value */
+interface SelectNode {
+  /** Individual property paths — present when not SelectAll */
+  readonly items?: SelectItem[];
+  /** True when $select=* */
+  readonly all?: boolean;
+}
+/** Single $expand item — one navigation property with optional nested query options */
+interface ExpandItem {
+  readonly navigationProperty: string;
+  readonly filter?: FilterNode;
+  readonly select?: SelectNode;
+  readonly orderBy?: OrderByItem[];
+  readonly top?: number;
+  readonly skip?: number;
+  readonly expand?: ExpandNode;
+}
+/** Parsed $expand value — list of expand items */
+interface ExpandNode {
+  readonly items: readonly ExpandItem[];
+}
+/**
+ * Aggregate of parsed OData query option values.
+ * Each field is optional — only present when the query string contains it.
+ */
+interface QueryOptions {
+  readonly filter?: FilterNode;
+  readonly orderBy?: OrderByItem[];
+  readonly select?: SelectNode;
+  readonly top?: number;
+  readonly skip?: number;
+  readonly expand?: ExpandNode;
+}
+/** A single search term, optionally negated. Quoted phrases are stored as a single value. */
+interface SearchTermNode {
+  readonly kind: 'SearchTerm';
+  readonly value: string;
+  readonly negated?: boolean;
+}
+/** Binary search expression combining two search nodes with AND or OR. */
+interface SearchBinaryNode {
+  readonly kind: 'SearchBinary';
+  readonly operator: 'AND' | 'OR';
+  readonly left: SearchNode;
+  readonly right: SearchNode;
+}
+/** Union of all $search expression node types. */
+type SearchNode = SearchTermNode | SearchBinaryNode;
+/**
+ * A single aggregate method expression: `property with method as alias`
+ * or `$count as alias` (property='$count', method='count').
+ */
+interface AggregateExpression {
+  readonly property: string;
+  readonly method: 'sum' | 'count' | 'avg' | 'min' | 'max' | 'countdistinct';
+  readonly alias: string;
+}
+/** filter() transformation step — applies a filter expression to the current set. */
+interface ApplyFilterStep {
+  readonly kind: 'ApplyFilter';
+  readonly filter: FilterNode;
+}
+/**
+ * groupby() transformation step — partitions by property list with optional
+ * aggregate expressions inside.
+ */
+interface ApplyGroupByStep {
+  readonly kind: 'ApplyGroupBy';
+  readonly properties: string[];
+  readonly aggregate?: readonly AggregateExpression[];
+}
+/** aggregate() transformation step — computes aggregate values across the set. */
+interface ApplyAggregateStep {
+  readonly kind: 'ApplyAggregate';
+  readonly expressions: readonly AggregateExpression[];
+}
+/** Union of all $apply transformation step types. */
+type ApplyStep = ApplyFilterStep | ApplyGroupByStep | ApplyAggregateStep;
+/** Root $apply node — an ordered pipeline of transformation steps. */
+interface ApplyNode {
+  readonly steps: readonly ApplyStep[];
+}
+//#endregion
+//#region src/parser/visitor.d.ts
+/**
+ * Generic visitor interface for FilterNode AST traversal.
+ * Implement this interface to transform or analyze OData filter expressions.
+ *
+ * @template T - The return type of each visit method
+ */
+interface FilterVisitor<T> {
+  visitBinaryExpr(node: BinaryExprNode): T;
+  visitUnaryExpr(node: UnaryExprNode): T;
+  visitFunctionCall(node: FunctionCallNode): T;
+  visitLambdaExpr(node: LambdaExprNode): T;
+  visitPropertyAccess(node: PropertyAccessNode): T;
+  visitLiteral(node: LiteralNode): T;
+}
+/**
+ * Dispatch a FilterNode to the appropriate visitor method.
+ * Convenience function to avoid writing switch statements in every visitor.
+ */
+declare function acceptVisitor<T>(node: FilterNode, visitor: FilterVisitor<T>): T;
+//#endregion
+//#region src/parser/errors.d.ts
+/**
+ * OData parser error types.
+ * ODataParseError carries position information for diagnostic messages.
+ */
+/**
+ * Thrown when the lexer or parser encounters malformed OData query syntax.
+ *
+ * The `position` field indicates the character offset in the input string
+ * where the error was detected. The `token` field (if available) holds
+ * the token that triggered the error.
+ *
+ * Note: position info is intentionally included — the input is the user's own
+ * query string, not server-internal data, so there is no information disclosure risk.
+ */
+declare class ODataParseError extends Error {
+  readonly position: number;
+  readonly token: unknown;
+  readonly queryContext?: string | undefined;
+  constructor(message: string, position: number, token?: unknown, queryContext?: string | undefined);
+  /**
+   * Create an ODataParseError with a context snippet extracted from the query string.
+   * Extracts ~20 characters before and after the error position for diagnostic context.
+   *
+   * Per threat model T-12-05: context snippet shows only the user's own query input
+   * (already known to them) — never includes stack traces or internal paths.
+   *
+   * @param message - Base error message
+   * @param position - Character offset where the error was detected
+   * @param queryString - The full query string for context extraction
+   * @param token - Optional token that triggered the error
+   */
+  static withContext(message: string, position: number, queryString: string, token?: unknown): ODataParseError;
+}
+//#endregion
+//#region src/parser/lexer.d.ts
+/**
+ * OData v4 Lexer (tokenizer).
+ * Converts an OData query expression string into a token stream.
+ *
+ * Character-by-character scanning with keyword disambiguation.
+ * OData keyword recognition per Part 2 Section 5.1.1 ABNF grammar.
+ */
+/** All token kinds produced by the OData lexer */
+declare enum TokenKind {
+  STRING_LITERAL = "STRING_LITERAL",
+  INT_LITERAL = "INT_LITERAL",
+  DECIMAL_LITERAL = "DECIMAL_LITERAL",
+  BOOL_LITERAL = "BOOL_LITERAL",
+  NULL_LITERAL = "NULL_LITERAL",
+  GUID_LITERAL = "GUID_LITERAL",
+  DATETIME_LITERAL = "DATETIME_LITERAL",
+  IDENTIFIER = "IDENTIFIER",
+  OPEN_PAREN = "OPEN_PAREN",
+  CLOSE_PAREN = "CLOSE_PAREN",
+  COMMA = "COMMA",
+  SLASH = "SLASH",
+  COLON = "COLON",
+  STAR = "STAR",
+  AND = "AND",
+  OR = "OR",
+  NOT = "NOT",
+  EQ = "EQ",
+  NE = "NE",
+  LT = "LT",
+  LE = "LE",
+  GT = "GT",
+  GE = "GE",
+  HAS = "HAS",
+  IN = "IN",
+  ADD = "ADD",
+  SUB = "SUB",
+  MUL = "MUL",
+  DIV = "DIV",
+  DIVBY = "DIVBY",
+  MOD = "MOD",
+  EOF = "EOF"
+}
+/** A single lexer token with kind, value, and source position */
+interface Token {
+  readonly kind: TokenKind;
+  readonly value: string | number | boolean | null;
+  readonly position: number;
+}
+/**
+ * Tokenize an OData query expression string into a token array.
+ * The last token is always EOF.
+ *
+ * @param input - Raw OData expression string (e.g., "Price gt 5 and Active eq true")
+ * @returns Array of tokens ending with EOF
+ * @throws ODataParseError on unrecognized characters
+ */
+declare function tokenize(input: string): Token[];
+//#endregion
+//#region src/parser/parser.d.ts
+/**
+ * Parse a standalone OData $filter expression string into a FilterNode AST.
+ *
+ * @param input - Raw filter expression (e.g., "Price gt 5 and Active eq true")
+ * @returns Root FilterNode of the parsed expression
+ * @throws ODataParseError on syntax errors
+ */
+declare function parseFilter(input: string): FilterNode;
+/**
+ * Parse an OData query string into a QueryOptions object.
+ * Handles $filter, $orderby, $select, $top, $skip.
+ * Unknown query options are silently ignored.
+ *
+ * @param queryString - Raw query string, with or without leading '?'
+ * @returns Parsed QueryOptions (fields are optional — only present when found in query)
+ * @throws ODataParseError on syntax errors
+ */
+declare function parseQuery(queryString: string): QueryOptions;
+//#endregion
+//#region src/parser/search-parser.d.ts
+/**
+ * Parse an OData $search query string into a SearchNode AST.
+ *
+ * @param input - The raw $search query string value (without the $search= prefix)
+ * @throws ODataParseError if the input is empty, malformed, or exceeds MAX_SEARCH_DEPTH
+ */
+declare function parseSearch(input: string): SearchNode;
+//#endregion
+//#region src/parser/apply-parser.d.ts
+/**
+ * Parse an OData $apply transformation pipeline into an ApplyNode AST.
+ *
+ * Steps are separated by '/' at depth 0. Each step is one of:
+ *   - filter(...)
+ *   - aggregate(...)
+ *   - groupby((...),aggregate(...))
+ *
+ * @param input - The raw $apply query string value (without the $apply= prefix)
+ * @throws ODataParseError for empty input, unrecognized steps, invalid aliases,
+ *         or post-groupby filter steps (HAVING not supported)
+ */
+declare function parseApply(input: string): ApplyNode;
+//#endregion
+//#region src/edm/edm-types.d.ts
+/**
+ * OData v4 EDM (Entity Data Model) primitive type system.
+ * All 15 OData v4 primitive types per the OASIS OData v4 specification.
+ * Note: Edm.DateTime is NOT included — use Edm.DateTimeOffset per OData v4.
+ */
+/** All 15 OData v4 EDM primitive types */
+type EdmPrimitiveType = 'Edm.Binary' | 'Edm.Boolean' | 'Edm.Byte' | 'Edm.Date' | 'Edm.DateTimeOffset' | 'Edm.Decimal' | 'Edm.Double' | 'Edm.Guid' | 'Edm.Int16' | 'Edm.Int32' | 'Edm.Int64' | 'Edm.SByte' | 'Edm.Single' | 'Edm.String' | 'Edm.TimeOfDay';
+/** A structural property of an EDM entity type */
+interface EdmProperty {
+  readonly name: string;
+  readonly type: EdmPrimitiveType;
+  readonly nullable: boolean;
+  readonly precision?: number;
+  readonly scale?: number;
+  readonly maxLength?: number;
+}
+/** A navigation property linking two EDM entity types */
+interface EdmNavigationProperty {
+  readonly name: string;
+  readonly type: string;
+  readonly nullable: boolean;
+  readonly isCollection: boolean;
+  readonly partner?: string;
+}
+/** Strategy when a TypeScript type cannot be mapped to an EDM primitive type */
+type UnmappedTypeStrategy = 'skip' | 'string-fallback' | 'error';
+//#endregion
+//#region src/edm/edm-entity-type.d.ts
+/**
+ * Represents an OData v4 EntityType in the Entity Data Model.
+ * Immutable — always create new instances rather than mutating existing ones.
+ */
+interface EdmEntityType {
+  readonly name: string;
+  readonly namespace: string;
+  readonly properties: readonly EdmProperty[];
+  readonly navigationProperties: readonly EdmNavigationProperty[];
+  readonly keyProperties: readonly string[];
+  readonly isReadOnly: boolean;
+}
+//#endregion
+//#region src/edm/edm-entity-set.d.ts
+/**
+ * Represents an OData v4 EntitySet in the Entity Data Model.
+ * An EntitySet is a named collection of entities of a given type.
+ */
+interface EdmEntitySet {
+  readonly name: string;
+  readonly entityTypeName: string;
+  readonly namespace: string;
+  readonly isReadOnly: boolean;
+}
+/**
+ * Full entity configuration combining type and set metadata.
+ * Used by IEdmDeriver to pass complete entity information to the registry.
+ */
+interface EdmEntityConfig {
+  readonly entityTypeName: string;
+  readonly entitySetName: string;
+  readonly properties: readonly EdmProperty[];
+  readonly navigationProperties: readonly EdmNavigationProperty[];
+  readonly keyProperties: readonly string[];
+  readonly isReadOnly: boolean;
+}
+/**
+ * Virtual view — a projection of an existing entity type exposing only
+ * a subset of properties as its own EntitySet. Per design decisions D-22, D-23.
+ */
+interface EdmVirtualView {
+  readonly name: string;
+  readonly sourceEntityTypeName: string;
+  readonly exposedProperties: readonly string[];
+  readonly entitySetName: string;
+}
+//#endregion
+//#region src/query/odata-query.types.d.ts
+/**
+ * Per-entity security option overrides.
+ * When set via EdmRegistry, these take precedence over global ODataModuleOptions values.
+ *
+ * Per D-07: allows individual entity sets to have tighter (or looser) limits than the
+ * global defaults without modifying the global config.
+ */
+interface ODataEntitySecurityOptions {
+  readonly maxTop?: number;
+  readonly maxExpandDepth?: number;
+  readonly maxFilterDepth?: number;
+}
+/**
+ * Typed OData query object produced by ODataQueryPipe.
+ * All optional fields are only present when the corresponding query option
+ * was supplied in the request.
+ *
+ * Per D-14: entitySetName is required for context URL and validation.
+ */
+interface ODataQuery {
+  readonly filter?: FilterNode;
+  readonly select?: SelectNode;
+  readonly orderBy?: OrderByItem[];
+  readonly top?: number;
+  readonly skip?: number;
+  /** True when $count=true was present in the query string */
+  readonly count?: boolean;
+  /** Name of the entity set — required for context URL construction and field validation */
+  readonly entitySetName: string;
+  /** Parsed $expand value — navigation properties to expand */
+  readonly expand?: ExpandNode;
+  /** Parsed $search value — full-text search expression */
+  readonly search?: SearchNode;
+  /** Parsed $apply value — aggregation/transformation pipeline */
+  readonly apply?: ApplyNode;
+}
+/**
+ * Result of executing a translated OData query.
+ * Used by IQueryTranslator.execute() to return structured data to the controller.
+ *
+ * select is included so the controller can build the correct @odata.context URL.
+ */
+interface ODataQueryResult<T = unknown> {
+  readonly items: T[];
+  readonly count?: number;
+  readonly nextLink?: string;
+  readonly select?: SelectNode;
+  /** True when the result was produced by a $apply aggregation pipeline */
+  readonly isAggregated?: boolean;
+  /** Property names present in aggregation output (for context URL construction) */
+  readonly applyProperties?: string[];
+}
+//#endregion
+//#region src/edm/edm-registry.d.ts
+/**
+ * EdmRegistry — NestJS injectable singleton that stores all registered
+ * OData entity types and entity sets.
+ *
+ * Per threat model T-02-01: throws on duplicate registration to prevent
+ * silent override of entity types (Tampering mitigation).
+ */
+declare class EdmRegistry {
+  private readonly entityTypes;
+  private readonly entitySets;
+  /** Per-entity security option overrides keyed by entitySetName (per D-07) */
+  private readonly entitySecurityOptions;
+  /**
+   * Register an entity type and its corresponding entity set.
+   *
+   * Idempotent: if the same entity type name is already registered (e.g. from multiple
+   * ODataTypeOrmModule.forFeature() calls in different feature modules), the registration
+   * is silently skipped. This supports the common pattern of importing forFeature() in
+   * both a root AppModule and a feature module for the same entity.
+   *
+   * Throws only if a DIFFERENT entity type is registered under the same name (name collision).
+   */
+  register(entityType: EdmEntityType, entitySet: EdmEntitySet): void;
+  /** Retrieve a registered entity type by name. Returns undefined if not found. */
+  getEntityType(name: string): EdmEntityType | undefined;
+  /** Retrieve a registered entity set by name. Returns undefined if not found. */
+  getEntitySet(name: string): EdmEntitySet | undefined;
+  /** All registered entity types as a read-only map. */
+  getEntityTypes(): ReadonlyMap<string, EdmEntityType>;
+  /** All registered entity sets as a read-only map. */
+  getEntitySets(): ReadonlyMap<string, EdmEntitySet>;
+  /**
+   * Store per-entity security option overrides for a given entity set name.
+   * These override global ODataModuleResolvedOptions values (per D-07).
+   */
+  setEntitySecurityOptions(entitySetName: string, options: ODataEntitySecurityOptions): void;
+  /**
+   * Retrieve per-entity security options for a given entity set name.
+   * Returns undefined if no overrides have been set.
+   */
+  getEntitySecurityOptions(entitySetName: string): ODataEntitySecurityOptions | undefined;
+}
+//#endregion
+//#region src/edm/pluralize.d.ts
+/**
+ * Pluralize an entity class name to produce an EntitySet name.
+ * Uses the `pluralize` library which handles irregular forms (Person → People,
+ * Category → Categories, Index → Indices, etc.).
+ *
+ * @param name - Entity class name in PascalCase (e.g., 'Product', 'OrderItem')
+ * @returns Pluralized entity set name (e.g., 'Products', 'OrderItems')
+ */
+declare function pluralizeEntityName(name: string): string;
+//#endregion
+//#region src/interfaces/edm-deriver.interface.d.ts
+/** A generic constructor type representing an entity class */
+type EntityClass = new (...args: unknown[]) => unknown;
+/**
+ * IEdmDeriver — adapter seam interface for ORM-specific EDM derivation.
+ * Implementations live in adapter packages (e.g., @nestjs-odata/typeorm).
+ * Core has zero ORM dependencies — adapters inject their implementation
+ * via the EDM_DERIVER token.
+ */
+interface IEdmDeriver {
+  deriveEntityTypes(entityClasses: EntityClass[]): EdmEntityConfig[];
+}
+/** NestJS injection token for IEdmDeriver */
+declare const EDM_DERIVER: unique symbol;
+//#endregion
+//#region src/interfaces/query-translator.interface.d.ts
+/**
+ * IQueryTranslator — adapter seam interface for ORM-specific query translation.
+ *
+ * Implementations live in adapter packages (e.g., @nestjs-odata/typeorm).
+ * The two-method design (translate + execute) separates AST-to-query translation
+ * from query execution, enabling independent unit testing of each step.
+ *
+ * Generic parameter TQuery is the ORM-specific query type (e.g., TypeORM SelectQueryBuilder).
+ */
+interface IQueryTranslator<TQuery = unknown> {
+  /** Translate a typed OData query AST into an ORM-specific query object */
+  translate(query: ODataQuery, entityType: EdmEntityType): TQuery;
+  /** Execute the translated query and return structured results */
+  execute(translatedQuery: TQuery, includeCount: boolean): Promise<ODataQueryResult>;
+}
+/** NestJS injection token for IQueryTranslator */
+declare const QUERY_TRANSLATOR: unique symbol;
+//#endregion
+//#region src/interfaces/etag.interface.d.ts
+/**
+ * Injection token for IETagProvider.
+ * Use this token when registering or injecting the ETag provider via NestJS DI.
+ */
+declare const ETAG_PROVIDER: unique symbol;
+/**
+ * Interface for computing and validating ETags for OData entities.
+ *
+ * Implementations are adapter-specific (e.g., TypeOrmETagProvider).
+ * Core uses this interface without importing any ORM code.
+ */
+interface IETagProvider {
+  /**
+   * Get the ETag column name for an entity set.
+   * Returns undefined if the entity set is not ETag-enabled
+   * (no @UpdateDateColumn or @ODataETag decorator found).
+   */
+  getETagColumn(entitySetName: string): string | undefined;
+  /**
+   * Compute a weak ETag string from an entity's ETag column value.
+   * Format: W/"<value>"
+   */
+  computeETag(entity: Record<string, unknown>, etagColumn: string): string;
+  /**
+   * Validate an If-Match header value against the current entity state.
+   * Returns true if the ETag matches (proceed with mutation),
+   * false if the ETag is stale (return 412).
+   */
+  validateIfMatch(ifMatchValue: string, entity: Record<string, unknown>, etagColumn: string): boolean;
+}
+//#endregion
+//#region src/interfaces/search.interface.d.ts
+/**
+ * Injection token for ISearchProvider.
+ * Use this token when registering or injecting the search provider via NestJS DI.
+ */
+declare const SEARCH_PROVIDER: unique symbol;
+/**
+ * Interface for translating a parsed $search expression into a SQL condition.
+ *
+ * Implementations are adapter-specific (e.g., TypeOrmSearchProvider).
+ * Core uses this interface without importing any ORM code.
+ *
+ * Returns null if the search cannot be applied (e.g., no searchable fields defined).
+ */
+interface ISearchProvider {
+  /**
+   * Build a SQL WHERE condition fragment from a parsed $search expression.
+   *
+   * @param searchNode - The parsed $search AST node
+   * @param entitySetName - The entity set being queried
+   * @param alias - The query builder alias for the entity table
+   * @returns An object with the SQL condition string and named parameters,
+   *          or null if search cannot be applied
+   */
+  buildSearchCondition(searchNode: SearchNode, entitySetName: string, alias: string): {
+    condition: string;
+    params: Record<string, unknown>;
+  } | null;
+}
+//#endregion
+//#region src/query/odata-validation.error.d.ts
+/**
+ * OData validation error types.
+ * ODataValidationError is distinct from ODataParseError — it represents
+ * semantic validation failures (unknown properties, type mismatches) rather
+ * than syntax errors.
+ *
+ * Per threat model T-03-02: includes property name and entity type name
+ * (user's own query input) but never stack traces or internal paths.
+ */
+/**
+ * Thrown when field name validation fails against the EdmRegistry.
+ *
+ * The `entityTypeName` and `propertyName` fields provide diagnostic context
+ * for the user's own query (not internal server data).
+ */
+declare class ODataValidationError extends Error {
+  readonly entityTypeName: string;
+  readonly propertyName: string;
+  readonly availableProperties?: readonly string[] | undefined;
+  constructor(message: string, entityTypeName: string, propertyName: string, availableProperties?: readonly string[] | undefined);
+}
+//#endregion
+//#region src/tokens.d.ts
+/**
+ * DI injection token for the array of EdmEntityConfig objects
+ * registered via ODataModule.forFeature().
+ */
+declare const EDM_ENTITY_CONFIGS: unique symbol;
+/**
+ * DI injection token for the fully-resolved ODataModuleOptions (with defaults applied).
+ * Defined here (not in odata.module.ts) to avoid circular imports with metadata builders.
+ */
+declare const ODATA_MODULE_OPTIONS: unique symbol;
+//#endregion
+//#region src/odata.module.d.ts
+/**
+ * Configuration options for ODataModule.forRoot().
+ *
+ * Per threat model T-02-03: serviceRoot must be a non-empty string.
+ * Per threat model T-02-04: maxTop and maxExpandDepth have safe defaults.
+ */
+interface ODataModuleOptions {
+  /** Base path for the OData service, e.g. '/odata' */
+  serviceRoot: string;
+  /** EDM namespace for all entity types. Default: 'Default' (per D-08) */
+  namespace?: string;
+  /** Maximum number of entities returned per query. Default: 1000 */
+  maxTop?: number;
+  /** Maximum depth of $expand nesting. Default: 2 */
+  maxExpandDepth?: number;
+  /** Maximum nesting depth of $filter expressions. Default: 10 (per SEC-04) */
+  maxFilterDepth?: number;
+  /** Strategy when a TypeScript type cannot be mapped to an EDM primitive. Default: 'skip' (per D-10) */
+  unmappedTypeStrategy?: UnmappedTypeStrategy;
+  /**
+   * Maximum nesting depth for deep insert POST bodies. Default: 5.
+   * Per T-10-05: prevents denial-of-service via unbounded recursion.
+   */
+  maxDeepInsertDepth?: number;
+  /**
+   * OData controller classes decorated with @ODataController().
+   * Per D-17: forRoot() patches each controller's PATH_METADATA to prepend serviceRoot synchronously,
+   * before NestJS compiles the module. Controllers not listed here will NOT have serviceRoot applied.
+   */
+  controllers?: (new (...args: any[]) => any)[];
+}
+/** Resolved options with all defaults applied */
+interface ODataModuleResolvedOptions {
+  serviceRoot: string;
+  namespace: string;
+  maxTop: number;
+  maxExpandDepth: number;
+  /** Maximum nesting depth of $filter expressions (SEC-04). Default: 10 */
+  maxFilterDepth: number;
+  unmappedTypeStrategy: UnmappedTypeStrategy;
+  /** Maximum nesting depth for deep insert POST bodies. Default: 5. */
+  maxDeepInsertDepth: number;
+}
+declare const ConfigurableModuleClass: _$_nestjs_common0.ConfigurableModuleCls<ODataModuleOptions, "forRoot", "create", {}>;
+/**
+ * Core OData module — ORM-agnostic.
+ *
+ * Usage:
+ *   // Root module:
+ *   ODataModule.forRoot({ serviceRoot: '/odata' })
+ *   ODataModule.forRootAsync({ useFactory: () => ({ serviceRoot: '/odata' }) })
+ *
+ *   // Feature modules:
+ *   ODataModule.forFeature([myEdmEntityConfig])
+ *
+ * Zero TypeORM imports — per PKG-01 architecture constraint.
+ */
+declare class ODataModule extends ConfigurableModuleClass {
+  /** Static storage for serviceRoot, set by forRoot() and read by forFeature() adapters. */
+  private static _serviceRoot;
+  /** Returns the serviceRoot registered via forRoot(). Used by adapter modules (e.g. ODataTypeOrmModule). */
+  static get registeredServiceRoot(): string;
+  /** Override forRoot to inject the resolved-options provider into the dynamic module. */
+  static forRoot(options: ODataModuleOptions): DynamicModule;
+  /** Override forRootAsync to inject the resolved-options provider into the dynamic module. */
+  static forRootAsync(options: ConfigurableModuleAsyncOptions<ODataModuleOptions>): DynamicModule;
+  /**
+   * Register EDM entity configurations from a feature module.
+   * Entities provided here are available via the EDM_ENTITY_CONFIGS injection token.
+   */
+  static forFeature(entityConfigs: EdmEntityConfig[]): DynamicModule;
+}
+//#endregion
+//#region src/query/odata-query.pipe.d.ts
+/**
+ * ODataQueryPipe — NestJS PipeTransform that converts raw Express query params
+ * (req.query as Record<string, string>) into a typed, validated ODataQuery.
+ *
+ * Per threat model T-03-01: validates all $filter/$select/$orderby property
+ * references against EdmRegistry. Unknown properties throw ODataValidationError.
+ *
+ * Per threat model T-03-03: clamps $top to maxTop from ODataModuleResolvedOptions.
+ *
+ * Zero TypeORM imports — per PKG-01 architecture constraint.
+ */
+declare class ODataQueryPipe implements PipeTransform<Record<string, string>, ODataQuery> {
+  private readonly edmRegistry;
+  private readonly options;
+  constructor(edmRegistry: EdmRegistry, options: ODataModuleResolvedOptions);
+  transform(value: Record<string, string>, metadata: ArgumentMetadata): ODataQuery;
+  /**
+   * Recursively walk a FilterNode tree and throw ODataValidationError for any
+   * PropertyAccessNode whose path[0] is not in entityType.properties.
+   *
+   * Per D-10: validates property references before any DB query is constructed.
+   * Per T-03-01: unknown properties throw ODataValidationError (not a generic error).
+   */
+  private validateFilterNode;
+  /**
+   * Validate $expand navigation property names against the entity type's navigationProperties.
+   * Validates top-level navigation properties only — nested expand validation is handled
+   * by TypeOrmExpandVisitor at translation time with full EDM registry access.
+   *
+   * Per T-04-09: prevents users from expanding properties not declared as navigation properties.
+   * Per D-10: validates property references before any DB query is constructed.
+   */
+  private validateExpandNode;
+  /**
+   * Validate a $select item path[0] against entityType.properties.
+   * Throws ODataValidationError for unknown property names.
+   */
+  private validateSelectItem;
+}
+//#endregion
+//#region src/decorators/metadata-keys.d.ts
+/** Metadata key for @EdmType() property decorator — stores EdmTypeOptions per property */
+declare const EDM_TYPE_KEY: unique symbol;
+/** Metadata key for @ODataExclude() property decorator — stores Set<string> of excluded property names */
+declare const ODATA_EXCLUDE_KEY: unique symbol;
+/** Metadata key for @ODataEntitySet() class decorator — stores the entity set name string */
+declare const ODATA_ENTITY_SET_KEY: unique symbol;
+/** Metadata key for @ODataKey() property decorator — stores string[] of key property names */
+declare const ODATA_KEY_KEY: unique symbol;
+/** Metadata key for @ODataView() class decorator — stores ODataViewOptions */
+declare const ODATA_VIEW_KEY: unique symbol;
+/** Metadata key for @ODataGet() method decorator — marks a route as an OData route */
+declare const ODATA_ROUTE_KEY: unique symbol;
+/** Metadata key for @ODataController() class decorator — stores the entity set name string */
+declare const ODATA_CONTROLLER_KEY: unique symbol;
+/** Metadata key for @ODataETag() property decorator — stores the ETag source property name */
+declare const ODATA_ETAG_KEY: unique symbol;
+/** Metadata key for @ODataSearchable() property decorator — stores string[] of searchable property names */
+declare const ODATA_SEARCHABLE_KEY: unique symbol;
+//#endregion
+//#region src/decorators/odata-etag.decorator.d.ts
+/**
+ * Marks a property as the ETag source for concurrency control.
+ * Per D-03: opt-in per entity. Only entities with @ODataETag or @UpdateDateColumn get ETags.
+ *
+ * Usage:
+ *   class Product {
+ *     @ODataETag()
+ *     version: number
+ *   }
+ */
+declare function ODataETag(): PropertyDecorator;
+/**
+ * Get the ETag property name for a given entity class.
+ * Returns undefined if the entity does not have @ODataETag.
+ */
+declare function getETagProperty(target: new (...args: unknown[]) => unknown): string | undefined;
+//#endregion
+//#region src/decorators/odata-searchable.decorator.d.ts
+/**
+ * Marks a property as searchable via OData $search.
+ * Multiple properties on the same entity can be decorated — all are stored.
+ *
+ * Usage:
+ *   class Product {
+ *     @ODataSearchable()
+ *     name: string
+ *
+ *     @ODataSearchable()
+ *     description: string
+ *   }
+ */
+declare function ODataSearchable(): PropertyDecorator;
+/**
+ * Get the list of searchable property names for a given entity class.
+ * Returns an empty array if no properties are decorated with @ODataSearchable().
+ */
+declare function getSearchableProperties(target: new (...args: unknown[]) => unknown): string[];
+//#endregion
+//#region src/decorators/edm-type.decorator.d.ts
+/** Options for the @EdmType property decorator */
+interface EdmTypeOptions {
+  readonly type: string;
+  readonly precision?: number;
+  readonly scale?: number;
+  readonly maxLength?: number;
+}
+/**
+ * @EdmType() — override the EDM primitive type for a property.
+ * Use when the TypeScript type cannot be automatically mapped, or when
+ * precision/scale/maxLength constraints are needed (e.g., Edm.Decimal).
+ *
+ * Zero imports from typeorm, @nestjs/common, or any ORM. Pure reflect-metadata.
+ */
+declare function EdmType(options: EdmTypeOptions): PropertyDecorator;
+/** Read all @EdmType overrides registered on a class */
+declare function getEdmTypeOverrides(target: object): Record<string, EdmTypeOptions>;
+//#endregion
+//#region src/decorators/odata-exclude.decorator.d.ts
+/**
+ * @ODataExclude() — marks a property to be excluded from the OData EDM.
+ * The property will not appear in $metadata and will be stripped from responses.
+ *
+ * Zero imports from typeorm, @nestjs/common, or any ORM. Pure reflect-metadata.
+ */
+declare function ODataExclude(): PropertyDecorator;
+/** Read all property names excluded via @ODataExclude() on a class */
+declare function getExcludedProperties(target: object): Set<string>;
+//#endregion
+//#region src/decorators/odata-entity-set.decorator.d.ts
+/**
+ * @ODataEntitySet(name) — override the entity set name for an entity class.
+ * Without this decorator, the adapter will auto-pluralize the class name.
+ *
+ * Zero imports from typeorm, @nestjs/common, or any ORM. Pure reflect-metadata.
+ */
+declare function ODataEntitySet(name: string): ClassDecorator;
+/** Read the entity set name set via @ODataEntitySet(), or undefined if not set */
+declare function getEntitySetName(target: object): string | undefined;
+//#endregion
+//#region src/decorators/odata-key.decorator.d.ts
+/**
+ * @ODataKey() — marks a property as part of the entity key.
+ * Can be applied to multiple properties for composite keys.
+ *
+ * Zero imports from typeorm, @nestjs/common, or any ORM. Pure reflect-metadata.
+ */
+declare function ODataKey(): PropertyDecorator;
+/** Read all key property names registered via @ODataKey() on a class */
+declare function getKeyProperties(target: object): string[];
+//#endregion
+//#region src/decorators/odata-view.decorator.d.ts
+/** Options for the @ODataView class decorator */
+interface ODataViewOptions {
+  readonly sourceEntity: string;
+  readonly exposedProperties: string[];
+  readonly entitySetName?: string;
+}
+/**
+ * @ODataView() — marks a class as a virtual OData view.
+ * A virtual view projects a subset of an existing entity type's properties
+ * as its own EntitySet without duplicating entity registration. Per D-22, D-23.
+ *
+ * Zero imports from typeorm, @nestjs/common, or any ORM. Pure reflect-metadata.
+ */
+declare function ODataView(options: ODataViewOptions): ClassDecorator;
+/** Read the ODataView options from a class, or undefined if not decorated */
+declare function getODataViewOptions(target: object): ODataViewOptions | undefined;
+//#endregion
+//#region src/decorators/odata-get.decorator.d.ts
+/**
+ * Options for the @ODataGet() decorator.
+ */
+interface ODataGetOptions {
+  /** Custom route path. Defaults to '' (empty, NestJS will use the controller prefix). */
+  path?: string;
+  /**
+   * When true, signals the auto-handler mechanism (wired in Plan 04 by the typeorm module)
+   * to replace the decorated method body with a generated handler.
+   * Default: false
+   */
+  autoHandler?: boolean;
+}
+/**
+ * Composite method decorator for OData GET endpoints.
+ *
+ * Composes:
+ *   1. Get(path) — NestJS route decorator
+ *   2. SetMetadata(ODATA_ROUTE_KEY, { entitySetName }) — marks the route as OData
+ *   3. UseInterceptors(ODataResponseInterceptor) — wraps result in OData JSON envelope
+ *   4. UseFilters(ODataExceptionFilter) — formats errors as OData v4 error bodies
+ *
+ * @param entitySetName - The OData entity set name (e.g. 'Products'). Used to build
+ *   the @odata.context URL and for response formatting.
+ * @param options - Optional configuration
+ *
+ * Per D-12, D-13, RESEARCH.md Pattern 5.
+ * Zero TypeORM imports — per PKG-01 architecture constraint.
+ */
+declare function ODataGet(entitySetName: string, options?: ODataGetOptions): MethodDecorator;
+//#endregion
+//#region src/decorators/odata-query.decorator.d.ts
+/**
+ * Parameter decorator that extracts req.query and auto-applies ODataQueryPipe.
+ *
+ * Usage:
+ *   @Get()
+ *   async getProducts(@ODataQueryParam('Products') query: ODataQuery) { ... }
+ *
+ * The decorator passes the entitySetName as `data` so that the ODataQueryPipe
+ * can inject it into the query object for context URL construction and field validation.
+ *
+ * Per D-04: auto-applies ODataQueryPipe — no @UsePipes(ODataQueryPipe) needed.
+ * Per D-05: ODataQueryPipe remains exported for advanced use cases.
+ * Per D-06: eliminates silent validation bypass when forgetting @UsePipes.
+ *
+ * NestJS resolves ODataQueryPipe from DI automatically when a class reference
+ * is passed as the pipe argument to a createParamDecorator result.
+ *
+ * Zero TypeORM imports — per PKG-01 architecture constraint.
+ */
+declare const ODataQueryParam: (entitySetName?: string) => ParameterDecorator;
+//#endregion
+//#region src/decorators/odata-post.decorator.d.ts
+interface ODataPostOptions {
+  path?: string;
+}
+/**
+ * Composite method decorator for OData POST (create) endpoints.
+ *
+ * Composes:
+ *   1. Post(path) — NestJS route decorator
+ *   2. HttpCode(201) — POST returns 201 Created per D-03
+ *   3. SetMetadata(ODATA_ROUTE_KEY, { entitySetName, operation: 'create' })
+ *   4. UseInterceptors(ODataResponseInterceptor) — wraps result in OData JSON envelope
+ *   5. UseFilters(ODataExceptionFilter) — formats errors as OData v4 error bodies
+ *
+ * Per D-03: POST returns 201. Per D-12: explicit opt-in per operation.
+ * Zero TypeORM imports — per PKG-01 architecture constraint.
+ */
+declare function ODataPost(entitySetName: string, options?: ODataPostOptions): MethodDecorator;
+//#endregion
+//#region src/decorators/odata-patch.decorator.d.ts
+interface ODataPatchOptions {
+  path?: string;
+}
+/**
+ * Composite method decorator for OData PATCH (update) endpoints.
+ *
+ * Composes:
+ *   1. Patch(path) — NestJS route decorator, defaults to ':key'
+ *   2. SetMetadata(ODATA_ROUTE_KEY, { entitySetName, operation: 'update', isSingleEntity: true })
+ *   3. UseInterceptors(ODataResponseInterceptor) — wraps result in single-entity OData envelope
+ *   4. UseFilters(ODataExceptionFilter) — formats errors as OData v4 error bodies
+ *
+ * Per D-01: merge-patch semantics. Per D-02: parenthetical key via ':key' param.
+ * Zero TypeORM imports — per PKG-01 architecture constraint.
+ */
+declare function ODataPatch(entitySetName: string, options?: ODataPatchOptions): MethodDecorator;
+//#endregion
+//#region src/decorators/odata-put.decorator.d.ts
+interface ODataPutOptions {
+  path?: string;
+}
+/**
+ * Composite method decorator for OData PUT (full entity replacement) endpoints.
+ *
+ * Composes:
+ *   1. Put(path) — NestJS route decorator, defaults to ':key'
+ *   2. SetMetadata(ODATA_ROUTE_KEY, { entitySetName, operation: 'replace', isSingleEntity: true })
+ *   3. UseInterceptors(ODataResponseInterceptor) — wraps result in single-entity OData envelope
+ *   4. UseFilters(ODataExceptionFilter) — formats errors as OData v4 error bodies
+ *
+ * Per D-01: PUT semantics — full entity replacement. All unspecified fields reset to
+ * column defaults (null for nullable, default value for columns with defaults).
+ * Per D-02: parenthetical key via ':key' param.
+ * Zero TypeORM imports — per PKG-01 architecture constraint.
+ */
+declare function ODataPut(entitySetName: string, options?: ODataPutOptions): MethodDecorator;
+//#endregion
+//#region src/decorators/odata-delete.decorator.d.ts
+interface ODataDeleteOptions {
+  path?: string;
+}
+/**
+ * Composite method decorator for OData DELETE endpoints.
+ *
+ * Composes:
+ *   1. Delete(path) — NestJS route decorator, defaults to ':key'
+ *   2. HttpCode(204) — DELETE returns 204 No Content per D-04
+ *   3. SetMetadata(ODATA_ROUTE_KEY, { entitySetName, operation: 'delete' })
+ *   4. UseFilters(ODataExceptionFilter) — formats errors as OData v4 error bodies
+ *
+ * Per D-04: DELETE returns 204 with no body. No ODataResponseInterceptor — no body.
+ * Zero TypeORM imports — per PKG-01 architecture constraint.
+ */
+declare function ODataDelete(entitySetName: string, options?: ODataDeleteOptions): MethodDecorator;
+//#endregion
+//#region src/decorators/odata-get-by-key.decorator.d.ts
+interface ODataGetByKeyOptions {
+  path?: string;
+}
+/**
+ * Composite method decorator for OData GET-by-key (single entity) endpoints.
+ *
+ * Composes:
+ *   1. Get(path) — NestJS route decorator, defaults to ':key'
+ *   2. SetMetadata(ODATA_ROUTE_KEY, { entitySetName, operation: 'getByKey', isSingleEntity: true })
+ *   3. UseInterceptors(ODataResponseInterceptor) — returns entity directly (not wrapped in value array)
+ *   4. UseFilters(ODataExceptionFilter) — formats errors as OData v4 error bodies
+ *
+ * Per D-05: Returns single entity, not wrapped in value array.
+ * Context URL uses /$entity suffix for single-entity responses.
+ * Zero TypeORM imports — per PKG-01 architecture constraint.
+ */
+declare function ODataGetByKey(entitySetName: string, options?: ODataGetByKeyOptions): MethodDecorator;
+//#endregion
+//#region src/decorators/odata-controller.decorator.d.ts
+interface ODataControllerOptions {
+  /** Override the route path. Defaults to entitySetName. */
+  path?: string;
+}
+/**
+ * Class decorator for OData controllers.
+ *
+ * Composes:
+ *   1. Controller(path) — NestJS route prefix, defaults to entitySetName
+ *   2. SetMetadata(ODATA_CONTROLLER_KEY, entitySetName) — marks as OData controller
+ *      (used by ODataModule.forRoot() to patch PATH_METADATA with serviceRoot)
+ *
+ * Per D-11: Separate from @Controller() — sets entity context and route prefix.
+ * Per D-17: The service root prefix is applied by ODataModule.forRoot({ controllers })
+ *   via Reflect.defineMetadata(PATH_METADATA) — the same pattern used by MetadataController.
+ *   The controller is initially registered with just the entitySetName as path;
+ *   the module prepends serviceRoot during forRoot().
+ *
+ * Note: ODataResponseInterceptor and ODataExceptionFilter are NOT applied at class level.
+ * Each CRUD method decorator (@ODataGet, @ODataPost, @ODataPatch, @ODataDelete, @ODataGetByKey)
+ * applies these per-method. This avoids double-wrapping when method and class decorators
+ * are both used.
+ *
+ * @param entitySetName - The OData entity set name (e.g. 'Products')
+ * @param options - Optional configuration
+ *
+ * Zero TypeORM imports — per PKG-01 architecture constraint.
+ */
+declare function ODataController(entitySetName: string, options?: ODataControllerOptions): ClassDecorator;
+//#endregion
+//#region src/response/odata-context-url.builder.d.ts
+/**
+ * Builds the OData v4 @odata.context URL per spec section 10.
+ *
+ * Format: {serviceRoot}/$metadata#{entitySetName}[(field1,field2,...)]
+ * Single-entity format: {serviceRoot}/$metadata#{entitySetName}/$entity
+ *
+ * Per D-07: when $select has specific items (not all, not undefined),
+ * a select projection suffix is appended.
+ * Per D-05: when isSingleEntity is true, /$entity suffix is appended.
+ *
+ * @param serviceRoot - The OData service root path (e.g. '/odata')
+ * @param entitySetName - The name of the entity set (e.g. 'Products')
+ * @param select - Optional SelectNode from the parsed query
+ * @param isSingleEntity - When true, appends /$entity suffix for single-entity responses
+ */
+declare function buildContextUrl(serviceRoot: string, entitySetName: string, select?: SelectNode, isSingleEntity?: boolean): string;
+//#endregion
+//#region src/response/odata-annotation.builder.d.ts
+/**
+ * Context needed to annotate an entity with OData metadata annotations.
+ */
+interface AnnotationContext {
+  /** The OData service root path (e.g. '/odata') */
+  readonly serviceRoot: string;
+  /** The OData entity set name (e.g. 'Products') */
+  readonly entitySetName: string;
+  /** The EDM entity type descriptor */
+  readonly entityType: EdmEntityType;
+  /** The EDM namespace (e.g. 'Default') */
+  readonly namespace: string;
+}
+/**
+ * Annotate a single entity object with OData v4 metadata annotations.
+ *
+ * Adds:
+ * - @odata.id — canonical URL for the entity (RESP-04)
+ * - @odata.type — qualified type name with namespace prefix (RESP-05)
+ * - {navProp}@odata.navigationLink — for each navigation property (RESP-06)
+ *
+ * Returns the entity unchanged if it is null, undefined, or not an object.
+ *
+ * This function is pure — it never mutates the input entity.
+ *
+ * @param entity - The entity object to annotate
+ * @param ctx - The annotation context (service root, entity set name, entity type, namespace)
+ */
+declare function annotateEntity(entity: Record<string, unknown>, ctx: AnnotationContext): Record<string, unknown>;
+/**
+ * Annotate an array of entity objects with OData v4 metadata annotations.
+ *
+ * Applies `annotateEntity` to every item in the array and returns a new array.
+ * Does not mutate the input array or any items.
+ *
+ * @param items - The array of entity objects to annotate
+ * @param ctx - The annotation context
+ */
+declare function annotateEntities(items: Record<string, unknown>[], ctx: AnnotationContext): Record<string, unknown>[];
+//#endregion
+//#region src/response/odata-response.interceptor.d.ts
+/**
+ * NestJS interceptor that wraps ODataQueryResult into an OData v4 JSON envelope.
+ *
+ * Per D-05: only activates on routes that have ODATA_ROUTE_KEY metadata (set by @ODataGet()).
+ * Non-OData routes pass through completely unchanged (T-03-09).
+ *
+ * Response format:
+ *   {
+ *     '@odata.context': '/odata/$metadata#EntitySet',
+ *     '@odata.id': '/odata/EntitySet(key)',     (per RESP-04)
+ *     '@odata.type': '#Namespace.EntityType',   (per RESP-05)
+ *     '{nav}@odata.navigationLink': '...',      (per RESP-06)
+ *     'value': [...],
+ *     '@odata.count': N,       (only when present)
+ *     '@odata.nextLink': '...' (only when present)
+ *   }
+ *
+ * Per D-08: undefined keys are omitted entirely — not set to null or undefined.
+ *
+ * Zero TypeORM imports — per PKG-01 architecture constraint.
+ */
+declare class ODataResponseInterceptor implements NestInterceptor {
+  private readonly reflector;
+  private readonly options;
+  private readonly edmRegistry;
+  constructor(reflector: Reflector, options: ODataModuleResolvedOptions, edmRegistry: EdmRegistry);
+  /**
+   * Resolve the AnnotationContext for an entity set name.
+   * Returns null when the entity set or its type is not registered (graceful degradation).
+   */
+  private resolveAnnotationContext;
+  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+}
+//#endregion
+//#region src/response/odata-exception.filter.d.ts
+/**
+ * NestJS exception filter that converts all caught exceptions into OData v4 error format.
+ *
+ * Per D-09: all errors are formatted as { error: { code, message, details } }.
+ * Per D-11, T-03-08: never includes stack traces or internal server details.
+ *
+ * Handled exception types:
+ *   - ODataParseError    -> HTTP 400, code 'BadRequest', user message
+ *   - ODataValidationError -> HTTP 400, code 'BadRequest', user message
+ *   - HttpException      -> uses exception's HTTP status code, generic OData code
+ *   - All others         -> HTTP 500, code 'InternalServerError', generic message (no details leaked)
+ *
+ * Zero TypeORM imports — per PKG-01 architecture constraint.
+ */
+declare class ODataExceptionFilter implements ExceptionFilter {
+  catch(exception: unknown, host: ArgumentsHost): void;
+}
+//#endregion
+//#region src/metadata/csdl-builder.d.ts
+/**
+ * CsdlBuilder — builds OData v4 CSDL XML from the EdmRegistry.
+ *
+ * Per D-17: XML is built once at init time and cached.
+ * Per D-08: Default namespace is 'Default'.
+ * Per D-09: Container name is 'Container'.
+ * Per T-02-08: Caching mitigates DoS risk from repeated CSDL requests.
+ */
+declare class CsdlBuilder {
+  private readonly edmRegistry;
+  private readonly options;
+  private cachedXml;
+  constructor(edmRegistry: EdmRegistry, options: ODataModuleOptions);
+  /**
+   * Build and return the CSDL XML string.
+   * Builds once on first call; returns cached string on subsequent calls.
+   */
+  buildCsdlXml(): string;
+  private buildXml;
+  private buildEntityTypeXml;
+  private buildPropertyXml;
+  private buildNavigationPropertyXml;
+  private buildEntitySetXml;
+}
+//#endregion
+//#region src/metadata/service-document-builder.d.ts
+/** A single entity set entry in the OData service document */
+interface ServiceDocumentEntry {
+  readonly name: string;
+  readonly url: string;
+  readonly kind: 'EntitySet';
+}
+/** OData service document response shape */
+interface ServiceDocument {
+  readonly '@odata.context': string;
+  readonly value: readonly ServiceDocumentEntry[];
+}
+/**
+ * ServiceDocumentBuilder — builds the OData service document (root URL response).
+ *
+ * Per D-24: Service document lists all registered EntitySets with name, url, and kind.
+ */
+declare class ServiceDocumentBuilder {
+  private readonly edmRegistry;
+  private readonly options;
+  constructor(edmRegistry: EdmRegistry, options: ODataModuleOptions);
+  /**
+   * Build the OData service document JSON object.
+   * Returns @odata.context pointing to $metadata and a value array with all EntitySets.
+   */
+  buildServiceDocument(): ServiceDocument;
+}
+//#endregion
+//#region src/metadata/metadata.controller.d.ts
+/**
+ * MetadataController — serves the $metadata CSDL XML and OData service document.
+ *
+ * Routes (relative to serviceRoot, e.g. '/odata'):
+ *   GET /odata/$metadata  → CSDL XML  (Content-Type: application/xml)
+ *   GET /odata            → Service document JSON (Content-Type: application/json)
+ *
+ * The controller uses @Controller() with no prefix because consumers mount it
+ * via ODataModule which sets the serviceRoot path. The routes use the serviceRoot
+ * path directly to ensure correct routing when integrated into a NestJS app.
+ *
+ * Implementation uses a fixed serviceRoot-relative routing strategy:
+ * The @Controller() prefix is set to the serviceRoot and endpoints are
+ * '/$metadata' and '/' respectively. This is the most NestJS-idiomatic approach.
+ */
+declare class MetadataController {
+  private readonly csdlBuilder;
+  private readonly serviceDocumentBuilder;
+  readonly options: ODataModuleOptions;
+  constructor(csdlBuilder: CsdlBuilder, serviceDocumentBuilder: ServiceDocumentBuilder, options: ODataModuleOptions);
+  /**
+   * GET {serviceRoot}/$metadata
+   * Returns OData v4 CSDL XML document.
+   * Content-Type: application/xml per OData spec.
+   */
+  getMetadata(): string;
+  /**
+   * GET {serviceRoot}/ (service document)
+   * Returns OData service document listing all available EntitySets.
+   * Content-Type: application/json per OData spec.
+   */
+  getServiceDocument(): object;
+}
+//#endregion
+//#region src/utils/odata-key-parser.d.ts
+/**
+ * Parse an OData parenthetical key string into a Record of key-value pairs.
+ *
+ * Formats per D-02:
+ *   Simple:    '42'                  -> { Id: 42 }
+ *   String:    "'hello'"             -> { Name: 'hello' }
+ *   Composite: 'OrderId=1,ItemId=3'  -> { OrderId: 1, ItemId: 3 }
+ *
+ * Per T-04-02: Key values are returned as typed JS values (number, string, boolean)
+ * — never interpolated into SQL. Safe for parameterized ORM queries.
+ */
+/**
+ * Parse an OData parenthetical key string into a Record of key-value pairs.
+ *
+ * @param keyStr - The key string extracted from parentheses (e.g., '42', "'hello'", 'OrderId=1,ItemId=3')
+ * @param keyProperties - Ordered list of key property names (used for simple keys)
+ * @returns Record mapping property names to coerced values
+ * @throws Error if keyStr is empty
+ */
+declare function parseODataKey(keyStr: string, keyProperties: readonly string[]): Record<string, unknown>;
+//#endregion
+//#region src/index.d.ts
+declare const VERSION = "0.0.1";
+//#endregion
+export { AggregateExpression, type AnnotationContext, ApplyAggregateStep, ApplyFilterStep, ApplyGroupByStep, ApplyNode, ApplyStep, BatchChangesetPart, BatchPart, BatchRequestPart, BatchResponse, BatchResponsePart, BinaryExprNode, BinaryOperator, CsdlBuilder, EDM_DERIVER, EDM_ENTITY_CONFIGS, EDM_TYPE_KEY, ETAG_PROVIDER, EdmEntityConfig, EdmEntitySet, EdmEntityType, EdmNavigationProperty, EdmPrimitiveType, EdmProperty, EdmRegistry, EdmType, type EdmTypeOptions, EdmVirtualView, EntityClass, ExpandItem, ExpandNode, FilterNode, FilterVisitor, FunctionCallNode, IETagProvider, IEdmDeriver, IQueryTranslator, ISearchProvider, LambdaExprNode, LambdaOperator, LiteralKind, LiteralNode, MAX_BATCH_OPERATIONS, MetadataController, ODATA_CONTROLLER_KEY, ODATA_ENTITY_SET_KEY, ODATA_ETAG_KEY, ODATA_EXCLUDE_KEY, ODATA_KEY_KEY, ODATA_MODULE_OPTIONS, ODATA_ROUTE_KEY, ODATA_SEARCHABLE_KEY, ODATA_VIEW_KEY, ODataController, type ODataControllerOptions, ODataDelete, type ODataDeleteOptions, ODataETag, type ODataEntitySecurityOptions, ODataEntitySet, ODataExceptionFilter, ODataExclude, ODataGet, ODataGetByKey, type ODataGetByKeyOptions, type ODataGetOptions, ODataKey, ODataModule, ODataModuleOptions, ODataModuleResolvedOptions, ODataParseError, ODataPatch, type ODataPatchOptions, ODataPost, type ODataPostOptions, ODataPut, type ODataPutOptions, type ODataQuery, ODataQueryParam, ODataQueryPipe, type ODataQueryResult, ODataResponseInterceptor, ODataSearchable, ODataValidationError, ODataView, type ODataViewOptions, OrderByDirection, OrderByItem, OrderByNode, ParsedBatch, PropertyAccessNode, QUERY_TRANSLATOR, QueryOptions, SEARCH_PROVIDER, SearchBinaryNode, SearchNode, SearchTermNode, SelectItem, SelectNode, type ServiceDocument, ServiceDocumentBuilder, type ServiceDocumentEntry, Token, TokenKind, UnaryExprNode, UnaryOperator, UnmappedTypeStrategy, VERSION, acceptVisitor, annotateEntities, annotateEntity, buildContextUrl, extractBoundary, getETagProperty, getEdmTypeOverrides, getEntitySetName, getExcludedProperties, getKeyProperties, getODataViewOptions, getSearchableProperties, parseApply, parseBatchBody, parseFilter, parseODataKey, parseQuery, parseSearch, pluralizeEntityName, tokenize };
+//# sourceMappingURL=index.d.mts.map