angular-odata 0.123.0 → 0.125.0

package/lib/constants.d.ts

@@ -59,6 +59,7 @@ export declare const NEWLINE = "\r\n";
 export declare const NEWLINE_REGEXP: RegExp;
 export declare const CACHE_KEY_SEPARATOR = ":";
 export declare const CID_FIELD_NAME = "_cid";
+export declare const EVENT_SPLITTER: RegExp;
 export declare const COMPUTED: RegExp;
 export declare const OPTIMISTIC_CONCURRENCY: RegExp;
 export declare const DESCRIPTION: RegExp;

package/lib/helper.d.ts

@@ -26,31 +26,31 @@ export interface ODataVersionHelper {
     ODATA_DEFERRED: string;
     ODATA_ANNOTATION: string;
     entity(value: {
-        [key: string]: any;
+        [name: string]: any;
     }): any;
     entities(value: {
-        [key: string]: any;
+        [name: string]: any;
     }): any;
     property(value: {
-        [key: string]: any;
+        [name: string]: any;
     }): any;
     annotations(value: {
-        [key: string]: any;
+        [name: string]: any;
     }): Map<string, any>;
     attributes(value: {
-        [key: string]: any;
+        [name: string]: any;
     }, metadata: ODataMetadataType): any;
     context(annots: Map<string, any> | {
-        [key: string]: any;
+        [name: string]: any;
     }): ODataContext;
     id(annots: Map<string, any> | {
-        [key: string]: any;
+        [name: string]: any;
     }): string | undefined;
     etag(annots: Map<string, any> | {
-        [key: string]: any;
+        [name: string]: any;
     }): string | undefined;
     type(annots: Map<string, any> | {
-        [key: string]: any;
+        [name: string]: any;
     }): string | undefined;
     count(annots: Map<string, any>): number | undefined;
     functions(annots: Map<string, any>): Map<string, any>;
@@ -65,7 +65,7 @@ export interface ODataVersionHelper {
     mediaContentType(annots: Map<string, any>): string | undefined;
     deltaLink(annots: Map<string, any>): string | undefined;
     countParam(): {
-        [key: string]: string;
+        [name: string]: string;
     };
 }
 export declare const ODataHelper: {

package/lib/models/collection.d.ts

@@ -1,9 +1,8 @@
-import { EventEmitter } from '@angular/core';
 import { Observable } from 'rxjs';
 import { ODataActionOptions, ODataEntitiesAnnotations, ODataEntitySetResource, ODataFunctionOptions, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryOptionsHandler, ODataResource } from '../resources';
 import { ODataStructuredType } from '../schema/structured-type';
 import { ODataModel } from './model';
-import { ModelFieldOptions, ODataModelEntry, ODataModelEvent, ODataModelField } from './options';
+import { ModelFieldOptions, ODataModelEntry, ODataModelEventEmitter, ODataModelField } from './options';
 export declare class ODataCollection<T, M extends ODataModel<T>> implements Iterable<M> {
     static model: typeof ODataModel | null;
     _parent: [
@@ -23,7 +22,7 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     _model: typeof ODataModel;
     models(): M[];
     get length(): number;
-    events$: EventEmitter<ODataModelEvent<T>>;
+    events$: ODataModelEventEmitter<T>;
     constructor(entities?: Partial<T>[] | {
         [name: string]: any;
     }[], { parent, resource, annots, model, reset, }?: {
@@ -134,8 +133,8 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
         silent?: boolean;
     }): void;
     query(ctx: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): this;
-    callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataFunctionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
-    callAction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataActionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
+    callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', options?: ODataFunctionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
+    callAction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', options?: ODataActionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
     private _unlink;
     private _link;
     private _findEntry;

package/lib/models/model.d.ts

@@ -1,9 +1,8 @@
-import { EventEmitter } from '@angular/core';
 import { Observable } from 'rxjs';
 import { EntityKey, ODataActionOptions, ODataEntityAnnotations, ODataEntityResource, ODataFunctionOptions, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryArgumentsOptions, ODataQueryOptionsHandler, ODataResource, ODataSingletonResource } from '../resources';
 import { ODataStructuredType } from '../schema';
 import { ODataCollection } from './collection';
-import { ModelOptions, ODataModelEvent, ODataModelField, ODataModelOptions, ODataModelAttribute } from './options';
+import { ModelOptions, ODataModelField, ODataModelOptions, ODataModelAttribute, ODataModelEventEmitter } from './options';
 import { ParserOptions } from '../types';
 export declare class ODataModel<T> {
     static options: ModelOptions;
@@ -25,12 +24,12 @@ 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;
     _meta: ODataModelOptions<any>;
-    events$: EventEmitter<ODataModelEvent<T>>;
+    events$: ODataModelEventEmitter<T>;
     constructor(data?: Partial<T> | {
         [name: string]: any;
     }, { parent, resource, annots, reset, }?: {
@@ -74,7 +73,7 @@ export declare class ODataModel<T> {
         [name: string]: any;
     } | null | undefined;
     _errors?: {
-        [key: string]: any;
+        [name: string]: any;
     };
     validate({ method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';
@@ -158,13 +157,14 @@ export declare class ODataModel<T> {
      * @returns The result of the context
      */
     asEntity<R>(ctx: (model: this) => R): R;
-    callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none' | 'blob' | 'arraybuffer', { ...options }?: {} & ODataFunctionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null | Blob | ArrayBuffer>;
+    callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none' | 'blob' | 'arraybuffer', options?: ODataFunctionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null | Blob | ArrayBuffer>;
     callAction<P, R>(name: string, params: P | null, responseType?: 'property' | 'model' | 'collection' | 'none' | 'blob' | 'arraybuffer', { ...options }?: {} & ODataActionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null | Blob | ArrayBuffer>;
     cast<S>(type: string): ODataModel<S>;
-    fetchNavigationProperty<S>(name: keyof T | string, responseType: 'model' | 'collection', { ...options }?: {} & ODataQueryArgumentsOptions<S>): Observable<ODataModel<S> | ODataCollection<S, ODataModel<S>> | null>;
-    getValue<P>(name: keyof T | string, options?: ODataOptions): Observable<P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null>;
+    fetchNavigationProperty<S>(name: keyof T | string, responseType: 'model' | 'collection', options?: ODataQueryArgumentsOptions<S>): Observable<ODataModel<S> | ODataCollection<S, ODataModel<S>> | null>;
+    fetchAttribute<P>(name: keyof T | string, options?: ODataQueryArgumentsOptions<P>): Observable<P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null>;
+    getAttribute<P>(name: keyof T | string): P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null | undefined;
+    setAttribute<N>(name: keyof T | string, model: ODataModel<N> | ODataCollection<N, ODataModel<N>> | null, options?: ODataOptions): Observable<this>;
     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;
     get [Symbol.toStringTag](): string;
     equals(other: ODataModel<T>): boolean;
     collection(): ODataCollection<T, ODataModel<T>> | undefined;

package/lib/models/options.d.ts

@@ -18,33 +18,54 @@ export declare enum ODataModelEventType {
     Attach = "attach"
 }
 export declare class ODataModelEvent<T> {
-    name: ODataModelEventType;
+    name: ODataModelEventType | string;
     value?: any;
     previous?: any;
     options?: any;
-    constructor(name: ODataModelEventType, { model, collection, previous, value, attr, options, }?: {
+    constructor(name: ODataModelEventType | string, { model, collection, previous, value, attr, options, bubbly, chain, }?: {
         model?: ODataModel<T>;
         collection?: ODataCollection<T, ODataModel<T>>;
         attr?: ODataModelAttribute<any> | number;
         previous?: any;
         value?: any;
         options?: any;
+        bubbly?: boolean;
+        chain?: [
+            ODataModel<any> | ODataCollection<any, ODataModel<any>>,
+            ODataModelAttribute<any> | number | null
+        ][];
     });
-    bubbling: boolean;
-    stopPropagation(): void;
     chain: [
         ODataModel<any> | ODataCollection<any, ODataModel<any>>,
         ODataModelAttribute<any> | number | null
     ][];
     push(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>, attr: ODataModelAttribute<any> | number): ODataModelEvent<T>;
+    bubbly: boolean;
+    stopPropagation(): void;
     visited(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
+    canContinueWith(self: ODataModel<T> | ODataCollection<T, ODataModel<T>>): boolean;
     get path(): string;
     model?: ODataModel<T>;
     get currentModel(): ODataModel<any> | undefined;
     collection?: ODataCollection<T, ODataModel<T>>;
     get currentCollection(): ODataCollection<any, ODataModel<any>> | undefined;
 }
-export declare const BUBBLING: ODataModelEventType[];
+export declare class ODataModelEventEmitter<T> extends EventEmitter<ODataModelEvent<T>> {
+    model?: ODataModel<T>;
+    collection?: ODataCollection<T, ODataModel<T>>;
+    constructor({ model, collection, }?: {
+        model?: ODataModel<T>;
+        collection?: ODataCollection<T, ODataModel<T>>;
+    });
+    trigger(type: ODataModelEventType | string, { collection, previous, value, attr, options, bubbly, }?: {
+        collection?: ODataCollection<T, ODataModel<T>>;
+        attr?: ODataModelAttribute<any> | number;
+        previous?: any;
+        value?: any;
+        options?: any;
+        bubbly?: boolean;
+    }): void;
+}
 export declare const INCLUDE_SHALLOW: {
     include_concurrency: boolean;
     include_computed: boolean;
@@ -64,9 +85,7 @@ export declare enum ODataModelState {
 }
 export type ModelOptions = {
     cid?: string;
-    fields: {
-        [name: string]: ModelFieldOptions;
-    };
+    fields: Map<string, ModelFieldOptions>;
 };
 export type ModelFieldOptions = {
     field?: string;
@@ -156,7 +175,7 @@ export declare class ODataModelAttribute<T> {
     private value?;
     private change?;
     private subscription?;
-    events$: EventEmitter<ODataModelEvent<T>>;
+    events$: ODataModelEventEmitter<T>;
     constructor(_model: ODataModel<any>, _field: ODataModelField<T>);
     get navigation(): boolean;
     get computed(): boolean | undefined;
@@ -187,12 +206,12 @@ export declare class ODataModelOptions<T> {
     name: string;
     cid: string;
     base?: string;
-    open?: boolean;
     private _fields;
     schema: ODataStructuredType<T>;
     entitySet?: ODataEntitySet;
     parent?: ODataModelOptions<any>;
     children: ODataModelOptions<any>[];
+    events$: ODataModelEventEmitter<T>;
     constructor({ options, schema, }: {
         options: ModelOptions;
         schema: ODataStructuredType<T>;
@@ -202,6 +221,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,4 +1,4 @@
-import { PathSegment } from '../../types';
+import { Parser, PathSegment } from '../../types';
 import { EntityKey } from '../resource';
 import { SegmentHandler } from './handlers';
 export type ODataSegment = {
@@ -11,14 +11,23 @@ export 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/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, }: {
+    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,3 +1,4 @@
+import { Parser } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
@@ -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<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,10 +13,11 @@ 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<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<T>;
-    field<F extends Object>(field: F[], opts?: (e: {
+    field<F>(field: F[], opts?: (e: {
         t: F;
         f: CountField<F>;
     }) => CountExpression<F>): CountExpression<F>;

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

@@ -1,3 +1,4 @@
+import { Parser } from '../../../types';
 import type { QueryCustomType, Unpacked } from '../builder';
 import { Expression } from './base';
 import { FilterExpression, FilterExpressionBuilder } from './filter';
@@ -15,17 +16,18 @@ 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<T>;
-    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>): ExpandExpression<T>;
-    filter<T extends object>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
-    search<T extends object>(opts: (builder: SearchExpressionBuilder<T>) => SearchExpression<T>): SearchExpression<T>;
-    orderBy<T extends object>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<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";
@@ -40,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<T>;
     private _add;
-    field<F extends keyof T>(field: T[F], opts?: (e: ExpandField<Unpacked<T[F]>>) => void): ExpandExpression<T>;
+    field<F>(field: F, opts?: (e: ExpandField<Unpacked<F>>) => void): ExpandExpression<T>;
 }

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

@@ -1,3 +1,4 @@
+import { Parser } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { CountExpression, CountField } from './count';
@@ -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,10 +26,11 @@ 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<F>;
     private _add;
@@ -46,15 +48,15 @@ export declare class FilterExpression<F> extends Expression<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 extends object>(left: N[], opts?: (e: {
+    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';
@@ -10,10 +11,11 @@ export declare class OrderByField implements Renderable {
         field: any;
         order: "asc" | "desc";
     };
-    render({ aliases, escape, prefix, }: {
+    render({ aliases, escape, prefix, parser, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
+        parser?: Parser<any>;
     }): string;
     clone(): OrderByField;
 }
@@ -25,12 +27,13 @@ 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<T>;
     ascending(field: any): OrderByExpression<T>;

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

@@ -1,3 +1,4 @@
+import { Parser } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
@@ -10,10 +11,11 @@ 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;
 }
@@ -28,12 +30,13 @@ 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<T>;
     toJSON(): {

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

@@ -1,3 +1,4 @@
+import { Parser } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
@@ -9,11 +10,12 @@ 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<T>;
     private _add;