angular-odata 0.90.0 → 0.99.2

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

@@ -0,0 +1,58 @@
+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<T> extends Expression<T> {
+    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: (e: {
+        s: T;
+        e: (connector?: FilterConnector) => FilterExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => 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;
+    private _add;
+    or(exp: FilterExpression<T>): FilterExpression<T>;
+    and(exp: FilterExpression<T>): FilterExpression<T>;
+    not(exp: FilterExpression<T>): FilterExpression<T>;
+    eq(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    ne(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    gt(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    ge(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    lt(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    le(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    has(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    in(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    contains(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    startsWith(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    endsWith(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    any<N extends object>(left: N[], opts: (e: {
+        s: N;
+        e: (connector?: FilterConnector) => FilterExpression<N>;
+    }) => FilterExpression<N>, alias?: string): FilterExpression<T>;
+    all<N extends object>(left: N[], opts: (e: {
+        s: N;
+        e: (connector?: FilterConnector) => FilterExpression<N>;
+    }) => FilterExpression<N>, alias?: string): FilterExpression<T>;
+    isof(type: string): FilterExpression<T>;
+    isof(left: T, type: string): FilterExpression<T>;
+}

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,37 @@
+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;
+}
+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: (e: {
+        s: T;
+        e: () => OrderByExpression<T>;
+    }) => OrderByExpression<T>): OrderByExpression<T>;
+    private _add;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    ascending(field: any): OrderByExpression<T>;
+    descending(field: any): OrderByExpression<T>;
+}

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

@@ -0,0 +1,47 @@
+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(): {
+        value: string;
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+}
+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: (e: {
+        e: (connector?: SearchConnector) => SearchExpression<T>;
+    }) => SearchExpression<T>): SearchExpression<T>;
+    private _add;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    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,21 @@
+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>(opts: (e: {
+        s: T;
+        e: () => SelectExpression<T>;
+    }) => SelectExpression<T>): SelectExpression<T>;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    private _add;
+    field(field: any): SelectExpression<T>;
+}

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

@@ -1,32 +1,51 @@
-import type { QueryCustomType } from './builder';
+import type { QueryCustomType } from '../builder';
 export interface Renderable {
-    render(aliases?: QueryCustomType[]): string;
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
     toString(): string;
     toJSON(): any;
 }
-export declare type Funcs<T> = (x: ODataSyntax<T>) => Function<T> | Operator<T> | Grouping<T> | Navigation<T, any>;
-export declare type Field<T> = keyof T | Funcs<keyof 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;
+}
+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[];
     protected normalize: boolean;
-    constructor(name: string, values: any[], normalize?: boolean);
+    protected escape: boolean;
+    constructor(name: string, values: any[], normalize?: boolean, escape?: boolean);
     get [Symbol.toStringTag](): string;
     toJSON(): {
         name: string;
         values: any[];
         normalize: boolean;
     };
-    render(aliases?: QueryCustomType[]): string;
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
 }
 export declare class StringAndCollectionFunctions<T> {
-    concat(field: T, value: any, normalize?: boolean): Function<T>;
-    contains(field: T, value: any, normalize?: boolean): Function<T>;
-    endsWith(field: T, value: any, normalize?: boolean): Function<T>;
-    indexOf(field: T, value: any, normalize?: boolean): Function<T>;
-    length(value: T, normalize?: boolean): Function<T>;
-    startsWith(field: T, value: any, normalize?: boolean): Function<T>;
-    subString(field: T, start: any, length?: any, normalize?: boolean): Function<T>;
+    concat(field: any, value: any, normalize?: boolean): Function<T>;
+    contains(field: any, value: any, normalize?: boolean): Function<T>;
+    endsWith(field: any, value: any, normalize?: boolean): Function<T>;
+    indexOf(field: any, value: any, normalize?: boolean): Function<T>;
+    length(value: any, normalize?: boolean): Function<T>;
+    startsWith(field: any, value: any, normalize?: boolean): Function<T>;
+    subString(field: any, start: number, length?: number): Function<T>;
 }
 export declare class CollectionFunctions<T> {
     hasSubset(s1: T, s2: any): Function<T>;
@@ -39,20 +58,20 @@ export declare class StringFunctions<T> {
     trim(value: T): Function<T>;
 }
 export declare class DateAndTimeFunctions<T> {
-    date(value: T): Function<T>;
-    day(value: T): Function<T>;
-    fractionalseconds(value: T): Function<T>;
-    hour(value: T): Function<T>;
-    maxdatetime(value: T): Function<T>;
-    mindatetime(value: T): Function<T>;
-    minute(value: T): Function<T>;
-    month(value: T): Function<T>;
+    date(value: any): Function<T>;
+    day(value: any): Function<T>;
+    fractionalseconds(value: any): Function<T>;
+    hour(value: any): Function<T>;
+    maxdatetime(value: any): Function<T>;
+    mindatetime(value: any): Function<T>;
+    minute(value: any): Function<T>;
+    month(value: any): Function<T>;
     now(): Function<T>;
-    second(value: T): Function<T>;
-    time(value: T): Function<T>;
-    totaloffsetminutes(value: T): Function<T>;
-    totalseconds(value: T): Function<T>;
-    year(value: T): Function<T>;
+    second(value: any): Function<T>;
+    time(value: any): Function<T>;
+    totaloffsetminutes(value: any): Function<T>;
+    totalseconds(value: any): Function<T>;
+    year(value: any): Function<T>;
 }
 export declare class ArithmeticFunctions<T> {
     ceiling(value: T | string): Function<T>;
@@ -64,9 +83,9 @@ export declare class TypeFunctions<T> {
     isof(value: T | string, type?: string): Function<T>;
 }
 export declare class GeoFunctions<T> {
-    distance(value: T, point: string, normalize?: boolean): Function<T>;
-    intersects(value: T, polygon: string, normalize?: boolean): Function<T>;
-    length(value: T, normalize?: boolean): Function<T>;
+    geoDistance(value: T, point: string, normalize?: boolean): Function<T>;
+    geoIntersects(value: T, polygon: string, normalize?: boolean): Function<T>;
+    geoLength(line: T, normalize?: boolean): Function<T>;
 }
 export declare class ConditionalFunctions<T> {
     case(condition: T | string, value: any): Function<T>;
@@ -82,7 +101,11 @@ export declare class Operator<T> implements Renderable {
         values: any[];
         normalize: boolean;
     };
-    render(aliases?: QueryCustomType[]): string;
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
 }
 export declare class LogicalOperators<T> {
     eq(left: any, right: any, normalize?: boolean): Operator<unknown>;
@@ -91,8 +114,6 @@ export declare class LogicalOperators<T> {
     ge(left: any, right: any, normalize?: boolean): Operator<unknown>;
     lt(left: any, right: any, normalize?: boolean): Operator<unknown>;
     le(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    and(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    or(left: any, right: any, normalize?: boolean): Operator<unknown>;
     not(value: any, normalize?: boolean): Operator<T>;
     has(left: any, right: any, normalize?: boolean): Operator<unknown>;
     in(left: any, right: any, normalize?: boolean): Operator<unknown>;
@@ -112,38 +133,36 @@ export declare class Grouping<T> implements Renderable {
     toJSON(): {
         group: any;
     };
-    render(aliases?: QueryCustomType[]): string;
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
 }
-export declare class Navigation<T, N> implements Renderable {
-    protected field: T;
-    protected value: Field<N>;
-    constructor(field: T, value: Field<N>);
-    get [Symbol.toStringTag](): string;
-    toJSON(): {
-        field: T;
-        value: Field<N>;
-    };
-    render(aliases?: QueryCustomType[]): string;
-}
-export declare class GroupingAndNavigationOperators<T> {
-    grouping(value: any): Grouping<unknown>;
-    navigation<N>(field: T, value: Field<N>): Navigation<T, N>;
-}
-export declare class Lambda<T> extends Operator<T> {
+export declare class Lambda<T> implements Renderable {
     protected op: string;
     protected values: any[];
-    protected normalize: boolean;
-    constructor(op: string, values: any[], normalize?: boolean);
+    protected alias?: string | undefined;
+    constructor(op: string, values: any[], alias?: string | undefined);
     get [Symbol.toStringTag](): string;
-    render(aliases?: QueryCustomType[]): string;
+    toJSON(): {
+        op: string;
+        values: any[];
+        alias: string | undefined;
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
 }
 export declare class LambdaOperators<T> {
-    any(field: T, value: any): Lambda<unknown>;
-    all(field: T, value: any): Lambda<unknown>;
+    any(field: T, value: any, alias?: string): Lambda<unknown>;
+    all(field: T, value: any, alias?: string): Lambda<unknown>;
 }
 export declare class ODataOperators<T> {
 }
-export interface ODataOperators<T> extends LogicalOperators<T>, ArithmeticOperators<T>, GroupingAndNavigationOperators<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,6 +1,8 @@
-import { Expand, Filter, OrderBy, Select, Transform } from './builder';
 import { QueryOptionNames } from '../../types';
-import { Expression } from './expressions';
+import { Expand, Filter, OrderBy, Select, Transform } from './builder';
+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';
 export declare class ODataQueryOptionHandler<T> {
     private o;
@@ -37,44 +39,53 @@ export declare class ODataQueryOptionsHandler<T> {
      * @returns The alias
      */
     alias(value: any, name?: string): import("./builder").QueryCustomType;
+    select(opts: (e: {
+        s: T;
+        e: () => SelectExpression<T>;
+    }) => SelectExpression<T>): SelectExpression<T>;
     select(opts: Select<T>): ODataQueryOptionHandler<T>;
     select(): ODataQueryOptionHandler<T>;
+    expand(opts: (e: {
+        s: T;
+        e: () => ExpandExpression<T>;
+    }) => ExpandExpression<T>): ExpandExpression<T>;
     expand(opts: Expand<T>): ODataQueryOptionHandler<T>;
     expand(): ODataQueryOptionHandler<T>;
     /**
-     * Url: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptioncompute
+     * @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>;
-        and: Expression<T>;
-        or: Expression<T>;
-        not: typeof Expression.not;
-    }) => Expression<T>): Expression<T>;
+        s: T;
+        e: () => ComputeExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => ComputeExpression<T>): ComputeExpression<T>;
     compute(opts: string): ODataQueryOptionHandler<T>;
     compute(): ODataQueryOptionHandler<T>;
     /**
-     * Url: https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptionformat
+     * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptionformat
      */
     format(opts: string): ODataQueryOptionHandler<T>;
     format(): ODataQueryOptionHandler<T>;
     transform(opts: Transform<T>): ODataQueryOptionHandler<T>;
     transform(): ODataQueryOptionHandler<T>;
+    search(opts: (e: {
+        e: (connector: SearchConnector) => SearchExpression<T>;
+    }) => SearchExpression<T>): SearchExpression<T>;
     search(opts: string): ODataQueryOptionHandler<T>;
     search(): ODataQueryOptionHandler<T>;
     filter(opts: (e: {
-        e: () => Expression<T>;
-        and: () => Expression<T>;
-        or: () => Expression<T>;
-        not: (e: Expression<T>) => Expression<T>;
-    }) => Expression<T>): Expression<T>;
+        s: T;
+        e: (connector?: FilterConnector) => FilterExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => FilterExpression<T>): FilterExpression<T>;
     filter(opts: Filter<T>): ODataQueryOptionHandler<T>;
     filter(): ODataQueryOptionHandler<T>;
     orderBy(opts: (e: {
-        e: () => Expression<T>;
-        and: () => Expression<T>;
-        or: () => Expression<T>;
-        not: (e: Expression<T>) => Expression<T>;
-    }) => Expression<T>): Expression<T>;
+        s: T;
+        e: () => 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,7 +1,7 @@
-import { Expand, Filter, OrderBy, Select, Transform } from './builder';
 import { QueryOptionNames } from '../../types';
-import { ODataQueryOptionHandler } from './handlers';
+import { Expand, Filter, OrderBy, Select, Transform } from './builder';
 import { Expression } from './expressions';
+import { ODataQueryOptionHandler } from './handlers';
 export declare type ODataQueryArguments<T> = {
     [QueryOptionNames.select]?: Select<T>;
     [QueryOptionNames.filter]?: Filter<T>;
@@ -22,7 +22,7 @@ export declare class ODataQueryOptions<T> {
     constructor(options?: {
         [name: string]: any;
     });
-    pathAndParams(): [string, {
+    pathAndParams(escape?: boolean): [string, {
         [name: string]: any;
     }];
     toString(): string;

package/lib/resources/request.d.ts

@@ -1,7 +1,7 @@
 import { HttpHeaders, HttpParams } from '@angular/common/http';
 import { ODataApi } from '../api';
-import { ODataResource } from './resource';
 import { QueryOptionNames } from '../types';
+import { ODataResource } from './resource';
 export declare class ODataRequest<T> {
     readonly api: ODataApi;
     readonly observe: 'events' | 'response';

package/lib/resources/resource.d.ts

@@ -1,18 +1,26 @@
 import { Observable } from 'rxjs';
-import { ODataPathSegments, ODataPathSegmentsHandler } from './path';
-import { ODataOptions } from './types';
 import { ODataApi } from '../api';
+import { ODataCollection, ODataModel } from '../models';
+import { ODataStructuredType } from '../schema';
+import { ODataSchemaElement } from '../schema/element';
 import { OptionsHelper, QueryOptionNames } from '../types';
-import { QueryCustomType, ODataQueryOptions, ODataQueryOptionsHandler } from './query';
-import { ODataStructuredType, ODataCallable } from '../schema/index';
+import { ODataPathSegments, ODataPathSegmentsHandler } from './path';
+import { ODataQueryOptions, ODataQueryOptionsHandler, QueryCustomType } from './query';
+import { ODataEntitiesAnnotations, ODataEntityAnnotations } from './responses/index';
+import { ODataOptions } from './types';
 export declare type EntityKey<T> = {
     readonly [P in keyof T]?: T[P];
 } | QueryCustomType | string | number;
-export declare abstract class ODataResource<T> {
+export declare class ODataResource<T> {
     api: ODataApi;
+    schema?: ODataSchemaElement;
     protected pathSegments: ODataPathSegments;
     protected queryOptions: ODataQueryOptions<T>;
-    constructor(api: ODataApi, segments?: ODataPathSegments, query?: ODataQueryOptions<T>);
+    constructor(api: ODataApi, { segments, query, schema, }?: {
+        segments?: ODataPathSegments;
+        query?: ODataQueryOptions<T>;
+        schema?: ODataSchemaElement;
+    });
     /**
      * @returns string The type of the resource
      */
@@ -30,17 +38,27 @@ export declare abstract class ODataResource<T> {
      */
     hasKey(): boolean;
     clearKey(): void | undefined;
+    asModel<M extends ODataModel<T>>(entity?: Partial<T> | {
+        [name: string]: any;
+    }, { annots, reset }?: {
+        annots?: ODataEntityAnnotations;
+        reset?: boolean;
+    }): M;
+    asCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(entities?: Partial<T>[] | {
+        [name: string]: any;
+    }[], { annots, reset, }?: {
+        annots?: ODataEntitiesAnnotations;
+        reset?: boolean;
+    }): C;
     isSubtypeOf(other: ODataResource<any>): boolean;
-    isParentOf(other: ODataResource<any>): boolean;
-    isChildOf(other: ODataResource<any>): boolean;
+    isSupertypeOf(other: ODataResource<any>): boolean;
     isEqualTo(other: ODataResource<any>, test?: 'path' | 'params'): boolean;
-    pathAndParams(): [string, {
+    pathAndParams(escape?: boolean): [string, {
         [name: string]: any;
     }];
     endpointUrl(params?: boolean): string;
     toString(): string;
-    abstract clone(): ODataResource<T>;
-    abstract schema(): ODataStructuredType<T> | ODataCallable<T> | undefined;
+    clone(): ODataResource<T>;
     deserialize(value: any, options?: OptionsHelper): any;
     serialize(value: any, options?: OptionsHelper): any;
     encode(value: any, options?: OptionsHelper): any;
@@ -64,7 +82,7 @@ export declare abstract class ODataResource<T> {
      * @param f Function context for handle the query options
      */
     query(f: (q: ODataQueryOptionsHandler<T>) => void): this;
-    static resolveKey<T>(value: any, schema?: ODataStructuredType<T> | ODataCallable<T>): EntityKey<T> | undefined;
+    static resolveKey<T>(value: any, schema?: ODataStructuredType<T>): EntityKey<T> | undefined;
     protected resolveKey(value: any): EntityKey<T> | undefined;
     protected request(method: string, options: ODataOptions & {
         body?: any;

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

@@ -1,28 +1,22 @@
-import { ODataCollection, ODataModel } from '../../models';
-import { ODataEntities, ODataEntitiesAnnotations, ODataEntity, ODataEntityAnnotations, ODataProperty } from '../responses';
-import { ODataEntitiesOptions, ODataEntityOptions, ODataNoneOptions, ODataOptions, ODataPropertyOptions } from './options';
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
+import { ODataCollection, ODataModel } from '../../models';
+import { ODataCallable } from '../../schema/callable';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
+import { ODataEntities, ODataEntity, ODataProperty } from '../responses';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataNoneOptions, ODataOptions, ODataPropertyOptions } from './options';
 export declare class ODataActionResource<P, R> extends ODataResource<R> {
-    static factory<P, R>(api: ODataApi, path: string, type: string | undefined, segments: ODataPathSegments, query: ODataQueryOptions<R>): ODataActionResource<P, R>;
+    static factory<P, R>(api: ODataApi, { path, schema, segments, query, }: {
+        path?: string;
+        schema?: ODataCallable<R>;
+        segments?: ODataPathSegments;
+        query?: ODataQueryOptions<R>;
+    }): ODataActionResource<P, R>;
+    static fromResource<P, R>(resource: ODataResource<any>, path: string): ODataActionResource<P, R>;
     clone(): ODataActionResource<P, R>;
-    schema(): import("angular-odata").ODataCallable<R> | undefined;
     returnType(): string | undefined;
-    asModel<M extends ODataModel<R>>(entity: Partial<R> | {
-        [name: string]: any;
-    }, { annots, reset }?: {
-        annots?: ODataEntityAnnotations;
-        reset?: boolean;
-    }): M;
-    asCollection<M extends ODataModel<R>, C extends ODataCollection<R, M>>(entities: Partial<R>[] | {
-        [name: string]: any;
-    }[], { annots, reset, }?: {
-        annots?: ODataEntitiesAnnotations;
-        reset?: boolean;
-    }): C;
     protected post(params: P | null, options?: ODataEntityOptions & ODataEntitiesOptions & ODataPropertyOptions): Observable<any>;
     /**
      * Execute the action

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

@@ -1,9 +1,9 @@
 import { Observable, Subject } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataOptions } from './options';
 import { ODataRequest } from '../request';
 import { ODataResource } from '../resource';
 import { ODataResponse } from '../responses';
+import { ODataOptions } from './options';
 export declare class ODataBatchRequest<T> extends Subject<ODataResponse<T>> {
     request: ODataRequest<any>;
     constructor(request: ODataRequest<any>);
@@ -26,7 +26,15 @@ export declare class ODataBatchResource extends ODataResource<any> {
     requests(): ODataRequest<any>[];
     static factory(api: ODataApi): ODataBatchResource;
     clone(): ODataBatchResource;
-    schema(): undefined;
+    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

@@ -1,13 +1,15 @@
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataOptions } from './options';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
+import { ODataOptions } from './options';
 export declare class ODataCountResource<T> extends ODataResource<T> {
-    static factory<T>(api: ODataApi, segments: ODataPathSegments, query: ODataQueryOptions<T>): ODataCountResource<T>;
+    static factory<T>(api: ODataApi, { segments, query, }: {
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<T>;
+    }): ODataCountResource<T>;
     clone(): ODataCountResource<T>;
-    schema(): undefined;
     protected get(options?: ODataOptions): Observable<number>;
     /**
      * Fetch the count of the set.