angular-odata 0.95.0 → 0.99.5

package/lib/models/collection.d.ts

@@ -110,8 +110,10 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     [Symbol.iterator](): {
         next(): IteratorResult<M>;
     };
-    filter(predicate: (m: M, index: number) => boolean): M[];
-    find(predicate: (m: M, index: number) => boolean): M | 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;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: M, currentIndex: number, array: M[]) => U, initialValue: U): U;
     first(): M | undefined;
     last(): M | undefined;
     next(model: M): M | undefined;

package/lib/models/model.d.ts

@@ -45,7 +45,7 @@ export declare class ODataModel<T> {
     resource(): ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T>;
     navigationProperty<N>(name: keyof T | string): ODataNavigationPropertyResource<N>;
     property<N>(name: string): ODataPropertyResource<N>;
-    attach(resource: ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T>): void;
+    attach<R>(resource: ODataEntityResource<R> | ODataNavigationPropertyResource<R> | ODataPropertyResource<R> | ODataSingletonResource<R>): void;
     schema(): ODataStructuredType<T>;
     annots(): ODataEntityAnnotations;
     key({ field_mapping, resolve, }?: {

package/lib/models/options.d.ts

@@ -7,13 +7,6 @@ import type { ODataModel } from './model';
 export declare type ODataModelEventType = 'change' | 'reset' | 'update' | 'destroy' | 'add' | 'remove' | 'invalid' | 'request' | 'sync' | 'attach';
 export declare class ODataModelEvent<T> {
     name: ODataModelEventType;
-    bubbling: boolean;
-    model?: ODataModel<T>;
-    collection?: ODataCollection<T, ODataModel<T>>;
-    chain: [
-        ODataModel<any> | ODataCollection<any, ODataModel<any>>,
-        string | number | null
-    ][];
     value?: any;
     previous?: any;
     options?: any;
@@ -25,10 +18,19 @@ export declare class ODataModelEvent<T> {
         value?: any;
         options?: any;
     });
+    bubbling: boolean;
     stopPropagation(): void;
+    chain: [
+        ODataModel<any> | ODataCollection<any, ODataModel<any>>,
+        string | number | null
+    ][];
     push(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>, track: string | number): void;
     visited(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>): 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: string[];
 export declare const INCLUDE_SHALLOW: {
@@ -170,13 +172,13 @@ export declare class ODataModelOptions<T> {
         include_parents?: boolean;
         include_navigation?: boolean;
     }): ODataModelField<any>[];
-    field<F>(name: keyof T | string): ODataModelField<any>;
-    attach(self: ODataModel<T>, resource: ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T>): void;
+    field<F>(name: keyof T | string): ODataModelField<F>;
+    attach<R>(self: ODataModel<T>, resource: ODataEntityResource<R> | ODataNavigationPropertyResource<R> | ODataPropertyResource<R> | ODataSingletonResource<R>): void;
     static chain(child: ODataModel<any> | ODataCollection<any, ODataModel<any>>): [
         ODataModel<any> | ODataCollection<any, ODataModel<any>>,
         ODataModelField<any> | null
     ][];
-    static resource<T>(child: ODataModel<T> | ODataCollection<T, ODataModel<T>>): ODataResource<T> | ODataResource<T>;
+    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>;

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

@@ -32,6 +32,7 @@ export declare type ExpandOptions<T> = {
     filter?: Filter<T>;
     orderBy?: OrderBy<T>;
     top?: number;
+    skip?: number;
     levels?: number | 'max';
     count?: boolean | Filter<T>;
     expand?: Expand<T>;

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

@@ -0,0 +1,20 @@
+import type { QueryCustomType } from '../builder';
+import { Renderable } from './syntax';
+export declare abstract class Expression<T> implements Renderable {
+    protected _children: Renderable[];
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    get [Symbol.toStringTag](): string;
+    abstract render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    abstract clone(): Expression<T>;
+    children(): Renderable[];
+    length(): number;
+    toJSON(): {
+        children: any[];
+    };
+}

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

@@ -0,0 +1,27 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { ODataFunctions, ODataOperators, Renderable } from './syntax';
+export declare class ComputeExpression<T> extends Expression<T> {
+    names: string[];
+    constructor({ children, names, }?: {
+        children?: Renderable[];
+        names?: string[];
+    });
+    static e<T>(): ComputeExpression<T>;
+    static s<T extends object>(): T;
+    static compute<T extends object>(opts: (builder: {
+        s: T;
+        e: () => ComputeExpression<T>;
+    }, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    clone(): ComputeExpression<unknown>;
+    private _add;
+    field<T extends object>(name: string, opts: (e: {
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Renderable): ComputeExpression<T>;
+}

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

@@ -0,0 +1,68 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { FilterConnector, FilterExpression } from './filter';
+import { OrderByExpression } from './orderby';
+import { SearchConnector, SearchExpression } from './search';
+import { SelectExpression } from './select';
+import { ODataFunctions, ODataOperators, Renderable } from './syntax';
+export declare class ExpandField<T> implements Renderable {
+    protected field: any;
+    private values;
+    constructor(field: any, values?: {
+        [name: string]: any;
+    });
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        field: any;
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+    clone(): ExpandField<unknown>;
+    select<T extends object>(opts: (builder: {
+        s: T;
+        e: () => SelectExpression<T>;
+    }, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
+    expand<T extends object>(opts: (builder: {
+        s: T;
+        e: () => ExpandExpression<T>;
+    }, current?: ExpandExpression<T>) => ExpandExpression<T>): any;
+    filter<T extends object>(opts: (builder: {
+        s: T;
+        e: (connector?: FilterConnector) => FilterExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }, current?: FilterExpression<T>) => FilterExpression<T>): any;
+    search<T extends object>(opts: (builder: {
+        e: (connector?: SearchConnector) => SearchExpression<T>;
+    }) => SearchExpression<T>): any;
+    orderBy<T extends object>(opts: (builder: {
+        s: T;
+        e: () => OrderByExpression<T>;
+    }, current?: OrderByExpression<T>) => OrderByExpression<T>): any;
+    skip(n: number): any;
+    top(n: number): any;
+    levels(n: number | 'max'): any;
+    private option;
+}
+export declare class ExpandExpression<T> extends Expression<T> {
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    static e<T>(): ExpandExpression<T>;
+    static s<T extends object>(): T;
+    static expand<T extends object>(opts: (builder: {
+        s: T;
+        e: () => ExpandExpression<T>;
+    }, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    clone(): ExpandExpression<unknown>;
+    private _add;
+    field<F>(field: F, opts?: (e: ExpandField<F>) => void): ExpandExpression<F>;
+}

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

@@ -0,0 +1,59 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { ODataFunctions, ODataOperators, Renderable } from './syntax';
+export declare type FilterConnector = 'and' | 'or';
+export declare class FilterExpression<F> extends Expression<F> {
+    private _connector;
+    private _negated;
+    constructor({ children, connector, negated, }?: {
+        children?: Renderable[];
+        connector?: FilterConnector;
+        negated?: boolean;
+    });
+    static s<T extends object>(): T;
+    static e<T>(connector?: FilterConnector): FilterExpression<T>;
+    static filter<T extends object>(opts: (builder: {
+        s: T;
+        e: (connector?: FilterConnector) => FilterExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
+    toJSON(): {
+        children: any[];
+        connector: FilterConnector;
+        negated: boolean;
+    };
+    connector(): FilterConnector;
+    negated(): boolean;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+    clone(): FilterExpression<unknown>;
+    private _add;
+    or(exp: FilterExpression<F>): FilterExpression<F>;
+    and(exp: FilterExpression<F>): FilterExpression<F>;
+    not(exp: FilterExpression<F>): FilterExpression<F>;
+    eq(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    ne(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    gt(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    ge(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    lt(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    le(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    has(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    in(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    contains(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    startsWith(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    endsWith(left: any, right: any, normalize?: boolean): FilterExpression<F>;
+    any<N extends object>(left: N[], opts: (e: {
+        s: N;
+        e: (connector?: FilterConnector) => FilterExpression<N>;
+    }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
+    all<N extends object>(left: N[], opts: (e: {
+        s: N;
+        e: (connector?: FilterConnector) => FilterExpression<N>;
+    }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
+    isof(type: string): FilterExpression<F>;
+    isof(left: F, type: string): FilterExpression<F>;
+}

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

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

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

@@ -0,0 +1,39 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { Renderable } from './syntax';
+export declare class OrderByField implements Renderable {
+    protected field: Renderable;
+    protected order: 'asc' | 'desc';
+    constructor(field: Renderable, order: 'asc' | 'desc');
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        field: any;
+        order: "desc" | "asc";
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+    clone(): OrderByField;
+}
+export declare class OrderByExpression<T> extends Expression<T> {
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    static e<T>(): OrderByExpression<T>;
+    static s<T extends object>(): T;
+    static orderBy<T extends object>(opts: (builder: {
+        s: T;
+        e: () => OrderByExpression<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;
+    }): string;
+    clone(): OrderByExpression<unknown>;
+    ascending(field: any): OrderByExpression<T>;
+    descending(field: any): OrderByExpression<T>;
+}

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

@@ -0,0 +1,50 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { Renderable } from './syntax';
+export declare type SearchConnector = 'AND' | 'OR';
+export declare class SearchTerm implements Renderable {
+    protected value: string;
+    constructor(value: string);
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        $type: string;
+        value: string;
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+    clone(): SearchTerm;
+}
+export declare class SearchExpression<T> extends Expression<T> {
+    private _connector;
+    private _negated;
+    constructor({ children, connector, negated, }?: {
+        children?: Renderable[];
+        connector?: SearchConnector;
+        negated?: boolean;
+    });
+    static e<T>(connector?: SearchConnector): SearchExpression<T>;
+    static search<T extends object>(opts: (builder: {
+        e: (connector?: SearchConnector) => SearchExpression<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;
+    }): string;
+    clone(): SearchExpression<unknown>;
+    toJSON(): {
+        children: any[];
+        connector: SearchConnector;
+        negated: boolean;
+    };
+    connector(): SearchConnector;
+    negated(): boolean;
+    or(exp: SearchExpression<T>): SearchExpression<T>;
+    and(exp: SearchExpression<T>): SearchExpression<T>;
+    not(exp: SearchExpression<T>): SearchExpression<T>;
+    term(value: any): SearchExpression<T>;
+}

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

@@ -0,0 +1,22 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { Renderable } from './syntax';
+export declare class SelectExpression<T> extends Expression<T> {
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    static e<T>(): SelectExpression<T>;
+    static s<T extends object>(): T;
+    static select<T extends object>(builder: (b: {
+        s: T;
+        e: () => SelectExpression<T>;
+    }, c?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    clone(): SelectExpression<unknown>;
+    private _add;
+    field(field: any): SelectExpression<T>;
+}

package/lib/resources/query/{syntax.d.ts → expressions/syntax.d.ts}

@@ -1,4 +1,4 @@
-import type { QueryCustomType } from './builder';
+import type { QueryCustomType } from '../builder';
 export interface Renderable {
     render({ aliases, escape, prefix, }: {
         aliases?: QueryCustomType[];
@@ -7,14 +7,21 @@ export interface Renderable {
     }): string;
     toString(): string;
     toJSON(): any;
+    clone(): any;
 }
-export declare type Funcs<T> = (x: ODataSyntax<T>) => Function<T> | Operator<T> | Grouping<T>;
 export declare class Field<T extends object> implements ProxyHandler<T> {
     name: string;
     constructor(name?: string);
-    static factory<T extends object>(): T;
-    get(target: T, p: string | symbol): any;
-}
+    static factory<T extends object>(name?: string): T;
+    get(target: T, key: string | symbol): any;
+    has(target: T, key: string): any;
+}
+export declare function render(value: any, { aliases, normalize, escape, prefix, }?: {
+    aliases?: QueryCustomType[];
+    normalize?: boolean;
+    escape?: boolean;
+    prefix?: string;
+}): string | number | boolean | null;
 export declare class Function<T> implements Renderable {
     protected name: string;
     protected values: any[];
@@ -23,6 +30,7 @@ export declare class Function<T> implements Renderable {
     constructor(name: string, values: any[], normalize?: boolean, escape?: boolean);
     get [Symbol.toStringTag](): string;
     toJSON(): {
+        $type: string;
         name: string;
         values: any[];
         normalize: boolean;
@@ -32,6 +40,7 @@ export declare class Function<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): Function<T>;
 }
 export declare class StringAndCollectionFunctions<T> {
     concat(field: any, value: any, normalize?: boolean): Function<T>;
@@ -92,6 +101,7 @@ export declare class Operator<T> implements Renderable {
     constructor(op: string, values: any[], normalize?: boolean);
     get [Symbol.toStringTag](): string;
     toJSON(): {
+        $type: string;
         op: string;
         values: any[];
         normalize: boolean;
@@ -101,6 +111,7 @@ export declare class Operator<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): Operator<unknown>;
 }
 export declare class LogicalOperators<T> {
     eq(left: any, right: any, normalize?: boolean): Operator<unknown>;
@@ -126,6 +137,7 @@ export declare class Grouping<T> implements Renderable {
     constructor(group: Renderable);
     get [Symbol.toStringTag](): string;
     toJSON(): {
+        $type: string;
         group: any;
     };
     render({ aliases, escape, prefix, }: {
@@ -133,9 +145,7 @@ export declare class Grouping<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
-}
-export declare class GroupingOperators<T> {
-    grouping(value: any): Grouping<unknown>;
+    clone(): Grouping<unknown>;
 }
 export declare class Lambda<T> implements Renderable {
     protected op: string;
@@ -144,6 +154,7 @@ export declare class Lambda<T> implements Renderable {
     constructor(op: string, values: any[], alias?: string | undefined);
     get [Symbol.toStringTag](): string;
     toJSON(): {
+        $type: string;
         op: string;
         values: any[];
         alias: string | undefined;
@@ -153,6 +164,7 @@ export declare class Lambda<T> implements Renderable {
         escape?: boolean;
         prefix?: string;
     }): string;
+    clone(): Lambda<unknown>;
 }
 export declare class LambdaOperators<T> {
     any(field: T, value: any, alias?: string): Lambda<unknown>;
@@ -160,7 +172,7 @@ export declare class LambdaOperators<T> {
 }
 export declare class ODataOperators<T> {
 }
-export interface ODataOperators<T> extends LogicalOperators<T>, ArithmeticOperators<T>, GroupingOperators<T>, LambdaOperators<T> {
+export interface ODataOperators<T> extends LogicalOperators<T>, ArithmeticOperators<T>, LambdaOperators<T> {
 }
 export declare const operators: ODataOperators<any>;
 export declare class ODataFunctions<T> {

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

@@ -1,8 +1,9 @@
 import { QueryOptionNames } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
-import { Connector, Expression } from './expressions';
+import { ComputeExpression, FilterConnector, FilterExpression, OrderByExpression, SearchConnector, SearchExpression, ODataFunctions, ODataOperators } from './expressions';
+import { ExpandExpression } from './expressions/expand';
+import { SelectExpression } from './expressions/select';
 import type { ODataQueryArguments, ODataQueryOptions } from './options';
-import { ODataFunctions, ODataOperators } from './syntax';
 export declare class ODataQueryOptionHandler<T> {
     private o;
     private n;
@@ -38,16 +39,27 @@ export declare class ODataQueryOptionsHandler<T> {
      * @returns The alias
      */
     alias(value: any, name?: string): import("./builder").QueryCustomType;
+    select(opts: (builder: {
+        s: T;
+        e: () => SelectExpression<T>;
+    }, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
     select(opts: Select<T>): ODataQueryOptionHandler<T>;
     select(): ODataQueryOptionHandler<T>;
+    expand(opts: (builder: {
+        s: T;
+        e: () => ExpandExpression<T>;
+    }, current?: ExpandExpression<T>) => ExpandExpression<T>): ExpandExpression<T>;
     expand(opts: Expand<T>): ODataQueryOptionHandler<T>;
     expand(): ODataQueryOptionHandler<T>;
     /**
      * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptioncompute
      */
-    compute(opts: (e: {
-        e: Expression<T>;
-    }) => Expression<T>): Expression<T>;
+    compute(opts: (builder: {
+        s: T;
+        e: () => ComputeExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }, current?: ComputeExpression<T>) => ComputeExpression<T>): ComputeExpression<T>;
     compute(opts: string): ODataQueryOptionHandler<T>;
     compute(): ODataQueryOptionHandler<T>;
     /**
@@ -57,20 +69,23 @@ export declare class ODataQueryOptionsHandler<T> {
     format(): ODataQueryOptionHandler<T>;
     transform(opts: Transform<T>): ODataQueryOptionHandler<T>;
     transform(): ODataQueryOptionHandler<T>;
+    search(opts: (builder: {
+        e: (connector: SearchConnector) => SearchExpression<T>;
+    }, current?: SearchExpression<T>) => SearchExpression<T>): SearchExpression<T>;
     search(opts: string): ODataQueryOptionHandler<T>;
     search(): ODataQueryOptionHandler<T>;
-    filter(opts: (e: {
+    filter(opts: (builder: {
         s: T;
-        e: (connector?: Connector) => Expression<T>;
+        e: (connector?: FilterConnector) => FilterExpression<T>;
         o: ODataOperators<T>;
         f: ODataFunctions<T>;
-    }) => Expression<T>): Expression<T>;
+    }, current?: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
     filter(opts: Filter<T>): ODataQueryOptionHandler<T>;
     filter(): ODataQueryOptionHandler<T>;
-    orderBy(opts: (e: {
-        e: () => Expression<T>;
-        not: (e: Expression<T>) => Expression<T>;
-    }) => Expression<T>): Expression<T>;
+    orderBy(opts: (builder: {
+        s: T;
+        e: () => OrderByExpression<T>;
+    }, current?: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
     orderBy(opts: OrderBy<T>): ODataQueryOptionHandler<T>;
     orderBy(): ODataQueryOptionHandler<T>;
     top(opts: number): ODataQueryOptionHandler<T>;

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

@@ -1,22 +1,24 @@
 import { QueryOptionNames } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
-import { Expression } from './expressions';
+import { Expression, FilterExpression, OrderByExpression, SearchExpression } from './expressions';
+import { ExpandExpression } from './expressions/expand';
+import { SelectExpression } from './expressions/select';
 import { ODataQueryOptionHandler } from './handlers';
 export declare type ODataQueryArguments<T> = {
-    [QueryOptionNames.select]?: Select<T>;
-    [QueryOptionNames.filter]?: Filter<T>;
-    [QueryOptionNames.search]?: string;
+    [QueryOptionNames.select]?: Select<T> | SelectExpression<T>;
+    [QueryOptionNames.filter]?: Filter<T> | FilterExpression<T>;
+    [QueryOptionNames.search]?: string | SearchExpression<T>;
     [QueryOptionNames.compute]?: string;
     [QueryOptionNames.transform]?: Transform<T>;
-    [QueryOptionNames.orderBy]?: OrderBy<T>;
+    [QueryOptionNames.orderBy]?: OrderBy<T> | OrderByExpression<T>;
     [QueryOptionNames.top]?: number;
     [QueryOptionNames.skip]?: number;
     [QueryOptionNames.skiptoken]?: string;
-    [QueryOptionNames.expand]?: Expand<T>;
+    [QueryOptionNames.expand]?: Expand<T> | ExpandExpression<T>;
     [QueryOptionNames.format]?: string;
 };
 export declare class ODataQueryOptions<T> {
-    options: {
+    values: {
         [name: string]: any;
     };
     constructor(options?: {
@@ -29,7 +31,7 @@ export declare class ODataQueryOptions<T> {
     toJSON(): {};
     toQueryArguments(): ODataQueryArguments<T>;
     clone<O>(): ODataQueryOptions<O>;
-    expression(name: QueryOptionNames, exp: Expression<T>): Expression<T>;
+    expression(name: QueryOptionNames, exp?: Expression<T>): any;
     option<O>(name: QueryOptionNames, opts?: O): ODataQueryOptionHandler<O>;
     has(name: QueryOptionNames): boolean;
     remove(...names: QueryOptionNames[]): void;

package/lib/resources/resource.d.ts

@@ -51,13 +51,14 @@ export declare class ODataResource<T> {
         reset?: boolean;
     }): C;
     isSubtypeOf(other: ODataResource<any>): boolean;
+    isSupertypeOf(other: ODataResource<any>): boolean;
     isEqualTo(other: ODataResource<any>, test?: 'path' | 'params'): boolean;
     pathAndParams(escape?: boolean): [string, {
         [name: string]: any;
     }];
     endpointUrl(params?: boolean): string;
     toString(): string;
-    clone<R extends ODataResource<T>>(): R;
+    clone(): ODataResource<T>;
     deserialize(value: any, options?: OptionsHelper): any;
     serialize(value: any, options?: OptionsHelper): any;
     encode(value: any, options?: OptionsHelper): any;

package/lib/resources/types/action.d.ts

@@ -15,6 +15,7 @@ export declare class ODataActionResource<P, R> extends ODataResource<R> {
         query?: ODataQueryOptions<R>;
     }): ODataActionResource<P, R>;
     static fromResource<P, R>(resource: ODataResource<any>, path: string): ODataActionResource<P, R>;
+    clone(): ODataActionResource<P, R>;
     returnType(): string | undefined;
     protected post(params: P | null, options?: ODataEntityOptions & ODataEntitiesOptions & ODataPropertyOptions): Observable<any>;
     /**

package/lib/resources/types/batch.d.ts

@@ -25,6 +25,16 @@ export declare class ODataBatchResource extends ODataResource<any> {
     private _requests;
     requests(): ODataRequest<any>[];
     static factory(api: ODataApi): ODataBatchResource;
+    clone(): ODataBatchResource;
+    private storeRequester;
+    private restoreRequester;
+    /**
+     * Add to batch request
+     * @param ctx The context for the request
+     * @returns The result of execute the context
+     */
+    add<R>(ctx: (batch: this) => Observable<R>): Observable<R>;
+    send(options?: ODataOptions): void;
     /**
      * Execute the batch request
      * @param ctx The context for the request

package/lib/resources/types/count.d.ts

@@ -9,6 +9,7 @@ export declare class ODataCountResource<T> extends ODataResource<T> {
         segments: ODataPathSegments;
         query?: ODataQueryOptions<T>;
     }): ODataCountResource<T>;
+    clone(): ODataCountResource<T>;
     protected get(options?: ODataOptions): Observable<number>;
     /**
      * Fetch the count of the set.