angular-odata 0.126.0 → 0.128.0

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

@@ -12,7 +12,7 @@ export declare enum StandardAggregateMethods {
     average = "average",
     countdistinct = "countdistinct"
 }
-export type Aggregate = string | {
+export type AggregateType = string | {
     [propertyName: string]: {
         with: StandardAggregateMethods;
         as: string;
@@ -41,11 +41,11 @@ export type ExpandOptions<T> = {
     expand?: Expand<T>;
 };
 export type Transform<T> = {
-    aggregate?: Aggregate | Array<Aggregate>;
+    aggregate?: AggregateType | Array<AggregateType>;
     filter?: Filter<T>;
-    groupBy?: GroupBy<T>;
+    groupBy?: GroupByType<T>;
 };
-export type GroupBy<T> = {
+export type GroupByType<T> = {
     properties: Array<keyof T>;
     transform?: Transform<T>;
 };
@@ -69,6 +69,7 @@ export declare const isQueryCustomType: (value: any) => boolean;
 export declare const isRawType: (value: any) => boolean;
 export type QueryOptions<T> = ExpandOptions<T> & {
     search: string;
+    apply: string;
     transform: {
         [name: string]: any;
     } | {
@@ -92,7 +93,7 @@ export type QueryOptions<T> = ExpandOptions<T> & {
 };
 export declare const ITEM_ROOT = "";
 export default function <T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): string;
-export declare function buildPathAndQuery<T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): [string, {
+export declare function buildPathAndQuery<T>({ select, search, skiptoken, format, top, skip, filter, apply, transform, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): [string, {
     [name: string]: any;
 }];
 export declare function normalizeValue(value: Value, { aliases, escape, }?: {

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

@@ -0,0 +1,125 @@
+import { Parser, ParserOptions } from '../../../types';
+import { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { FilterConnector, FilterExpression } from './filter';
+import { SearchConnector, SearchExpression } from './search';
+import { ODataFunctions, ODataOperators, Renderable, AggregateMethod } from './syntax';
+export declare class GroupByTransformations<T> extends Expression<T> {
+    protected methods: (AggregateMethod | string)[];
+    protected aliases: string[];
+    constructor({ children, methods, aliases, }?: {
+        children?: Renderable[];
+        methods?: (AggregateMethod | string)[];
+        aliases?: string[];
+    });
+    get [Symbol.toStringTag](): string;
+    toJson(): {
+        $type: string;
+        children: any[];
+    } & {
+        methods: string[];
+        aliases: string[];
+    };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): GroupByTransformations<T>;
+    render({ aliases, escape, prefix, parser, options, }?: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+        parser?: Parser<T>;
+        options?: ParserOptions;
+    }): string;
+    clone(): GroupByTransformations<T>;
+    private _add;
+    aggregate(value: any, method: AggregateMethod | string, alias: string): GroupByTransformations<T>;
+    sum(value: any, alias: string): GroupByTransformations<T>;
+    min(value: any, alias: string): GroupByTransformations<T>;
+    max(value: any, alias: string): GroupByTransformations<T>;
+    average(value: any, alias: string): GroupByTransformations<T>;
+    countdistinct(value: any, alias: string): GroupByTransformations<T>;
+    count(alias: string): GroupByTransformations<T>;
+}
+export type ApplyExpressionBuilder<T> = {
+    t: Required<T>;
+    e: () => ApplyExpression<T>;
+};
+export declare class ApplyExpression<T> extends Expression<T> {
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    get [Symbol.toStringTag](): string;
+    static factory<T>(opts: (builder: ApplyExpressionBuilder<T>, current?: ApplyExpression<T>) => ApplyExpression<T>, current?: ApplyExpression<T>): ApplyExpression<T>;
+    toJson(): {
+        $type: string;
+        children: any[];
+    };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): ApplyExpression<T>;
+    render({ aliases, escape, prefix, parser, options, }?: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+        parser?: Parser<T>;
+        options?: ParserOptions;
+    }): string;
+    clone(): ApplyExpression<T>;
+    private _add;
+    aggregate(value: any, method: AggregateMethod, alias: string): ApplyExpression<T>;
+    topCount(opts: (e: {
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Renderable): ApplyExpression<T>;
+    topSum(opts: (e: {
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Renderable): ApplyExpression<T>;
+    topPercent(opts: (e: {
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Renderable): ApplyExpression<T>;
+    bottomCount(opts: (e: {
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Renderable): ApplyExpression<T>;
+    bottomSum(opts: (e: {
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Renderable): ApplyExpression<T>;
+    bottomPercent(opts: (e: {
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Renderable): ApplyExpression<T>;
+    identity(opts: (e: {
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Renderable): ApplyExpression<T>;
+    concat(opts: (e: {
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Renderable): ApplyExpression<T>;
+    groupBy(props: (e: {
+        rollup: (f: any) => any;
+    }) => any | any[], opts?: (e: GroupByTransformations<T>) => GroupByTransformations<T>): ApplyExpression<T>;
+    filter(opts: (e: {
+        t: T;
+        e: (connector?: FilterConnector) => FilterExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => FilterExpression<T>): ApplyExpression<T>;
+    expand(opts: (e: {
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Renderable): ApplyExpression<T>;
+    search(opts: (e: {
+        t: T;
+        e: (connector?: SearchConnector) => SearchExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => SearchExpression<T>): ApplyExpression<T>;
+    compute(opts: (e: {
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Renderable): ApplyExpression<T>;
+}

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

@@ -1,5 +1,5 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { QueryCustomType } from '../builder';
 import { Renderable } from './syntax';
 export declare abstract class Expression<T> implements Renderable {
     protected _children: Renderable[];

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

@@ -1,19 +1,19 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { 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> {
-    names: string[];
+    protected names: string[];
     constructor({ children, names, }?: {
         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>;
+    static factory<T>(opts: (builder: ComputeExpressionBuilder<T>, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
     toJson(): {
         $type: string;
         children: any[];

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

@@ -1,5 +1,5 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { FilterExpression, FilterExpressionBuilder } from './filter';
 import { Renderable } from './syntax';
@@ -26,7 +26,7 @@ export declare class CountField<T> implements Renderable {
     private option;
 }
 export type CountExpressionBuilder<T> = {
-    t: Readonly<Required<T>>;
+    t: Required<T>;
     e: () => CountExpression<T>;
 };
 export declare class CountExpression<T> extends Expression<T> {
@@ -34,7 +34,7 @@ export declare class CountExpression<T> extends Expression<T> {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    static count<T>(opts: (builder: CountExpressionBuilder<T>, current?: CountExpression<T>) => CountExpression<T>, current?: CountExpression<T>): CountExpression<T>;
+    static factory<T>(opts: (builder: CountExpressionBuilder<T>, current?: CountExpression<T>) => CountExpression<T>, current?: CountExpression<T>): CountExpression<T>;
     private _add;
     toJson(): {
         $type: string;

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

@@ -1,5 +1,5 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType, Unpacked } from '../builder';
+import { QueryCustomType, Unpacked } from '../builder';
 import { Expression } from './base';
 import { FilterExpression, FilterExpressionBuilder } from './filter';
 import { OrderByExpression, OrderByExpressionBuilder } from './orderby';
@@ -25,11 +25,11 @@ export declare class ExpandField<T> implements Renderable {
     }): 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>;
-    search<T>(opts: (builder: SearchExpressionBuilder<T>) => SearchExpression<T>): SearchExpression<T>;
-    orderBy<T>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
+    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";
@@ -37,7 +37,7 @@ 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> {
@@ -45,7 +45,7 @@ export declare class ExpandExpression<T> extends Expression<T> {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    static expand<T>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
+    static factory<T>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
     toJson(): {
         $type: string;
         children: any[];

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

@@ -1,11 +1,11 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { 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>;
@@ -19,7 +19,7 @@ export declare class FilterExpression<F> extends Expression<F> {
         negated?: boolean;
     });
     get [Symbol.toStringTag](): string;
-    static filter<T>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
+    static factory<T>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
     toJson(): {
         $type: string;
         children: any[];

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,16 +1,17 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
+export type OrderAttribute = 'asc' | 'desc';
 export declare class OrderByField implements Renderable {
     protected field: Renderable;
-    protected order: 'asc' | 'desc';
-    constructor(field: Renderable, order: 'asc' | 'desc');
+    protected order: OrderAttribute;
+    constructor(field: Renderable, order: OrderAttribute);
     get [Symbol.toStringTag](): string;
     toJson(): {
         $type: string;
         field: any;
-        order: "asc" | "desc";
+        order: OrderAttribute;
     };
     render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
@@ -23,7 +24,7 @@ export declare class OrderByField implements Renderable {
     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> {
@@ -31,7 +32,7 @@ export declare class OrderByExpression<T> extends Expression<T> {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    static orderBy<T>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
+    static factory<T>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
     private _add;
     toJson(): {
         $type: string;

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

@@ -1,5 +1,5 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
 export type SearchConnector = 'AND' | 'OR';
@@ -33,7 +33,7 @@ export declare class SearchExpression<T> extends Expression<T> {
         negated?: boolean;
     });
     get [Symbol.toStringTag](): string;
-    static search<T>(opts: (builder: SearchExpressionBuilder<T>, current?: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
+    static factory<T>(opts: (builder: SearchExpressionBuilder<T>, current?: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
     private _add;
     render({ aliases, escape, prefix, parser, options, }?: {
         aliases?: QueryCustomType[];

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

@@ -1,9 +1,9 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { 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> {
@@ -11,7 +11,7 @@ export declare class SelectExpression<T> extends Expression<T> {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    static select<T>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
+    static factory<T>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
     toJson(): {
         $type: string;
         children: any[];
@@ -29,4 +29,5 @@ export declare class SelectExpression<T> extends Expression<T> {
     clone(): SelectExpression<T>;
     private _add;
     field(field: any): SelectExpression<T>;
+    fields(...fields: any[]): SelectExpression<T>;
 }

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

@@ -1,5 +1,5 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { QueryCustomType } from '../builder';
 export type Normalize = 'all' | 'right' | 'left' | 'none';
 export interface Renderable {
     render({ aliases, escape, prefix, parser, options, }: {
@@ -9,7 +9,6 @@ export interface Renderable {
         parser?: Parser<any>;
         options?: ParserOptions;
     }): string;
-    toString(): string;
     toJson(): any;
     clone(): any;
     resolve(parser: any): any;
@@ -169,6 +168,75 @@ export declare class Grouping<T> implements Renderable {
     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(value: any, normalize?: Normalize): Function<T>;
+    filter(value: any, normalize?: Normalize): Function<T>;
+    skip(value: number, normalize?: Normalize): Function<T>;
+    top(value: number, normalize?: Normalize): Function<T>;
+    orderby(value: any, normalize?: Normalize): Function<T>;
+}
 export declare class Type<T> implements Renderable {
     protected name: string;
     protected type: string;
@@ -225,7 +293,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> {
@@ -233,8 +301,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>;

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

@@ -1,7 +1,7 @@
-import { QueryOption } from '../../types';
+import { Parser, QueryOption } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
-import { ComputeExpression, ComputeExpressionBuilder, FilterExpression, FilterExpressionBuilder, OrderByExpression, OrderByExpressionBuilder, SearchExpression, SearchExpressionBuilder, ExpandExpression, ExpandExpressionBuilder, SelectExpression, SelectExpressionBuilder } from './expressions';
-import type { ODataQueryArguments, ODataQueryOptions } from './options';
+import { ComputeExpression, ComputeExpressionBuilder, FilterExpression, FilterExpressionBuilder, OrderByExpression, OrderByExpressionBuilder, SearchExpression, SearchExpressionBuilder, ExpandExpression, ExpandExpressionBuilder, SelectExpression, SelectExpressionBuilder, ApplyExpression, ApplyExpressionBuilder } from './expressions';
+import { ODataQueryArguments, ODataQueryOptions } from './options';
 export declare class ODataQueryOptionHandler<T> {
     private o;
     private n;
@@ -85,6 +85,10 @@ export declare class ODataQueryOptionHandler<T> {
      * Clear the managed odata query option.
      */
     clear(): void;
+    toString({ escape, parser, }?: {
+        escape?: boolean;
+        parser?: Parser<T>;
+    }): string;
 }
 export declare class ODataQueryOptionsHandler<T> {
     protected options: ODataQueryOptions<T>;
@@ -146,6 +150,15 @@ export declare class ODataQueryOptionsHandler<T> {
     compute(opts: (builder: ComputeExpressionBuilder<T>, current?: ComputeExpression<T>) => ComputeExpression<T>): ComputeExpression<T>;
     compute(opts: string): ODataQueryOptionHandler<T>;
     compute(): ODataQueryOptionHandler<T>;
+    /**
+     * Build and return a handler for modifying the $apply option.
+     * If opts is given then set te value as new value for $compute.
+     * @link http://docs.oasis-open.org/odata/odata-data-aggregation-ext/v4.0/cs02/odata-data-aggregation-ext-v4.0-cs02.html
+     * @param opts string value or builder function for ApplyExpression<T>
+     */
+    apply(opts: (builder: ApplyExpressionBuilder<T>, current?: ApplyExpression<T>) => ApplyExpression<T>): ApplyExpression<T>;
+    apply(opts: string): ODataQueryOptionHandler<T>;
+    apply(): ODataQueryOptionHandler<T>;
     /**
      * Build and return a handler for modifying the $format option.
      * If opts is given then set te value as new value for $format.
@@ -206,6 +219,8 @@ export declare class ODataQueryOptionsHandler<T> {
      */
     skiptoken(opts: string): ODataQueryOptionHandler<T>;
     skiptoken(): ODataQueryOptionHandler<T>;
+    remove(...keys: QueryOption[]): void;
+    keep(...keys: QueryOption[]): void;
     /**
      * Shortcut for set $top, $skip, $skiptoken.
      * @param param0 skip or top or skiptoken
@@ -218,18 +233,26 @@ export declare class ODataQueryOptionsHandler<T> {
     /**
      * Shortcut for clear pagination by unset $top, $skip, $skiptoken.
      */
-    clearPaging(): void;
+    removePaging(): void;
     /**
      * Shortcut for clear query.
      */
     clear(): void;
     /**
-     * Retrun the query.
+     * Store the query options from the current query.
      */
-    query(): ODataQueryArguments<T>;
+    store(): ODataQueryArguments<T>;
     /**
-     * Apply the given query options to the current query.
-     * @param query The query to be applied.
+     * Restore the given query options to the current query.
+     * @param options The query to be applied.
      */
-    apply(query: ODataQueryArguments<T>): void;
+    restore(options: ODataQueryArguments<T>): void;
+    toJson(): {};
+    fromJson(json: {
+        [name: string]: any;
+    }): void;
+    toString({ escape, parser, }?: {
+        escape?: boolean;
+        parser?: Parser<T>;
+    }): string;
 }

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

@@ -1,6 +1,7 @@
 import { Parser, ParserOptions, QueryOption } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
 import { ComputeExpression, Expression, FilterExpression, OrderByExpression, SearchExpression } from './expressions';
+import { ApplyExpression } from './expressions/apply';
 import { ExpandExpression } from './expressions/expand';
 import { SelectExpression } from './expressions/select';
 import { ODataQueryOptionHandler } from './handlers';
@@ -8,6 +9,7 @@ export type ODataQueryArguments<T> = {
     [QueryOption.select]?: Select<T> | SelectExpression<T> | null;
     [QueryOption.expand]?: Expand<T> | ExpandExpression<T> | null;
     [QueryOption.compute]?: string | ComputeExpression<T> | null;
+    [QueryOption.apply]?: string | ApplyExpression<T> | null;
     [QueryOption.filter]?: Filter<T> | FilterExpression<T> | null;
     [QueryOption.search]?: string | SearchExpression<T> | null;
     [QueryOption.transform]?: Transform<T> | null;
@@ -19,26 +21,34 @@ export type ODataQueryArguments<T> = {
     [QueryOption.levels]?: number | 'max' | null;
     [QueryOption.count]?: boolean | null;
 };
+export declare const pathAndParamsFromQueryOptions: <T>(values: Map<QueryOption, any>, { escape, parser, options, }?: {
+    escape?: boolean | undefined;
+    parser?: Parser<T> | undefined;
+    options?: ParserOptions | undefined;
+}) => [string, {
+    [name: string]: any;
+}];
 export declare class ODataQueryOptions<T> {
-    values: Map<QueryOption, any>;
-    constructor(values?: Map<QueryOption, any> | {
-        [name: string]: any;
-    });
+    private _values;
+    constructor(values?: Map<QueryOption, any>);
     pathAndParams({ escape, parser, options, }?: {
         escape?: boolean;
         parser?: Parser<T>;
         options?: ParserOptions;
-    }): [
-        string,
-        {
-            [name: string]: any;
-        }
-    ];
+    }): [string, {
+        [name: string]: any;
+    }];
     toString({ escape, parser, }?: {
         escape?: boolean;
         parser?: Parser<T>;
     }): string;
     toJson(): {};
+    fromJson<T>(json: {
+        [name: string]: any;
+    }): this;
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): ODataQueryOptions<T>;
     toQueryArguments(): ODataQueryArguments<T>;
     clone<O>(): ODataQueryOptions<O>;
     expression(key: QueryOption, exp?: Expression<T>): any;