angular-odata 0.122.0 → 0.124.0

package/lib/helper.d.ts

@@ -2,7 +2,7 @@ import { ODataMetadataType } from './types';
 export declare const COLLECTION: RegExp;
 export declare const PROPERTY: RegExp;
 export declare const EXPAND: RegExp;
-export declare type ODataContext = {
+export type ODataContext = {
     serviceRootUrl?: string;
     metadataUrl?: string;
     entitySet?: string;

package/lib/models/model.d.ts

@@ -4,6 +4,7 @@ import { EntityKey, ODataActionOptions, ODataEntityAnnotations, ODataEntityResou
 import { ODataStructuredType } from '../schema';
 import { ODataCollection } from './collection';
 import { ModelOptions, ODataModelEvent, ODataModelField, ODataModelOptions, ODataModelAttribute } from './options';
+import { ParserOptions } from '../types';
 export declare class ODataModel<T> {
     static options: ModelOptions;
     static meta: ODataModelOptions<any>;
@@ -24,7 +25,7 @@ export declare class ODataModel<T> {
         resource: ODataResource<T> | null;
     }[];
     _attributes: Map<string, ODataModelAttribute<any>>;
-    _annotations: ODataEntityAnnotations<T> | null;
+    _annotations: ODataEntityAnnotations<T>;
     _reset: boolean;
     _reparent: boolean;
     _silent: boolean;
@@ -148,6 +149,7 @@ export declare class ODataModel<T> {
     hasChanged({ include_navigation, }?: {
         include_navigation?: boolean;
     }): boolean;
+    encode<E>(name: keyof T, options?: ParserOptions): any;
     isNew(): boolean;
     withResource<R>(resource: any, ctx: (model: this) => R): R;
     /**
@@ -163,8 +165,8 @@ export declare class ODataModel<T> {
     getValue<P>(name: keyof T | string, options?: ODataOptions): Observable<P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null>;
     setReference<N>(name: keyof T | string, model: ODataModel<N> | ODataCollection<N, ODataModel<N>> | null, options?: ODataOptions): Observable<this>;
     getReference<P>(name: keyof T | string): ODataModel<P> | ODataCollection<P, ODataModel<P>> | null;
-    equals(other: ODataModel<T>): boolean;
     get [Symbol.toStringTag](): string;
+    equals(other: ODataModel<T>): boolean;
     collection(): ODataCollection<T, ODataModel<T>> | undefined;
     next(): ODataModel<T> | undefined;
     prev(): ODataModel<T> | undefined;

package/lib/models/options.d.ts

@@ -62,13 +62,11 @@ export declare enum ODataModelState {
     Removed = 1,
     Unchanged = 2
 }
-export declare type ModelOptions = {
+export type ModelOptions = {
     cid?: string;
-    fields: {
-        [name: string]: ModelFieldOptions;
-    };
+    fields: Map<string, ModelFieldOptions>;
 };
-export declare type ModelFieldOptions = {
+export type ModelFieldOptions = {
     field?: string;
     parser?: ODataStructuredTypeFieldParser<any>;
     default?: any;
@@ -86,7 +84,7 @@ export declare function Model({ cid }?: {
 export declare function ModelField({ name, ...options }?: {
     name?: string;
 } & ModelFieldOptions): (target: any, key: string) => void;
-export declare type ODataModelFieldOptions<F> = ModelFieldOptions & {
+export type ODataModelFieldOptions<F> = ModelFieldOptions & {
     name: string;
     field: string;
     parser: ODataStructuredTypeFieldParser<F>;
@@ -175,7 +173,7 @@ export declare class ODataModelAttribute<T> {
     private link;
     private unlink;
 }
-export declare type ODataModelEntry<T, M extends ODataModel<T>> = {
+export type ODataModelEntry<T, M extends ODataModel<T>> = {
     state: ODataModelState;
     model: M;
     key?: EntityKey<T> | {
@@ -187,7 +185,6 @@ export declare class ODataModelOptions<T> {
     name: string;
     cid: string;
     base?: string;
-    open?: boolean;
     private _fields;
     schema: ODataStructuredType<T>;
     entitySet?: ODataEntitySet;
@@ -202,6 +199,8 @@ export declare class ODataModelOptions<T> {
         alias?: boolean;
     }): string;
     isOpenType(): boolean;
+    isEntityType(): boolean;
+    isComplexType(): boolean;
     isTypeOf(type: string): boolean;
     isModelFor(entity: T | {
         [name: string]: any;

package/lib/resources/path/segments.d.ts

@@ -1,7 +1,7 @@
-import { PathSegment } from '../../types';
+import { Parser, PathSegment } from '../../types';
 import { EntityKey } from '../resource';
 import { SegmentHandler } from './handlers';
-export declare type ODataSegment = {
+export type ODataSegment = {
     name: PathSegment;
     path: string;
     type?: string;
@@ -11,14 +11,23 @@ export declare type ODataSegment = {
 export declare class ODataPathSegments {
     private _segments;
     constructor(segments?: ODataSegment[]);
-    pathAndParams(escape?: boolean): [string, {
-        [name: string]: any;
-    }];
+    pathAndParams({ escape, parser, }?: {
+        escape?: boolean;
+        parser?: Parser<any>;
+    }): [
+        string,
+        {
+            [name: string]: any;
+        }
+    ];
     types({ key }?: {
         key?: boolean;
     }): string[];
     keys(values?: (EntityKey<any> | undefined)[]): (EntityKey<any> | undefined)[];
-    toString(): string;
+    toString({ escape, parser, }?: {
+        escape?: boolean;
+        parser?: Parser<any>;
+    }): string;
     toJSON(): any[];
     clone(): ODataPathSegments;
     find(predicate: (segment: ODataSegment) => boolean): ODataSegment | undefined;

package/lib/resources/query/builder.d.ts

@@ -1,8 +1,8 @@
-export declare type Unpacked<T> = T extends (infer U)[] ? U : T;
-export declare type Select<T> = SelectType<T> | SelectType<T>[];
-export declare type SelectType<T> = string | keyof T;
-export declare type Filter<T> = FilterType | FilterType[];
-export declare type FilterType = string | {
+export type Unpacked<T> = T extends (infer U)[] ? U : T;
+export type Select<T> = SelectType<T> | SelectType<T>[];
+export type SelectType<T> = string | keyof T;
+export type Filter<T> = FilterType | FilterType[];
+export type FilterType = string | {
     [name: string]: any;
 };
 export declare enum StandardAggregateMethods {
@@ -12,25 +12,25 @@ export declare enum StandardAggregateMethods {
     average = "average",
     countdistinct = "countdistinct"
 }
-export declare type Aggregate = string | {
+export type Aggregate = string | {
     [propertyName: string]: {
         with: StandardAggregateMethods;
         as: string;
     };
 };
-export declare type OrderBy<T> = OrderByType<T> | OrderByType<T>[];
-export declare type OrderByType<T> = string | OrderByObject<T>;
-export declare type OrderByObject<T> = keyof T | [keyof T | string, 'asc' | 'desc'] | NestedOrderBy<T>;
-export declare type NestedOrderBy<T> = {
+export type OrderBy<T> = OrderByType<T> | OrderByType<T>[];
+export type OrderByType<T> = string | OrderByObject<T>;
+export type OrderByObject<T> = keyof T | [keyof T | string, 'asc' | 'desc'] | NestedOrderBy<T>;
+export type NestedOrderBy<T> = {
     [P in keyof T]?: T[P] extends Array<infer E> ? OrderBy<E> : OrderBy<T[P]>;
 };
-export declare type Expand<T> = ExpandType<T> | ExpandType<T>[];
-export declare type ExpandType<T> = string | ExpandObject<T>;
-export declare type ExpandObject<T> = keyof T | NestedExpandOptions<T>;
-export declare type NestedExpandOptions<T> = {
+export type Expand<T> = ExpandType<T> | ExpandType<T>[];
+export type ExpandType<T> = string | ExpandObject<T>;
+export type ExpandObject<T> = keyof T | NestedExpandOptions<T>;
+export type NestedExpandOptions<T> = {
     [P in keyof T]?: ExpandOptions<Unpacked<T[P]>>;
 };
-export declare type ExpandOptions<T> = {
+export type ExpandOptions<T> = {
     select?: Select<T>;
     filter?: Filter<T>;
     orderBy?: OrderBy<T>;
@@ -40,12 +40,12 @@ export declare type ExpandOptions<T> = {
     count?: boolean | Filter<T>;
     expand?: Expand<T>;
 };
-export declare type Transform<T> = {
+export type Transform<T> = {
     aggregate?: Aggregate | Array<Aggregate>;
     filter?: Filter<T>;
     groupBy?: GroupBy<T>;
 };
-export declare type GroupBy<T> = {
+export type GroupBy<T> = {
     properties: Array<keyof T>;
     transform?: Transform<T>;
 };
@@ -55,18 +55,19 @@ export declare enum QueryCustomTypes {
     Duration = 2,
     Binary = 3
 }
-export declare type QueryCustomType = {
+export type QueryCustomType = {
     type: QueryCustomTypes;
     value: any;
     name?: string;
 };
-export declare type Value = string | Date | number | boolean | QueryCustomType;
+export type Value = string | Date | number | boolean | QueryCustomType;
 export declare const raw: (value: string) => QueryCustomType;
 export declare const alias: (value: any, name?: string) => QueryCustomType;
 export declare const duration: (value: string) => QueryCustomType;
 export declare const binary: (value: string) => QueryCustomType;
 export declare const isQueryCustomType: (value: any) => boolean;
-export declare type QueryOptions<T> = ExpandOptions<T> & {
+export declare const isRawType: (value: any) => boolean;
+export type QueryOptions<T> = ExpandOptions<T> & {
     search: string;
     transform: {
         [name: string]: any;

package/lib/resources/query/expressions/base.d.ts

@@ -1,3 +1,4 @@
+import { Parser } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Renderable } from './syntax';
 export declare abstract class Expression<T> implements Renderable {
@@ -6,10 +7,11 @@ export declare abstract class Expression<T> implements Renderable {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    abstract render({ aliases, escape, prefix, }: {
-        aliases?: QueryCustomType[] | undefined;
-        escape?: boolean | undefined;
-        prefix?: string | undefined;
+    abstract render({ aliases, escape, prefix, parser, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+        parser?: Parser<T>;
     }): string;
     abstract clone(): Expression<T>;
     children(): Renderable[];

package/lib/resources/query/expressions/compute.d.ts

@@ -1,7 +1,8 @@
+import { Parser } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
-export declare type ComputeExpressionBuilder<T> = {
+export type ComputeExpressionBuilder<T> = {
     t: Required<Readonly<T>>;
     e: () => ComputeExpression<T>;
 };
@@ -11,15 +12,16 @@ export declare class ComputeExpression<T> extends Expression<T> {
         children?: Renderable[];
         names?: string[];
     });
-    static compute<T extends object>(opts: (builder: ComputeExpressionBuilder<T>, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
-    render({ aliases, escape, prefix, }?: {
-        aliases?: QueryCustomType[] | undefined;
-        escape?: boolean | undefined;
-        prefix?: string | undefined;
+    static compute<T>(opts: (builder: ComputeExpressionBuilder<T>, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
+    render({ aliases, escape, prefix, parser, }?: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+        parser?: Parser<T>;
     }): string;
-    clone(): ComputeExpression<unknown>;
+    clone(): ComputeExpression<T>;
     private _add;
-    field<T extends object>(name: string, opts: (e: {
+    field<T>(name: string, opts: (e: {
         o: ODataOperators<T>;
         f: ODataFunctions<T>;
     }) => Renderable): ComputeExpression<T>;

package/lib/resources/query/expressions/count.d.ts

@@ -1,8 +1,9 @@
+import { Parser } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { FilterExpression, FilterExpressionBuilder } from './filter';
 import { Renderable } from './syntax';
-export declare class CountField<T extends object> implements Renderable {
+export declare class CountField<T> implements Renderable {
     protected field: any;
     private values;
     constructor(field: any, values?: {
@@ -12,16 +13,17 @@ export declare class CountField<T extends object> implements Renderable {
     toJSON(): {
         field: any;
     };
-    render({ aliases, escape, prefix, }: {
+    render({ aliases, escape, prefix, parser, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
+        parser?: Parser<T>;
     }): string;
     filter(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): any;
-    clone(): CountField<object>;
+    clone(): CountField<T>;
     private option;
 }
-export declare type CountExpressionBuilder<T> = {
+export type CountExpressionBuilder<T> = {
     t: Readonly<Required<T>>;
     e: () => CountExpression<T>;
 };
@@ -29,15 +31,16 @@ export declare class CountExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    static count<T extends object>(opts: (builder: CountExpressionBuilder<T>, current?: CountExpression<T>) => CountExpression<T>, current?: CountExpression<T>): CountExpression<T>;
+    static count<T>(opts: (builder: CountExpressionBuilder<T>, current?: CountExpression<T>) => CountExpression<T>, current?: CountExpression<T>): CountExpression<T>;
     private _add;
-    render({ aliases, escape, prefix, }?: {
-        aliases?: QueryCustomType[] | undefined;
-        escape?: boolean | undefined;
-        prefix?: string | undefined;
+    render({ aliases, escape, prefix, parser, }?: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+        parser?: Parser<T>;
     }): string;
-    clone(): CountExpression<unknown>;
-    field<F extends Object>(field: F[], opts?: (e: {
+    clone(): CountExpression<T>;
+    field<F>(field: F[], opts?: (e: {
         t: F;
         f: CountField<F>;
     }) => CountExpression<F>): CountExpression<F>;

package/lib/resources/query/expressions/expand.d.ts

@@ -1,4 +1,5 @@
-import type { QueryCustomType } from '../builder';
+import { Parser } from '../../../types';
+import type { QueryCustomType, Unpacked } from '../builder';
 import { Expression } from './base';
 import { FilterExpression, FilterExpressionBuilder } from './filter';
 import { OrderByExpression, OrderByExpressionBuilder } from './orderby';
@@ -15,23 +16,25 @@ export declare class ExpandField<T> implements Renderable {
     toJSON(): {
         field: any;
     };
-    render({ aliases, escape, prefix, }: {
+    render({ aliases, escape, prefix, parser, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
+        parser?: Parser<T>;
     }): string;
-    clone(): ExpandField<unknown>;
-    select<T extends object>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
-    expand<T extends object>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>): any;
-    filter<T extends object>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): any;
-    search<T extends object>(opts: (builder: SearchExpressionBuilder<T>) => SearchExpression<T>): any;
-    orderBy<T extends object>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>): any;
-    skip(n: number): any;
-    top(n: number): any;
-    levels(n: number | 'max'): any;
+    clone(): ExpandField<T>;
+    select<T>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
+    expand<T>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>): ExpandExpression<T>;
+    filter<T>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
+    search<T>(opts: (builder: SearchExpressionBuilder<T>) => SearchExpression<T>): SearchExpression<T>;
+    orderBy<T>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
+    skip(n: number): number;
+    top(n: number): number;
+    levels(n: number | 'max'): number | "max";
+    count(): boolean;
     private option;
 }
-export declare type ExpandExpressionBuilder<T> = {
+export type ExpandExpressionBuilder<T> = {
     t: Readonly<Required<T>>;
     e: () => ExpandExpression<T>;
 };
@@ -39,13 +42,14 @@ export declare class ExpandExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    static expand<T extends object>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
-    render({ aliases, escape, prefix, }?: {
-        aliases?: QueryCustomType[] | undefined;
-        escape?: boolean | undefined;
-        prefix?: string | undefined;
+    static expand<T>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
+    render({ aliases, escape, prefix, parser, }?: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+        parser?: Parser<T>;
     }): string;
-    clone(): ExpandExpression<unknown>;
+    clone(): ExpandExpression<T>;
     private _add;
-    field<F>(field: F, opts?: (e: ExpandField<F>) => void): ExpandExpression<F>;
+    field<F>(field: F, opts?: (e: ExpandField<Unpacked<F>>) => void): ExpandExpression<T>;
 }

package/lib/resources/query/expressions/filter.d.ts

@@ -1,9 +1,10 @@
+import { Parser } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { CountExpression, CountField } from './count';
-import { ODataFunctions, ODataOperators, Renderable } from './syntax';
-export declare type FilterConnector = 'and' | 'or';
-export declare type FilterExpressionBuilder<T> = {
+import { Normalize, ODataFunctions, ODataOperators, Renderable } from './syntax';
+export type FilterConnector = 'and' | 'or';
+export type FilterExpressionBuilder<T> = {
     t: Readonly<Required<T>>;
     e: (connector?: FilterConnector) => FilterExpression<T>;
     o: ODataOperators<T>;
@@ -17,7 +18,7 @@ export declare class FilterExpression<F> extends Expression<F> {
         connector?: FilterConnector;
         negated?: boolean;
     });
-    static filter<T extends object>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
+    static filter<T>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
     toJSON(): {
         children: any[];
         connector: FilterConnector;
@@ -25,36 +26,37 @@ export declare class FilterExpression<F> extends Expression<F> {
     };
     connector(): FilterConnector;
     negated(): boolean;
-    render({ aliases, escape, prefix, }?: {
+    render({ aliases, escape, prefix, parser, }?: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
+        parser?: Parser<any>;
     }): string;
-    clone(): FilterExpression<unknown>;
+    clone(): FilterExpression<F>;
     private _add;
     or(exp: FilterExpression<F>): FilterExpression<F>;
     and(exp: FilterExpression<F>): FilterExpression<F>;
     not(exp: FilterExpression<F>): FilterExpression<F>;
-    eq(left: any, right: any, normalize?: boolean): FilterExpression<F>;
-    ne(left: any, right: any, normalize?: boolean): FilterExpression<F>;
-    gt(left: any, right: any, normalize?: boolean): FilterExpression<F>;
-    ge(left: any, right: any, normalize?: boolean): FilterExpression<F>;
-    lt(left: any, right: any, normalize?: boolean): FilterExpression<F>;
-    le(left: any, right: any, normalize?: boolean): FilterExpression<F>;
-    has(left: any, right: any, normalize?: boolean): FilterExpression<F>;
-    in(left: any, right: any, normalize?: boolean): FilterExpression<F>;
-    contains(left: any, right: any, normalize?: boolean): FilterExpression<F>;
-    startsWith(left: any, right: any, normalize?: boolean): FilterExpression<F>;
-    endsWith(left: any, right: any, normalize?: boolean): FilterExpression<F>;
-    any<N extends object>(left: N[], opts?: (e: {
+    eq(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    ne(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    gt(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    ge(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    lt(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    le(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    has(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    in(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    contains(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    startsWith(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    endsWith(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
+    any<N>(left: N[], opts?: (e: {
         e: (connector?: FilterConnector) => FilterExpression<N>;
         t: N;
     }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
-    all<N extends object>(left: N[], opts: (e: {
+    all<N>(left: N[], opts: (e: {
         t: N;
         e: (connector?: FilterConnector) => FilterExpression<N>;
     }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
-    count<N extends object>(left: N[], opts?: (e: {
+    count<N>(left: N[], opts?: (e: {
         t: N;
         f: CountField<N>;
     }) => CountExpression<N>): FilterExpression<F>;

package/lib/resources/query/expressions/orderby.d.ts

@@ -1,3 +1,4 @@
+import { Parser } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
@@ -8,16 +9,17 @@ export declare class OrderByField implements Renderable {
     get [Symbol.toStringTag](): string;
     toJSON(): {
         field: any;
-        order: "desc" | "asc";
+        order: "asc" | "desc";
     };
-    render({ aliases, escape, prefix, }: {
+    render({ aliases, escape, prefix, parser, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
+        parser?: Parser<any>;
     }): string;
     clone(): OrderByField;
 }
-export declare type OrderByExpressionBuilder<T> = {
+export type OrderByExpressionBuilder<T> = {
     t: Readonly<Required<T>>;
     e: () => OrderByExpression<T>;
 };
@@ -25,14 +27,15 @@ export declare class OrderByExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    static orderBy<T extends object>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
+    static orderBy<T>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
     private _add;
-    render({ aliases, escape, prefix, }?: {
-        aliases?: QueryCustomType[] | undefined;
-        escape?: boolean | undefined;
-        prefix?: string | undefined;
+    render({ aliases, escape, prefix, parser, }?: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+        parser?: Parser<T>;
     }): string;
-    clone(): OrderByExpression<unknown>;
+    clone(): OrderByExpression<T>;
     ascending(field: any): OrderByExpression<T>;
     descending(field: any): OrderByExpression<T>;
 }

package/lib/resources/query/expressions/search.d.ts

@@ -1,7 +1,8 @@
+import { Parser } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
-export declare type SearchConnector = 'AND' | 'OR';
+export type SearchConnector = 'AND' | 'OR';
 export declare class SearchTerm implements Renderable {
     protected value: string;
     constructor(value: string);
@@ -10,14 +11,15 @@ export declare class SearchTerm implements Renderable {
         $type: string;
         value: string;
     };
-    render({ aliases, escape, prefix, }: {
+    render({ aliases, escape, prefix, parser, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
+        parser?: Parser<any>;
     }): string;
     clone(): SearchTerm;
 }
-export declare type SearchExpressionBuilder<T> = {
+export type SearchExpressionBuilder<T> = {
     e: (connector?: SearchConnector) => SearchExpression<T>;
 };
 export declare class SearchExpression<T> extends Expression<T> {
@@ -28,14 +30,15 @@ export declare class SearchExpression<T> extends Expression<T> {
         connector?: SearchConnector;
         negated?: boolean;
     });
-    static search<T extends object>(opts: (builder: SearchExpressionBuilder<T>, current?: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
+    static search<T>(opts: (builder: SearchExpressionBuilder<T>, current?: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
     private _add;
-    render({ aliases, escape, prefix, }?: {
-        aliases?: QueryCustomType[] | undefined;
-        escape?: boolean | undefined;
-        prefix?: string | undefined;
+    render({ aliases, escape, prefix, parser, }?: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+        parser?: Parser<T>;
     }): string;
-    clone(): SearchExpression<unknown>;
+    clone(): SearchExpression<T>;
     toJSON(): {
         children: any[];
         connector: SearchConnector;

package/lib/resources/query/expressions/select.d.ts

@@ -1,7 +1,8 @@
+import { Parser } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
-export declare type SelectExpressionBuilder<T> = {
+export type SelectExpressionBuilder<T> = {
     t: Readonly<Required<T>>;
     e: () => SelectExpression<T>;
 };
@@ -9,13 +10,14 @@ export declare class SelectExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    static select<T extends object>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
-    render({ aliases, escape, prefix, }?: {
-        aliases?: QueryCustomType[] | undefined;
-        escape?: boolean | undefined;
-        prefix?: string | undefined;
+    static select<T>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
+    render({ aliases, escape, prefix, parser, }?: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+        parser?: Parser<T>;
     }): string;
-    clone(): SelectExpression<unknown>;
+    clone(): SelectExpression<T>;
     private _add;
     field(field: any): SelectExpression<T>;
 }