angular-odata 0.125.0 → 0.127.0

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

@@ -1,9 +1,9 @@
-import { Parser } from '../../../types';
+import { Parser, ParserOptions } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
 export type ComputeExpressionBuilder<T> = {
-    t: Required<Readonly<T>>;
+    t: Required<T>;
     e: () => ComputeExpression<T>;
 };
 export declare class ComputeExpression<T> extends Expression<T> {
@@ -12,12 +12,23 @@ export declare class ComputeExpression<T> extends Expression<T> {
         children?: Renderable[];
         names?: string[];
     });
-    static compute<T>(opts: (builder: ComputeExpressionBuilder<T>, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
-    render({ aliases, escape, prefix, parser, }?: {
+    get [Symbol.toStringTag](): string;
+    static factory<T>(opts: (builder: ComputeExpressionBuilder<T>, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
+    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,34 +10,45 @@ 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> = {
-    t: Readonly<Required<T>>;
+    t: Required<T>;
     e: () => CountExpression<T>;
 };
 export declare class CountExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    static count<T>(opts: (builder: CountExpressionBuilder<T>, current?: CountExpression<T>) => CountExpression<T>, current?: CountExpression<T>): CountExpression<T>;
+    get [Symbol.toStringTag](): string;
+    static factory<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,21 +13,23 @@ 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>;
-    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>;
+    resolve(parser: any): any;
+    select(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
+    expand(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>): ExpandExpression<T>;
+    filter(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
+    search(opts: (builder: SearchExpressionBuilder<T>) => SearchExpression<T>): SearchExpression<T>;
+    orderBy(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";
@@ -35,19 +37,28 @@ export declare class ExpandField<T> implements Renderable {
     private option;
 }
 export type ExpandExpressionBuilder<T> = {
-    t: Readonly<Required<T>>;
+    t: Required<T>;
     e: () => ExpandExpression<T>;
 };
 export declare class ExpandExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    static expand<T>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
-    render({ aliases, escape, prefix, parser, }?: {
+    get [Symbol.toStringTag](): string;
+    static factory<T>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
+    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;

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

@@ -1,11 +1,11 @@
-import { Parser } from '../../../types';
+import { Parser, ParserOptions } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { CountExpression, CountField } from './count';
 import { Normalize, ODataFunctions, ODataOperators, Renderable } from './syntax';
 export type FilterConnector = 'and' | 'or';
 export type FilterExpressionBuilder<T> = {
-    t: Readonly<Required<T>>;
+    t: Required<T>;
     e: (connector?: FilterConnector) => FilterExpression<T>;
     o: ODataOperators<T>;
     f: ODataFunctions<T>;
@@ -18,19 +18,26 @@ export declare class FilterExpression<F> extends Expression<F> {
         connector?: FilterConnector;
         negated?: boolean;
     });
-    static filter<T>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
-    toJSON(): {
+    get [Symbol.toStringTag](): string;
+    static factory<T>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
+    toJson(): {
+        $type: string;
         children: any[];
+    } & {
         connector: FilterConnector;
         negated: boolean;
     };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): FilterExpression<T>;
     connector(): FilterConnector;
     negated(): boolean;
-    render({ aliases, escape, prefix, parser, }?: {
+    render({ aliases, escape, prefix, parser, options, }?: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<any>;
+        options?: ParserOptions;
     }): string;
     clone(): FilterExpression<F>;
     private _add;
@@ -51,10 +58,14 @@ export declare class FilterExpression<F> extends Expression<F> {
     any<N>(left: N[], opts?: (e: {
         e: (connector?: FilterConnector) => FilterExpression<N>;
         t: N;
+        o: ODataOperators<N>;
+        f: ODataFunctions<N>;
     }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
-    all<N>(left: N[], opts: (e: {
+    all<N>(left: N[], opts?: (e: {
         t: N;
         e: (connector?: FilterConnector) => FilterExpression<N>;
+        o: ODataOperators<N>;
+        f: ODataFunctions<N>;
     }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
     count<N>(left: N[], opts?: (e: {
         t: N;

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

@@ -1,5 +1,6 @@
 export * from './base';
 export * from './compute';
+export * from './apply';
 export * from './filter';
 export * from './orderby';
 export * from './search';

package/lib/resources/query/expressions/orderby.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 { Renderable } from './syntax';
@@ -7,33 +7,45 @@ export declare class OrderByField implements Renderable {
     protected order: 'asc' | 'desc';
     constructor(field: Renderable, order: 'asc' | 'desc');
     get [Symbol.toStringTag](): string;
-    toJSON(): {
+    toJson(): {
+        $type: string;
         field: any;
         order: "asc" | "desc";
     };
-    render({ aliases, escape, prefix, parser, }: {
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<any>;
+        options?: ParserOptions;
     }): string;
     clone(): OrderByField;
+    resolve(parser: any): any;
 }
 export type OrderByExpressionBuilder<T> = {
-    t: Readonly<Required<T>>;
+    t: Required<T>;
     e: () => OrderByExpression<T>;
 };
 export declare class OrderByExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    static orderBy<T>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
+    get [Symbol.toStringTag](): string;
+    static factory<T>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
     private _add;
-    render({ aliases, escape, prefix, parser, }?: {
+    toJson(): {
+        $type: string;
+        children: any[];
+    };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): OrderByExpression<T>;
+    render({ aliases, escape, prefix, parser, options, }?: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): OrderByExpression<T>;
     ascending(field: any): OrderByExpression<T>;

package/lib/resources/query/expressions/search.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 { Renderable } from './syntax';
@@ -7,17 +7,19 @@ export declare class SearchTerm implements Renderable {
     protected value: string;
     constructor(value: string);
     get [Symbol.toStringTag](): string;
-    toJSON(): {
+    toJson(): {
         $type: string;
         value: string;
     };
-    render({ aliases, escape, prefix, parser, }: {
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<any>;
+        options?: ParserOptions;
     }): string;
     clone(): SearchTerm;
+    resolve(parser: any): any;
 }
 export type SearchExpressionBuilder<T> = {
     e: (connector?: SearchConnector) => SearchExpression<T>;
@@ -30,20 +32,27 @@ export declare class SearchExpression<T> extends Expression<T> {
         connector?: SearchConnector;
         negated?: boolean;
     });
-    static search<T>(opts: (builder: SearchExpressionBuilder<T>, current?: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
+    get [Symbol.toStringTag](): string;
+    static factory<T>(opts: (builder: SearchExpressionBuilder<T>, current?: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
     private _add;
-    render({ aliases, escape, prefix, parser, }?: {
+    render({ aliases, escape, prefix, parser, options, }?: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): SearchExpression<T>;
-    toJSON(): {
+    toJson(): {
+        $type: string;
         children: any[];
+    } & {
         connector: SearchConnector;
         negated: boolean;
     };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): SearchExpression<T>;
     connector(): SearchConnector;
     negated(): boolean;
     or(exp: SearchExpression<T>): SearchExpression<T>;

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

@@ -1,21 +1,30 @@
-import { Parser } from '../../../types';
+import { Parser, ParserOptions } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
 export type SelectExpressionBuilder<T> = {
-    t: Readonly<Required<T>>;
+    t: Required<T>;
     e: () => SelectExpression<T>;
 };
 export declare class SelectExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    static select<T>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
-    render({ aliases, escape, prefix, parser, }?: {
+    get [Symbol.toStringTag](): string;
+    static factory<T>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
+    toJson(): {
+        $type: string;
+        children: any[];
+    };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): SelectExpression<T>;
+    render({ aliases, escape, prefix, parser, options, }?: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): SelectExpression<T>;
     private _add;

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

@@ -1,27 +1,30 @@
-import { Parser } from '../../../types';
+import { Parser, ParserOptions } from '../../../types';
 import type { QueryCustomType } from '../builder';
 export type Normalize = 'all' | 'right' | 'left' | 'none';
 export interface Renderable {
-    render({ aliases, escape, prefix, parser, }: {
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<any>;
+        options?: ParserOptions;
     }): string;
-    toString(): string;
-    toJSON(): any;
+    toJson(): any;
     clone(): any;
+    resolve(parser: any): any;
 }
-export declare const FieldFactory: <T extends object>(names?: string[]) => any;
-export declare function render(value: any, { aliases, normalize, escape, prefix, parser, }?: {
+export declare const FieldFactory: <T extends object>(names?: (string | Renderable)[]) => any;
+export declare const RenderableFactory: (value: any) => Renderable;
+export declare function render(value: any, { aliases, normalize, escape, prefix, parser, options, }?: {
     aliases?: QueryCustomType[];
     normalize?: boolean;
     escape?: boolean;
     prefix?: string;
     parser?: Parser<any>;
+    options?: ParserOptions;
 }): string | number | boolean | null;
 export declare function resolve(values: any, parser?: Parser<any>): any;
-export declare function encode(values: any, parser?: Parser<any>): any;
+export declare function encode(values: any, parser?: Parser<any>, options?: ParserOptions): any;
 export declare class Function<T> implements Renderable {
     protected name: string;
     protected values: any[];
@@ -29,19 +32,24 @@ export declare class Function<T> implements Renderable {
     protected escape: boolean;
     constructor(name: string, values: any[], normalize: Normalize, escape?: boolean);
     get [Symbol.toStringTag](): string;
-    toJSON(): {
+    toJson(): {
         $type: string;
         name: string;
         values: any[];
         normalize: Normalize;
     };
-    render({ aliases, escape, prefix, parser, }: {
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): Function<T>;
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): Function<T>;
+    resolve(parser: any): any;
 }
 export declare class StringAndCollectionFunctions<T> {
     concat(left: any, right: any, normalize?: Normalize): Function<T>;
@@ -84,8 +92,8 @@ export declare class ArithmeticFunctions<T> {
     round(left: T | string, normalize?: Normalize): Function<T>;
 }
 export declare class TypeFunctions<T> {
-    cast(left: T | string, right?: string, normalize?: Normalize): Function<T>;
-    isof(left: T | string, right?: string, normalize?: Normalize): Function<T>;
+    cast<N>(left: T | string, type?: string): N;
+    isof(left: T | string, type?: string): Type<T>;
 }
 export declare class GeoFunctions<T> {
     geoDistance(left: T, right: string, normalize?: Normalize): Function<T>;
@@ -101,19 +109,24 @@ export declare class Operator<T> implements Renderable {
     protected normalize: Normalize;
     constructor(op: string, values: any[], normalize: Normalize);
     get [Symbol.toStringTag](): string;
-    toJSON(): {
+    toJson(): {
         $type: string;
         op: string;
         values: any[];
         normalize: Normalize;
     };
-    render({ aliases, escape, prefix, parser, }: {
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): Operator<T>;
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): Operator<unknown>;
+    resolve(parser: any): any;
 }
 export declare class LogicalOperators<T> {
     eq(left: any, right: any, normalize?: Normalize): Operator<unknown>;
@@ -138,17 +151,113 @@ export declare class Grouping<T> implements Renderable {
     protected group: Renderable;
     constructor(group: Renderable);
     get [Symbol.toStringTag](): string;
-    toJSON(): {
+    toJson(): {
         $type: string;
         group: any;
     };
-    render({ aliases, escape, prefix, parser, }: {
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): Grouping<T>;
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): Grouping<unknown>;
+    resolve(parser: any): any;
+}
+export declare class GroupingOperators<T> {
+    group(value: any): Grouping<T>;
+    rollup(...values: any): Function<T>;
+}
+export type AggregateMethod = 'sum' | 'min' | 'max' | 'average' | 'countdistinct';
+export declare class Aggregate<T> implements Renderable {
+    protected value: Renderable;
+    protected method: AggregateMethod;
+    protected alias: string;
+    constructor(value: Renderable, method: AggregateMethod, alias: string);
+    get [Symbol.toStringTag](): string;
+    toJson(): {
+        $type: string;
+        value: any;
+        method: AggregateMethod;
+        alias: string;
+    };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): Aggregate<T>;
+    render({ aliases, escape, prefix, parser, options, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+        parser?: Parser<T>;
+        options?: ParserOptions;
+    }): string;
+    clone(): Aggregate<unknown>;
+    resolve(parser: any): any;
+}
+export declare class GroupBy<T> implements Renderable {
+    protected properties: Renderable[];
+    protected transformations?: Renderable | undefined;
+    constructor(properties: Renderable[], transformations?: Renderable | undefined);
+    get [Symbol.toStringTag](): string;
+    toJson(): {
+        $type: string;
+        properties: any[];
+        transformations: any;
+    };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): GroupBy<T>;
+    render({ aliases, escape, prefix, parser, options, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+        parser?: Parser<T>;
+        options?: ParserOptions;
+    }): string;
+    clone(): GroupBy<unknown>;
+    resolve(parser: any): any;
+}
+export declare class Transformations<T> {
+    aggregate(value: Renderable, method: AggregateMethod, alias: string): Aggregate<T>;
+    groupby(properties: Renderable[], options?: Renderable): GroupBy<T>;
+    topCount(value: number, field: Renderable, normalize?: Normalize): Function<T>;
+    topSum(value: number, field: Renderable, normalize?: Normalize): Function<T>;
+    topPercent(value: number, field: Renderable, normalize?: Normalize): Function<T>;
+    bottomCount(value: number, field: Renderable, normalize?: Normalize): Function<T>;
+    bottomSum(value: number, field: Renderable, normalize?: Normalize): Function<T>;
+    bottomPercent(value: number, field: Renderable, normalize?: Normalize): Function<T>;
+    identity(): Function<T>;
+    search(left: any, normalize?: Normalize): Function<T>;
+    filter(left: any, normalize?: Normalize): Function<T>;
+}
+export declare class Type<T> implements Renderable {
+    protected name: string;
+    protected type: string;
+    protected value?: any;
+    constructor(name: string, type: string, value?: any);
+    get [Symbol.toStringTag](): string;
+    toJson(): {
+        $type: string;
+        name: string;
+        type: string;
+        value: any;
+    };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): Type<T>;
+    render({ aliases, escape, prefix, parser, options, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+        parser?: Parser<T>;
+        options?: ParserOptions;
+    }): string;
+    clone(): Type<unknown>;
+    resolve(parser: any): any;
 }
 export declare class Lambda<T> implements Renderable {
     protected op: string;
@@ -156,19 +265,24 @@ export declare class Lambda<T> implements Renderable {
     protected alias?: string | undefined;
     constructor(op: string, values: any[], alias?: string | undefined);
     get [Symbol.toStringTag](): string;
-    toJSON(): {
+    toJson(): {
         $type: string;
         op: string;
         values: any[];
         alias: string | undefined;
     };
-    render({ aliases, escape, prefix, parser, }: {
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): Lambda<T>;
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): Lambda<unknown>;
+    resolve(parser: any): any;
 }
 export declare class LambdaOperators<T> {
     any(left: T, right: any, alias?: string): Lambda<unknown>;
@@ -176,7 +290,7 @@ export declare class LambdaOperators<T> {
 }
 export declare class ODataOperators<T> {
 }
-export interface ODataOperators<T> extends LogicalOperators<T>, ArithmeticOperators<T>, LambdaOperators<T> {
+export interface ODataOperators<T> extends LogicalOperators<T>, ArithmeticOperators<T>, GroupingOperators<T>, LambdaOperators<T> {
 }
 export declare const operators: ODataOperators<any>;
 export declare class ODataFunctions<T> {
@@ -184,8 +298,13 @@ export declare class ODataFunctions<T> {
 export interface ODataFunctions<T> extends StringAndCollectionFunctions<T>, CollectionFunctions<T>, StringFunctions<T>, DateAndTimeFunctions<T>, ArithmeticFunctions<T>, TypeFunctions<T>, GeoFunctions<T>, ConditionalFunctions<T> {
 }
 export declare const functions: ODataFunctions<any>;
+export declare class ODataTransformations<T> {
+}
+export interface ODataTransformations<T> extends Transformations<T> {
+}
+export declare const transformations: ODataTransformations<any>;
 export declare class ODataSyntax<T> {
 }
-export interface ODataSyntax<T> extends ODataOperators<T>, ODataFunctions<T> {
+export interface ODataSyntax<T> extends ODataOperators<T>, ODataFunctions<T>, ODataTransformations<T> {
 }
 export declare const syntax: ODataSyntax<any>;