angular-odata 0.124.0 → 0.126.0

package/lib/api.d.ts

@@ -26,13 +26,13 @@ export declare class ODataApi {
     configure(settings?: {
         requester?: (request: ODataRequest<any>) => Observable<any>;
     }): void;
-    fromJSON<P, R>(json: {
+    fromJson<P, R>(json: {
         segments: ODataSegment[];
         options: {
             [name: string]: any;
         };
     }): ODataActionResource<P, R> | ODataFunctionResource<P, R>;
-    fromJSON<E>(json: {
+    fromJson<E>(json: {
         segments: ODataSegment[];
         options: {
             [name: string]: any;

package/lib/client.d.ts

@@ -81,7 +81,7 @@ export declare class ODataClient {
     modelByName(name: string): typeof ODataModel;
     collectionByName(name: string): typeof ODataCollection;
     serviceByName(name: string): ODataEntityService<any> | undefined;
-    fromJSON<E>(json: {
+    fromJson<E>(json: {
         segments: ODataSegment[];
         options: {
             [name: string]: any;

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,34 +22,35 @@ 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, }?: {
         parent?: [ODataModel<any>, ODataModelField<any>];
-        resource?: ODataResource<T>;
+        resource?: ODataResource<T> | null;
         annots?: ODataEntitiesAnnotations<T>;
         model?: typeof ODataModel;
         reset?: boolean;
     });
     isParentOf(child: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
-    resource(): ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>;
-    pushResource(resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>): void;
+    resource(): ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null;
+    pushResource(resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null): void;
     popResource(): {
         parent: [ODataModel<any> | ODataCollection<any, ODataModel<any>>, ODataModelField<any> | null] | null;
         resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null;
     } | undefined;
     attach(resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>): void;
-    withResource<R>(resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>, ctx: (collection: this) => R): R;
+    withResource<R>(resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null, ctx: (collection: this) => R): R;
     asEntitySet<R>(ctx: (collection: this) => R): R;
     annots(): ODataEntitiesAnnotations<T>;
     private modelFactory;
-    toEntities({ client_id, include_navigation, include_concurrency, include_computed, include_key, include_non_field, changes_only, field_mapping, chain, }?: {
+    toEntities({ client_id, include_navigation, include_concurrency, include_computed, include_key, include_id, include_non_field, changes_only, field_mapping, chain, }?: {
         client_id?: boolean;
         include_navigation?: boolean;
         include_concurrency?: boolean;
         include_computed?: boolean;
         include_key?: boolean;
+        include_id?: boolean;
         include_non_field?: boolean;
         changes_only?: boolean;
         field_mapping?: boolean;
@@ -58,7 +58,7 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     }): (Partial<T> | {
         [name: string]: any;
     })[];
-    toJSON(): (Partial<T> | {
+    toJson(): (Partial<T> | {
         [name: string]: any;
     })[];
     hasChanged({ include_navigation }?: {
@@ -94,20 +94,21 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     }): Observable<this>;
     private addReference;
     private _addModel;
-    private addModel;
-    add(model: M, { silent, reparent, server, merge, position, }?: {
+    add(model: M, { silent, reparent, server, merge, position, reset, }?: {
         silent?: boolean;
         reparent?: boolean;
         server?: boolean;
         merge?: boolean;
         position?: number;
+        reset?: boolean;
     }): Observable<M>;
     private removeReference;
     private _removeModel;
     private removeModel;
-    remove(model: M, { silent, server, }?: {
+    remove(model: M, { silent, server, reset, }?: {
         silent?: boolean;
         server?: boolean;
+        reset?: boolean;
     }): Observable<M>;
     private _moveModel;
     create(attrs?: T, { silent, server, }?: {
@@ -134,19 +135,17 @@ 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;
     equals(other: ODataCollection<T, ODataModel<T>>): boolean;
     get [Symbol.toStringTag](): string;
-    [Symbol.iterator](): {
-        next(): IteratorResult<M>;
-    };
+    [Symbol.iterator](): Iterator<M, any, undefined>;
     filter(predicate: (value: M, index: number, array: M[]) => unknown, thisArg?: any): M[];
     map<U>(callbackfn: (value: M, index: number, array: M[]) => U, thisArg?: any): U[];
-    find(predicate: (value: M, index: number, obj: M[]) => unknown, thisArg?: any): M | undefined;
+    find(predicate: (value: M, index: number, obj: M[]) => unknown): M | undefined;
     reduce<U>(callbackfn: (previousValue: U, currentValue: M, currentIndex: number, array: M[]) => U, initialValue: U): U;
     first(): M | undefined;
     last(): M | undefined;
@@ -154,10 +153,9 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     prev(model: M): M | undefined;
     every(predicate: (m: M, index: number) => boolean): boolean;
     some(predicate: (m: M, index: number) => boolean): boolean;
-    contains(model: M): boolean;
+    includes(model: M, start?: number): boolean;
     indexOf(model: M): number;
     isEmpty(): boolean;
-    private _bisect;
     private _compare;
     _sortBy: {
         field: string | keyof T;

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;
@@ -30,7 +29,7 @@ export declare class ODataModel<T> {
     _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, }?: {
@@ -38,12 +37,12 @@ export declare class ODataModel<T> {
             ODataModel<any> | ODataCollection<any, ODataModel<any>>,
             ODataModelField<any> | null
         ];
-        resource?: ODataResource<T>;
+        resource?: ODataResource<T> | null;
         annots?: ODataEntityAnnotations<T>;
         reset?: boolean;
     });
-    resource(): ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T>;
-    pushResource(resource: ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T>): void;
+    resource(): ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T> | null;
+    pushResource(resource: ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T> | null): void;
     popResource(): {
         parent: [ODataModel<any> | ODataCollection<any, ODataModel<any>>, ODataModelField<any> | null] | null;
         resource: ODataResource<T> | null;
@@ -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';
@@ -87,12 +86,13 @@ export declare class ODataModel<T> {
         navigation?: boolean;
     }): boolean;
     defaults(): any;
-    toEntity({ client_id, include_navigation, include_concurrency, include_computed, include_key, include_non_field, changes_only, field_mapping, chain, }?: {
+    toEntity({ client_id, include_navigation, include_concurrency, include_computed, include_key, include_id, include_non_field, changes_only, field_mapping, chain, }?: {
         client_id?: boolean;
         include_navigation?: boolean;
         include_concurrency?: boolean;
         include_computed?: boolean;
         include_key?: boolean;
+        include_id?: boolean;
         include_non_field?: boolean;
         changes_only?: boolean;
         field_mapping?: boolean;
@@ -100,7 +100,7 @@ export declare class ODataModel<T> {
     }): T | {
         [name: string]: any;
     };
-    toJSON(): T | {
+    toJson(): T | {
         [name: string]: any;
     };
     set(path: string | string[], value: any, { type }?: {
@@ -158,13 +158,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,42 +18,66 @@ export declare enum ODataModelEventType {
     Attach = "attach"
 }
 export declare class ODataModelEvent<T> {
-    name: ODataModelEventType;
+    type: ODataModelEventType | string;
     value?: any;
     previous?: any;
     options?: any;
-    constructor(name: ODataModelEventType, { model, collection, previous, value, attr, options, }?: {
+    constructor(type: ODataModelEventType | string, { model, collection, previous, value, attr, options, bubbles, chain, }?: {
         model?: ODataModel<T>;
         collection?: ODataCollection<T, ODataModel<T>>;
         attr?: ODataModelAttribute<any> | number;
         previous?: any;
         value?: any;
         options?: any;
+        bubbles?: 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>;
+    bubbles: 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, bubbles, }?: {
+        collection?: ODataCollection<T, ODataModel<T>>;
+        attr?: ODataModelAttribute<any> | number;
+        previous?: any;
+        value?: any;
+        options?: any;
+        bubbles?: boolean;
+    }): void;
+}
+export declare const BUBBLES: (ODataModelEventType | string)[];
 export declare const INCLUDE_SHALLOW: {
     include_concurrency: boolean;
     include_computed: boolean;
     include_key: boolean;
+    include_id: boolean;
 };
 export declare const INCLUDE_DEEP: {
     include_concurrency: boolean;
     include_computed: boolean;
     include_key: boolean;
+    include_id: boolean;
     include_navigation: boolean;
     include_non_field: boolean;
 };
@@ -154,7 +178,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;
@@ -190,6 +214,7 @@ export declare class ODataModelOptions<T> {
     entitySet?: ODataEntitySet;
     parent?: ODataModelOptions<any>;
     children: ODataModelOptions<any>[];
+    events$: ODataModelEventEmitter<T>;
     constructor({ options, schema, }: {
         options: ModelOptions;
         schema: ODataStructuredType<T>;
@@ -225,16 +250,15 @@ export declare class ODataModelOptions<T> {
         ODataModel<any> | ODataCollection<any, ODataModel<any>>,
         ODataModelField<any> | null
     ][];
-    static resource<T>(child: ODataModel<T> | ODataCollection<T, ODataModel<T>>): ODataResource<T>;
-    collectionResourceFactory(query?: ODataQueryOptions<T>): ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | undefined;
-    modelResourceFactory(query?: ODataQueryOptions<T>): ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T> | undefined;
-    entityResource(self: ODataModel<T>): ODataResource<T>;
+    static resource<T>(child: ODataModel<T> | ODataCollection<T, ODataModel<T>>): ODataResource<T> | null;
+    collectionResourceFactory(query?: ODataQueryOptions<T>): ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null;
+    modelResourceFactory(query?: ODataQueryOptions<T>): ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T> | null;
     bind(self: ODataModel<T>, { parent, resource, annots, }?: {
         parent?: [
             ODataModel<any> | ODataCollection<any, ODataModel<any>>,
             ODataModelField<any> | null
         ];
-        resource?: ODataResource<T>;
+        resource?: ODataResource<T> | null;
         annots?: ODataEntityAnnotations<T>;
     }): void;
     query(self: ODataModel<T>, resource: ODataEntityResource<T> | ODataPropertyResource<T> | ODataNavigationPropertyResource<T> | ODataSingletonResource<T>, func: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): ODataModel<T>;
@@ -278,14 +302,15 @@ export declare class ODataModelOptions<T> {
         include_navigation?: boolean;
     }): boolean;
     hasKey(self: ODataModel<T>): boolean;
-    withResource<R, M extends ODataModel<T>>(self: M, resource: ODataEntityResource<T> | ODataPropertyResource<T> | ODataNavigationPropertyResource<T> | ODataSingletonResource<T>, ctx: (model: M) => R): R;
+    withResource<R, M extends ODataModel<T>>(self: M, resource: ODataEntityResource<T> | ODataPropertyResource<T> | ODataNavigationPropertyResource<T> | ODataSingletonResource<T> | null, ctx: (model: M) => R): R;
     asEntity<R, M extends ODataModel<T>>(self: M, ctx: (model: M) => R): R;
-    toEntity(self: ODataModel<T>, { client_id, include_navigation, include_concurrency, include_computed, include_key, include_non_field, changes_only, field_mapping, chain, }?: {
+    toEntity(self: ODataModel<T>, { client_id, include_navigation, include_concurrency, include_computed, include_key, include_id, include_non_field, changes_only, field_mapping, chain, }?: {
         client_id?: boolean;
         include_navigation?: boolean;
         include_concurrency?: boolean;
         include_computed?: boolean;
         include_key?: boolean;
+        include_id?: boolean;
         include_non_field?: boolean;
         changes_only?: boolean;
         field_mapping?: boolean;

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

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

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

@@ -1,4 +1,4 @@
-import { Parser } from '../../../types';
+import { Parser, ParserOptions } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Renderable } from './syntax';
 export declare abstract class Expression<T> implements Renderable {
@@ -7,16 +7,19 @@ export declare abstract class Expression<T> implements Renderable {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    abstract render({ aliases, escape, prefix, parser, }: {
+    abstract render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     abstract clone(): Expression<T>;
     children(): Renderable[];
     length(): number;
-    toJSON(): {
+    toJson(): {
+        $type: string;
         children: any[];
     };
+    resolve(parser: any): any;
 }

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

@@ -1,4 +1,4 @@
-import { Parser } from '../../../types';
+import { Parser, ParserOptions } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
@@ -12,12 +12,23 @@ export declare class ComputeExpression<T> extends Expression<T> {
         children?: Renderable[];
         names?: string[];
     });
+    get [Symbol.toStringTag](): string;
     static compute<T>(opts: (builder: ComputeExpressionBuilder<T>, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
-    render({ aliases, escape, prefix, parser, }?: {
+    toJson(): {
+        $type: string;
+        children: any[];
+    } & {
+        names: string[];
+    };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): ComputeExpression<T>;
+    render({ aliases, escape, prefix, parser, options, }?: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): ComputeExpression<T>;
     private _add;

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

@@ -1,4 +1,4 @@
-import { Parser } from '../../../types';
+import { Parser, ParserOptions } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { FilterExpression, FilterExpressionBuilder } from './filter';
@@ -10,17 +10,19 @@ export declare class CountField<T> implements Renderable {
         [name: string]: any;
     });
     get [Symbol.toStringTag](): string;
-    toJSON(): {
+    toJson(): {
         field: any;
     };
-    render({ aliases, escape, prefix, parser, }: {
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     filter(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): any;
     clone(): CountField<T>;
+    resolve(parser: any): any;
     private option;
 }
 export type CountExpressionBuilder<T> = {
@@ -31,13 +33,22 @@ export declare class CountExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
+    get [Symbol.toStringTag](): string;
     static count<T>(opts: (builder: CountExpressionBuilder<T>, current?: CountExpression<T>) => CountExpression<T>, current?: CountExpression<T>): CountExpression<T>;
     private _add;
-    render({ aliases, escape, prefix, parser, }?: {
+    toJson(): {
+        $type: string;
+        children: any[];
+    };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): CountExpression<T>;
+    render({ aliases, escape, prefix, parser, options, }?: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): CountExpression<T>;
     field<F>(field: F[], opts?: (e: {

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

@@ -1,4 +1,4 @@
-import { Parser } from '../../../types';
+import { Parser, ParserOptions } from '../../../types';
 import type { QueryCustomType, Unpacked } from '../builder';
 import { Expression } from './base';
 import { FilterExpression, FilterExpressionBuilder } from './filter';
@@ -13,16 +13,18 @@ export declare class ExpandField<T> implements Renderable {
         [name: string]: any;
     });
     get [Symbol.toStringTag](): string;
-    toJSON(): {
+    toJson(): {
         field: any;
     };
-    render({ aliases, escape, prefix, parser, }: {
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): ExpandField<T>;
+    resolve(parser: any): any;
     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>;
@@ -42,12 +44,21 @@ export declare class ExpandExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
+    get [Symbol.toStringTag](): string;
     static expand<T>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
-    render({ aliases, escape, prefix, parser, }?: {
+    toJson(): {
+        $type: string;
+        children: any[];
+    };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): ExpandExpression<T>;
+    render({ aliases, escape, prefix, parser, options, }?: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): ExpandExpression<T>;
     private _add;