angular-odata 0.78.1 → 0.95.0

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

@@ -0,0 +1,175 @@
+import type { QueryCustomType } from './builder';
+export interface Renderable {
+    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>;
+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 class Function<T> implements Renderable {
+    protected name: string;
+    protected values: any[];
+    protected 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, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+}
+export declare class StringAndCollectionFunctions<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>;
+    hasSubsequence(s1: T, s2: any): Function<T>;
+}
+export declare class StringFunctions<T> {
+    matchesPattern(value: T | string, pattern: string): Function<T>;
+    toLower(value: T): Function<T>;
+    toUpper(value: T): Function<T>;
+    trim(value: T): Function<T>;
+}
+export declare class DateAndTimeFunctions<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: 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>;
+    floor(value: T | string): Function<T>;
+    round(value: T | string): Function<T>;
+}
+export declare class TypeFunctions<T> {
+    cast(value: T | string, type?: string): Function<T>;
+    isof(value: T | string, type?: string): Function<T>;
+}
+export declare class GeoFunctions<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>;
+}
+export declare class Operator<T> implements Renderable {
+    protected op: string;
+    protected values: any[];
+    protected normalize: boolean;
+    constructor(op: string, values: any[], normalize?: boolean);
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        op: string;
+        values: any[];
+        normalize: boolean;
+    };
+    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>;
+    ne(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    gt(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    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>;
+    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>;
+}
+export declare class ArithmeticOperators<T> {
+    add(left: any, right: any, normalize?: boolean): Operator<T>;
+    sub(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    mul(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    div(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    mod(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    neg(value: any, normalize?: boolean): Operator<unknown>;
+}
+export declare class Grouping<T> implements Renderable {
+    protected group: Renderable;
+    constructor(group: Renderable);
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        group: any;
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+}
+export declare class GroupingOperators<T> {
+    grouping(value: any): Grouping<unknown>;
+}
+export declare class Lambda<T> implements Renderable {
+    protected op: string;
+    protected values: any[];
+    protected alias?: string | undefined;
+    constructor(op: string, values: any[], alias?: string | undefined);
+    get [Symbol.toStringTag](): 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, 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>, GroupingOperators<T>, LambdaOperators<T> {
+}
+export declare const operators: ODataOperators<any>;
+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 ODataSyntax<T> {
+}
+export interface ODataSyntax<T> extends ODataOperators<T>, ODataFunctions<T> {
+}
+export declare const syntax: ODataSyntax<any>;

package/lib/resources/request.d.ts

@@ -3,19 +3,20 @@ import { ODataApi } from '../api';
 import { QueryOptionNames } from '../types';
 import { ODataResource } from './resource';
 export declare class ODataRequest<T> {
-    private readonly _method;
     readonly api: ODataApi;
-    private readonly _body;
     readonly observe: 'events' | 'response';
     readonly reportProgress?: boolean;
     readonly withCredentials?: boolean;
     readonly bodyQueryOptions: QueryOptionNames[];
-    readonly responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
     readonly fetchPolicy: 'cache-first' | 'cache-and-network' | 'network-only' | 'no-cache' | 'cache-only';
+    readonly resource: ODataResource<T>;
+    private readonly _responseType?;
+    private readonly _method;
+    private readonly _body;
     private readonly _headers;
     private readonly _params;
     private readonly _path;
-    readonly resource: ODataResource<T>;
+    private readonly _queryBody;
     constructor(init: {
         method: string;
         api: ODataApi;
@@ -30,11 +31,12 @@ export declare class ODataRequest<T> {
         params?: HttpParams | {
             [param: string]: string | string[];
         };
-        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
+        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
         fetchPolicy?: 'cache-first' | 'cache-and-network' | 'network-only' | 'no-cache' | 'cache-only';
         withCredentials?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
     });
+    get responseType(): 'arraybuffer' | 'blob' | 'json' | 'text';
     get path(): string;
     get method(): string;
     get body(): any;
@@ -43,7 +45,7 @@ export declare class ODataRequest<T> {
     get pathWithParams(): string;
     get url(): string;
     get urlWithParams(): string;
-    isBodyQueryOptions(): boolean;
+    isBatch(): boolean;
     isFetch(): boolean;
     isMutate(): boolean;
 }

package/lib/resources/resource.d.ts

@@ -1,19 +1,26 @@
 import { Observable } from 'rxjs';
-import { ODataPathSegments } from './path-segments';
-import { QueryArguments, ODataQueryOptions } from './query-options';
-import { HttpOptions } 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 { Expand, Filter, OrderBy, Select, Transform, QueryCustomType } from './builder';
-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;
-    constructor(api: ODataApi, segments?: ODataPathSegments, query?: ODataQueryOptions);
+    protected queryOptions: ODataQueryOptions<T>;
+    constructor(api: ODataApi, { segments, query, schema, }?: {
+        segments?: ODataPathSegments;
+        query?: ODataQueryOptions<T>;
+        schema?: ODataSchemaElement;
+    });
     /**
      * @returns string The type of the resource
      */
@@ -31,92 +38,79 @@ 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;
     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;
-    serialize(value: any, options?: OptionsHelper): any;
+    clone<R extends ODataResource<T>>(): R;
     deserialize(value: any, options?: OptionsHelper): any;
+    serialize(value: any, options?: OptionsHelper): any;
     encode(value: any, options?: OptionsHelper): any;
     toJSON(): {
         segments: any[];
-        options: any;
+        options: {};
     };
     cloneSegments(): ODataPathSegments;
     clearQuery(): void;
-    cloneQuery(): ODataQueryOptions;
+    cloneQuery<P>(): ODataQueryOptions<P>;
     /**
-     * Factorise an object handler for mutate query options for resources that match to entity
-     * @returns Object handler for mutate query options
+     * Handle the path segments of the resource
+     * Create an object handler for mutate the path segments of the resource
+     * @param f Function context for handle the segments
+     * @returns ODataActionResource
      */
-    protected entityQueryHandler(): {
-        select(opts?: Select<T> | undefined): import("./query-options").OptionHandler<Select<T>>;
-        expand(opts?: Expand<T> | undefined): import("./query-options").OptionHandler<Expand<T>>;
-        compute(opts?: string | undefined): import("./query-options").OptionHandler<string>;
-        format(opts?: string | undefined): import("./query-options").OptionHandler<string>;
-        apply(query: QueryArguments<T>): void;
-    };
-    static resolveKey<T>(value: any, schema?: ODataStructuredType<T> | ODataCallable<T>): EntityKey<T> | undefined;
-    protected resolveKey(value: any): EntityKey<T> | undefined;
+    segment(f: (q: ODataPathSegmentsHandler<T>) => void): this;
     /**
-     * Factorise an object handler for mutate query options for resources that match to entities
-     * @returns Object handler for mutate query options
+     * Handle the query options of the resource
+     * Create an object handler for mutate the query options of the resource
+     * @param f Function context for handle the query options
      */
-    protected entitiesQueryHandler(): {
-        select(opts?: Select<T> | undefined): import("./query-options").OptionHandler<Select<T>>;
-        expand(opts?: Expand<T> | undefined): import("./query-options").OptionHandler<Expand<T>>;
-        compute(opts?: string | undefined): import("./query-options").OptionHandler<string>;
-        transform(opts?: Transform<T> | undefined): import("./query-options").OptionHandler<Transform<T>>;
-        search(opts?: string | undefined): import("./query-options").OptionHandler<string>;
-        filter(opts?: Filter | undefined): import("./query-options").OptionHandler<Filter>;
-        orderBy(opts?: OrderBy<T> | undefined): import("./query-options").OptionHandler<OrderBy<T>>;
-        format(opts?: string | undefined): import("./query-options").OptionHandler<string>;
-        top(opts?: number | undefined): import("./query-options").OptionHandler<number>;
-        skip(opts?: number | undefined): import("./query-options").OptionHandler<number>;
-        skiptoken(opts?: string | undefined): import("./query-options").OptionHandler<string>;
-        paging({ skip, skiptoken, top, }?: {
-            skip?: number | undefined;
-            skiptoken?: string | undefined;
-            top?: number | undefined;
-        }): void;
-        clearPaging(): void;
-        apply(query: QueryArguments<T>): void;
-    };
-    protected request(method: string, options: HttpOptions & {
+    query(f: (q: ODataQueryOptionsHandler<T>) => void): this;
+    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;
         etag?: string;
         responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
         withCount?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<any>;
-    protected get(options?: HttpOptions & {
+    protected get(options?: ODataOptions & {
         etag?: string;
         responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
         withCount?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<any>;
-    protected post(body: any, options?: HttpOptions & {
+    protected post(body: any, options?: ODataOptions & {
         responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
         withCount?: boolean;
     }): Observable<any>;
-    protected put(body: any, options?: HttpOptions & {
+    protected put(body: any, options?: ODataOptions & {
         etag?: string;
         responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
         withCount?: boolean;
     }): Observable<any>;
-    protected patch(body: any, options?: HttpOptions & {
+    protected patch(body: any, options?: ODataOptions & {
         etag?: string;
         responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
         withCount?: boolean;
     }): Observable<any>;
-    protected delete(options?: HttpOptions & {
+    protected delete(options?: ODataOptions & {
         etag?: string;
         responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
         withCount?: boolean;

package/lib/resources/responses/metadata.d.ts

@@ -1,5 +1,5 @@
-import { CsdlSchema } from './csdl/csdl-schema';
 import { CsdlReference } from './csdl/csdl-reference';
+import { CsdlSchema } from './csdl/csdl-schema';
 declare enum FieldType {
     ATTRIBUTE = 0,
     TAG = 1

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

@@ -1,4 +1,4 @@
-import { ODataEntityAnnotations, ODataEntitiesAnnotations, ODataPropertyAnnotations } from './annotations';
+import { ODataEntitiesAnnotations, ODataEntityAnnotations, ODataPropertyAnnotations } from './annotations';
 export declare type ODataEntity<T> = {
     entity: T | null;
     annots: ODataEntityAnnotations;

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

@@ -1,78 +1,64 @@
 import { Observable } from 'rxjs';
-import { ODataPathSegments } from '../path-segments';
-import { ODataQueryOptions } from '../query-options';
-import { HttpEntityOptions, HttpEntitiesOptions, HttpPropertyOptions, HttpOptions, HttpNoneOptions } from './options';
-import { ODataProperty, ODataEntities, ODataEntity, ODataEntityAnnotations, ODataEntitiesAnnotations } from '../responses';
 import { ODataApi } from '../../api';
 import { ODataCollection, ODataModel } from '../../models';
-import { Expand, Filter, OrderBy, Select, Transform } from '../builder';
+import { ODataCallable } from '../../schema/callable';
+import { ODataPathSegments } from '../path';
+import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
+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): ODataActionResource<P, R>;
-    clone(): ODataActionResource<P, R>;
-    schema(): import("angular-odata").ODataCallable<R> | undefined;
+    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>;
     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;
-    select(opts: Select<R>): ODataActionResource<P, R>;
-    expand(opts: Expand<R>): ODataActionResource<P, R>;
-    transform(opts: Transform<R>): ODataActionResource<P, R>;
-    search(opts: string): ODataActionResource<P, R>;
-    filter(opts: Filter): ODataActionResource<P, R>;
-    orderBy(opts: OrderBy<R>): ODataActionResource<P, R>;
-    format(opts: string): ODataActionResource<P, R>;
-    top(opts: number): ODataActionResource<P, R>;
-    skip(opts: number): ODataActionResource<P, R>;
-    skiptoken(opts: string): ODataActionResource<P, R>;
-    get segment(): {
-        entitySet(): import("../path-segments").SegmentHandler;
-        singleton(): import("../path-segments").SegmentHandler;
-        action(): import("../path-segments").SegmentHandler;
-    };
+    protected post(params: P | null, options?: ODataEntityOptions & ODataEntitiesOptions & ODataPropertyOptions): Observable<any>;
     /**
-     * Handle query options of the action
-     * @returns Handler for mutate the query of the action
+     * Execute the action
+     * @param params Parameters to be sent to the action
+     * @param options Options for the request
      */
-    get query(): {
-        select(opts?: Select<R> | undefined): import("../query-options").OptionHandler<Select<R>>;
-        expand(opts?: Expand<R> | undefined): import("../query-options").OptionHandler<Expand<R>>;
-        compute(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        transform(opts?: Transform<R> | undefined): import("../query-options").OptionHandler<Transform<R>>;
-        search(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        filter(opts?: Filter | undefined): import("../query-options").OptionHandler<Filter>;
-        orderBy(opts?: OrderBy<R> | undefined): import("../query-options").OptionHandler<OrderBy<R>>;
-        format(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        top(opts?: number | undefined): import("../query-options").OptionHandler<number>;
-        skip(opts?: number | undefined): import("../query-options").OptionHandler<number>;
-        skiptoken(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        paging({ skip, skiptoken, top, }?: {
-            skip?: number | undefined;
-            skiptoken?: string | undefined;
-            top?: number | undefined;
-        }): void;
-        clearPaging(): void;
-        apply(query: import("../query-options").QueryArguments<R>): void;
-    };
-    post(params: P | null, options?: HttpEntityOptions): Observable<ODataEntity<R>>;
-    post(params: P | null, options?: HttpEntitiesOptions): Observable<ODataEntities<R>>;
-    post(params: P | null, options?: HttpPropertyOptions): Observable<ODataProperty<R>>;
-    call(params: P | null, options?: HttpEntityOptions & HttpOptions): Observable<ODataEntity<R>>;
-    call(params: P | null, options?: HttpEntitiesOptions & HttpOptions): Observable<ODataEntities<R>>;
-    call(params: P | null, options?: HttpPropertyOptions & HttpOptions): Observable<ODataProperty<R>>;
-    call(params: P | null, options?: HttpNoneOptions & HttpOptions): Observable<null>;
-    callProperty(params: P | null, options?: HttpOptions): Observable<R | null>;
-    callEntity(params: P | null, options?: HttpOptions): Observable<R | null>;
-    callModel(params: P | null, options?: HttpOptions): Observable<ODataModel<R> | null>;
-    callEntities(params: P | null, options?: HttpOptions): Observable<R[] | null>;
-    callCollection(params: P | null, options?: HttpOptions): Observable<ODataCollection<R, ODataModel<R>> | null>;
+    call(params: P | null, options?: ODataEntityOptions): Observable<ODataEntity<R>>;
+    call(params: P | null, options?: ODataEntitiesOptions): Observable<ODataEntities<R>>;
+    call(params: P | null, options?: ODataPropertyOptions): Observable<ODataProperty<R>>;
+    call(params: P | null, options?: ODataNoneOptions): Observable<null>;
+    /**
+     * Execute the action and return the result as a property
+     * @param params Parameters for the action
+     * @param options Options for the request
+     * @returns Observable of the result of the action
+     */
+    callProperty(params: P | null, options?: ODataOptions): Observable<R | null>;
+    /**
+     * Execute the action and return the result as a entity
+     * @param params Parameters for the action
+     * @param options Options for the request
+     * @returns Observable of the result of the action
+     */
+    callEntity(params: P | null, options?: ODataOptions): Observable<R | null>;
+    /**
+     * Execute the action and return the result as a model
+     * @param params Parameters for the action
+     * @param options Options for the request
+     * @returns Observable of the result of the action
+     */
+    callModel<M extends ODataModel<R>>(params: P | null, options?: ODataOptions): Observable<M | null>;
+    /**
+     * Execute the action and return the result as a entities
+     * @param params Parameters for the action
+     * @param options Options for the request
+     * @returns Observable of the result of the action
+     */
+    callEntities(params: P | null, options?: ODataOptions): Observable<R[] | null>;
+    /**
+     * Execute the action and return the result as a collection
+     * @param params Parameters for the action
+     * @param options Options for the request
+     * @returns Observable of the result of the action
+     */
+    callCollection<M extends ODataModel<R>, C extends ODataCollection<R, M>>(params: P | null, options?: ODataOptions): Observable<C | null>;
 }

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

@@ -1,16 +1,16 @@
 import { Observable, Subject } from 'rxjs';
-import { ODataResource } from '../resource';
-import { ODataRequest } from '../request';
 import { ODataApi } from '../../api';
+import { ODataRequest } from '../request';
+import { ODataResource } from '../resource';
 import { ODataResponse } from '../responses';
-import { HttpOptions } from './options';
+import { ODataOptions } from './options';
 export declare class ODataBatchRequest<T> extends Subject<ODataResponse<T>> {
     request: ODataRequest<any>;
     constructor(request: ODataRequest<any>);
     toString(): string;
     onLoad(content: string[], status: {
         code: number;
-        text: string;
+        message: string;
     }): void;
     onError(content: string[], status: {
         code: number;
@@ -22,11 +22,16 @@ export declare class ODataBatchRequest<T> extends Subject<ODataResponse<T>> {
  * https://www.odata.org/getting-started/advanced-tutorial/#batch
  */
 export declare class ODataBatchResource extends ODataResource<any> {
-    private requests;
-    clone(): ODataBatchResource;
-    schema(): undefined;
+    private _requests;
+    requests(): ODataRequest<any>[];
     static factory(api: ODataApi): ODataBatchResource;
-    post(func: (batch: ODataBatchResource) => void, options?: HttpOptions): Observable<ODataResponse<any>>;
+    /**
+     * Execute the batch request
+     * @param ctx The context for the request
+     * @param options The options of the batch request
+     * @returns The result of execute the context
+     */
+    exec<R>(ctx: (batch: this) => Observable<R>, options?: ODataOptions): Observable<R>;
     body(): string;
     static buildBody(batchBoundary: string, requests: ODataBatchRequest<any>[]): string;
     static handleResponse(requests: ODataBatchRequest<any>[], response: ODataResponse<any>): void;

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

@@ -1,22 +1,19 @@
 import { Observable } from 'rxjs';
-import { ODataPathSegments } from '../path-segments';
-import { ODataQueryOptions } from '../query-options';
-import { ODataResource } from '../resource';
-import { HttpOptions } from './options';
 import { ODataApi } from '../../api';
-import { Filter } from '../builder';
-export declare class ODataCountResource extends ODataResource<any> {
-    static factory(api: ODataApi, segments: ODataPathSegments, query: ODataQueryOptions): ODataCountResource;
-    clone(): ODataCountResource;
-    schema(): undefined;
-    get segment(): {
-        entitySet(): import("../path-segments").SegmentHandler;
-        navigationProperty(): import("../path-segments").SegmentHandler;
-    };
-    get query(): {
-        search(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        filter(opts?: Filter | undefined): import("../query-options").OptionHandler<Filter>;
-    };
-    get(options?: HttpOptions): Observable<number>;
-    fetch(options?: HttpOptions): Observable<number>;
+import { ODataPathSegments } from '../path';
+import { ODataQueryOptions } from '../query';
+import { ODataResource } from '../resource';
+import { ODataOptions } from './options';
+export declare class ODataCountResource<T> extends ODataResource<T> {
+    static factory<T>(api: ODataApi, { segments, query, }: {
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<T>;
+    }): ODataCountResource<T>;
+    protected get(options?: ODataOptions): Observable<number>;
+    /**
+     * Fetch the count of the set.
+     * @param options Options for the request
+     * @returns The count of the set
+     */
+    fetch(options?: ODataOptions): Observable<number>;
 }