angular-odata 0.100.1 → 0.101.0

package/lib/cache/cache.d.ts

@@ -1,6 +1,13 @@
 import { Observable } from 'rxjs';
 import { ODataRequest, ODataResponse } from '../resources';
 import { Cache } from '../types';
+/**
+ * A cache entry that holds a payload, a last read time, and a timeout for the entry.
+ * @param payload The payload to cache.
+ * @param lastRead The last read time.
+ * @param timeout The timeout.
+ * @param tags Some tags to identify the entry.
+ */
 export interface ODataCacheEntry<T> {
     payload: T;
     lastRead: number;
@@ -15,28 +22,82 @@ export declare abstract class ODataCache implements Cache {
     });
     abstract getResponse(req: ODataRequest<any>): ODataResponse<any> | undefined;
     abstract putResponse(req: ODataRequest<any>, res: ODataResponse<any>): void;
+    /**
+     * Using the resource on the request build an array of string to identify the scope of the request
+     * @param req The request with the resource to build the scope
+     * @returns Array of string to identify the scope of the request
+     */
     scope(req: ODataRequest<any>): string[];
-    tags(req: ODataRequest<any>, res: ODataResponse<any>): string[];
+    /**
+     * Using the odata context on the response build an array of string to identify the tags of the response
+     * @param res The response to build the tags
+     * @returns Array of string to identify the tags of the response
+     */
+    tags(res: ODataResponse<any>): string[];
+    /**
+     * Build an entry from a payload and some options
+     * @param payload The payload to store in the cache
+     * @param timeout The timeout for the entry
+     * @param tags The tags for the entry
+     * @returns The entry to store in the cache
+     */
     buildEntry<T>(payload: T, { timeout, tags }: {
         timeout?: number;
         tags?: string[];
     }): ODataCacheEntry<T>;
+    /**
+     * Build a key from store an entry in the cache
+     * @param names The names of the entry
+     * @returns The key for the entry
+     */
     buildKey(names: string[]): string;
+    /**
+     * Put some payload in the cache
+     * @param name The name for the entry
+     * @param payload The payload to store in the cache
+     * @param timeout The timeout for the entry
+     * @param scope The scope for the entry
+     * @param tags The tags for the entry
+     */
     put<T>(name: string, payload: T, { timeout, scope, tags, }?: {
         timeout?: number;
         scope?: string[];
         tags?: string[];
     }): void;
+    /**
+     * Return the payload from the cache if it exists and is not expired
+     * @param name The name of the entry
+     * @param scope The scope of the entry
+     * @returns The payload of the entry
+     */
     get<T>(name: string, { scope }?: {
         scope?: string[];
     }): T;
+    /**
+     * Remove all cache entries that are matching with the given options
+     * @param options The options to forget
+     */
     forget({ name, scope, tags, }?: {
         name?: string;
         scope?: string[];
         tags?: string[];
     }): void;
+    /**
+     * Remove all cache entries
+     */
     flush(): void;
+    /**
+     * Check if the entry is expired
+     * @param entry The cache entry
+     * @returns Boolean indicating if the entry is expired
+     */
     isExpired(entry: ODataCacheEntry<any>): boolean;
+    /**
+     * Using the request, handle the fetching of the response
+     * @param req The request to fetch
+     * @param res$ Observable of the response
+     * @returns
+     */
     handleRequest(req: ODataRequest<any>, res$: Observable<ODataResponse<any>>): Observable<ODataResponse<any>>;
     private handleFetch;
     private handleMutate;

package/lib/cache/memory.d.ts

@@ -4,6 +4,16 @@ export declare class ODataInMemoryCache extends ODataCache {
     constructor({ timeout }?: {
         timeout?: number;
     });
+    /**
+     * Store the response in the cache
+     * @param req The request with the resource to store the response
+     * @param res The response to store in the cache
+     */
     putResponse(req: ODataRequest<any>, res: ODataResponse<any>): void;
+    /**
+     * Restore the response from the cache
+     * @param req The request with the resource to get the response
+     * @returns The response from the cache
+     */
     getResponse(req: ODataRequest<any>): ODataResponse<any> | undefined;
 }

package/lib/cache/storage.d.ts

@@ -8,9 +8,28 @@ export declare class ODataInStorageCache extends ODataCache {
         name: string;
         storage?: Storage;
     });
+    /**
+     * Store the cache in the storage
+     */
     store(): void;
+    /**
+     * Restore the cache from the storage
+     */
     restore(): void;
+    /**
+     * Flush the cache and clean the storage
+     */
     flush(): void;
+    /**
+     * Store the response in the cache
+     * @param req The request with the resource to store the response
+     * @param res The response to store in the cache
+     */
     putResponse(req: ODataRequest<any>, res: ODataResponse<any>): void;
+    /**
+     * Restore the response from the cache
+     * @param req The request with the resource to get the response
+     * @returns The response from the cache
+     */
     getResponse(req: ODataRequest<any>): ODataResponse<any> | undefined;
 }

package/lib/constants.d.ts

@@ -42,6 +42,7 @@ export declare const BINARY = "binary";
 export declare const BOUNDARY_PREFIX_SUFFIX = "--";
 export declare const BATCH_PREFIX = "batch_";
 export declare const CHANGESET_PREFIX = "changeset_";
+export declare const DEFAULT_METADATA = "minimal";
 export declare const DEFAULT_STRIP_METADATA = "full";
 export declare const DEFAULT_FETCH_POLICY = "network-only";
 export declare const DEFAULT_TIMEOUT = 60;

package/lib/models/collection.d.ts

@@ -68,19 +68,20 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     private addReference;
     private _addModel;
     private addModel;
-    add(model: M, { silent, reparent, server, position, }?: {
+    add(model: M, { silent, reparent, server, merge, position, }?: {
         silent?: boolean;
         reparent?: boolean;
         server?: boolean;
+        merge?: boolean;
         position?: number;
-    }): Observable<this>;
+    }): Observable<M>;
     private removeReference;
     private _removeModel;
     private removeModel;
     remove(model: M, { silent, server, }?: {
         silent?: boolean;
         server?: boolean;
-    }): Observable<this>;
+    }): Observable<M>;
     create(attrs?: T, { silent, server, }?: {
         silent?: boolean;
         server?: boolean;
@@ -92,6 +93,9 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
         path?: string | string[];
         silent?: boolean;
     }): void;
+    clear({ silent }?: {
+        silent?: boolean;
+    }): void;
     assign(objects: Partial<T>[] | {
         [name: string]: any;
     }[] | M[], { reset, reparent, silent, }?: {
@@ -102,8 +106,8 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     query(func: (q: ODataQueryOptionsHandler<T>) => void): this;
     callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataQueryArgumentsOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
     callAction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataQueryArgumentsOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
-    private _unsubscribe;
-    private _subscribe;
+    private _unlink;
+    private _link;
     private _findEntry;
     equals(other: ODataCollection<T, ODataModel<T>>): boolean;
     get [Symbol.toStringTag](): string;

package/lib/models/model.d.ts

@@ -55,13 +55,13 @@ export declare class ODataModel<T> {
         resolve?: boolean;
     }): {
         [name: string]: any;
-    } | undefined;
+    } | null | undefined;
     referenced(field: ODataModelField<any>, { field_mapping, resolve, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
     }): {
         [name: string]: any;
-    } | undefined;
+    } | null | undefined;
     _errors?: {
         [key: string]: any;
     };
@@ -109,6 +109,9 @@ export declare class ODataModel<T> {
         path?: string | string[];
         silent?: boolean;
     }): void;
+    clear({ silent }?: {
+        silent?: boolean;
+    }): void;
     assign(entity: Partial<T> | {
         [name: string]: any;
     }, { reset, reparent, silent, }?: {
@@ -155,7 +158,7 @@ export declare class ODataModel<T> {
     fetchNavigationProperty<S>(name: keyof T | string, responseType: 'model' | 'collection', { ...options }?: {} & ODataQueryArgumentsOptions<S>): Observable<ODataModel<S> | ODataCollection<S, ODataModel<S>> | null>;
     getValue<P>(name: keyof T | string, options?: ODataOptions): Observable<P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null>;
     setReference<N>(name: keyof T | string, model: ODataModel<N> | ODataCollection<N, ODataModel<N>> | null, options?: ODataOptions): Observable<this>;
-    getReference<P>(name: keyof T | string): ODataModel<P> | ODataCollection<P, ODataModel<P>>;
+    getReference<P>(name: keyof T | string): ODataModel<P> | ODataCollection<P, ODataModel<P>> | null;
     equals(other: ODataModel<T>): boolean;
     get [Symbol.toStringTag](): string;
     collection(): ODataCollection<T, ODataModel<T>> | undefined;

package/lib/models/options.d.ts

@@ -1,7 +1,7 @@
 import { Subscription } from 'rxjs';
 import { EntityKey, ODataEntitiesAnnotations, ODataEntityAnnotations, ODataEntityResource, ODataEntitySetResource, ODataNavigationPropertyResource, ODataPropertyResource, ODataQueryOptions, ODataQueryOptionsHandler, ODataResource, ODataSingletonResource } from '../resources';
 import { ODataEntitySet, ODataStructuredType, ODataStructuredTypeFieldParser } from '../schema';
-import { OptionsHelper } from '../types';
+import { ParserOptions } from '../types';
 import type { ODataCollection } from './collection';
 import type { ODataModel } from './model';
 export declare type ODataModelEventType = 'change' | 'reset' | 'update' | 'destroy' | 'add' | 'remove' | 'invalid' | 'request' | 'sync' | 'attach';
@@ -93,6 +93,7 @@ export declare class ODataModelField<F> {
     min?: number;
     max?: number;
     pattern?: RegExp;
+    parserOptions?: ParserOptions;
     constructor(options: ODataModelOptions<any>, { name, field, parser, ...opts }: ODataModelFieldOptions<F>);
     get api(): import("angular-odata").ODataApi;
     get type(): string;
@@ -102,7 +103,7 @@ export declare class ODataModelField<F> {
     configure({ findOptionsForType, concurrency, options, }: {
         findOptionsForType: (type: string) => ODataModelOptions<any> | undefined;
         concurrency: boolean;
-        options: OptionsHelper;
+        options: ParserOptions;
     }): void;
     isKey(): boolean;
     hasReferentials(): boolean;
@@ -116,9 +117,9 @@ export declare class ODataModelField<F> {
         navigation?: boolean;
     }): any;
     defaults(): any;
-    deserialize(value: any, options?: OptionsHelper): F;
-    serialize(value: F, options?: OptionsHelper): any;
-    encode(value: F, options?: OptionsHelper): any;
+    deserialize(value: any, options?: ParserOptions): F;
+    serialize(value: F, options?: ParserOptions): any;
+    encode(value: F, options?: ParserOptions): any;
     resourceFactory<T, F>(base: ODataResource<T>): ODataNavigationPropertyResource<F> | ODataPropertyResource<F>;
     annotationsFactory(base: ODataEntityAnnotations): ODataEntityAnnotations | ODataEntitiesAnnotations;
     schemaFactory<T, F>(base: ODataStructuredType<T>): ODataStructuredType<F> | undefined;
@@ -166,7 +167,7 @@ export declare class ODataModelOptions<T> {
     findChildOptions(predicate: (options: ODataModelOptions<any>) => boolean): ODataModelOptions<any> | undefined;
     configure({ findOptionsForType, options, }: {
         findOptionsForType: (type: string) => ODataModelOptions<any> | undefined;
-        options: OptionsHelper;
+        options: ParserOptions;
     }): void;
     fields({ include_navigation, include_parents, }?: {
         include_parents?: boolean;
@@ -206,7 +207,7 @@ export declare class ODataModelOptions<T> {
         resolve?: boolean;
     }): {
         [name: string]: any;
-    } | undefined;
+    } | null | undefined;
     resolveReferenced(value: ODataModel<T> | T | {
         [name: string]: any;
     } | null, field: ODataModelField<any>, { field_mapping, resolve, }?: {
@@ -214,7 +215,7 @@ export declare class ODataModelOptions<T> {
         resolve?: boolean;
     }): {
         [name: string]: any;
-    } | undefined;
+    } | null | undefined;
     validate(self: ODataModel<T>, { method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
@@ -269,6 +270,6 @@ export declare class ODataModelOptions<T> {
     private _setStructured;
     private _setValue;
     private _set;
-    private _unsubscribe;
-    private _subscribe;
+    private _unlink;
+    private _link;
 }

package/lib/options.d.ts

@@ -1,5 +1,5 @@
-import { ApiOptions, FetchPolicy, ODataMetadataType, ODataVersion, OptionsHelper, QueryOptionNames } from './types';
-export declare class ODataApiOptions implements ApiOptions, OptionsHelper {
+import { ApiOptions, FetchPolicy, ODataMetadataType, ODataVersion, ParserOptions, QueryOptionNames } from './types';
+export declare class ODataApiOptions implements ApiOptions {
     /**
      * Default OData version
      */
@@ -77,10 +77,6 @@ export declare class ODataApiOptions implements ApiOptions, OptionsHelper {
     deleteRefBy: 'path' | 'id';
     nonParenthesisForEmptyParameterFunction: boolean;
     constructor(config: ApiOptions);
-    get helper(): import("./helper").ODataVersionHelper;
-}
-export declare class ODataParserOptions implements OptionsHelper {
-    version: ODataVersion;
-    constructor(config: OptionsHelper);
+    get parserOptions(): ParserOptions;
     get helper(): import("./helper").ODataVersionHelper;
 }

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

@@ -8,22 +8,79 @@ export declare class ODataQueryOptionHandler<T> {
     private o;
     private n;
     constructor(o: Map<QueryOptionNames, any>, n: QueryOptionNames);
+    /**
+     * The name of the managed odata query option.
+     */
     get name(): QueryOptionNames;
+    /**
+     * Converts the managed odata query option to a json object.
+     * @returns {any}
+     */
     toJSON(): any;
+    /**
+     * Returns a boolean indicating if the managed odata query option is empty.
+     * @returns True if the managed odata query option is empty.
+     */
     empty(): boolean;
+    /**
+     * Get or Set the value of the managed odata query option.
+     * @param v The value to set.
+     * @returns
+     */
     value(v?: any): any;
     private assertArray;
+    /**
+     * Push value to the managed odata query option.
+     * @param value Value to push
+     */
     push(value: any): void;
+    /**
+     * Remove value from the managed odata query option.
+     * @param value Value to remove
+     */
     remove(value: any): void;
+    /**
+     * Return value at index of the managed odata query option.
+     * @param index Index of the value
+     * @returns The value
+     */
     at(index: number): any;
     private assertObject;
+    /**
+     * Set the value for path in the managed odata query option.
+     * @param path Path for set the value
+     * @param value Value to set
+     */
     set(path: string, value: any): void;
+    /**
+     * Get the value for path from the managed odata query option.
+     * @param path The path from get the value
+     * @param def Default if not found
+     * @returns
+     */
     get(path: string, def?: any): any;
+    /**
+     * Unset the value for path in the managed odata query option.
+     * @param path
+     */
     unset(path: string): void;
+    /**
+     * Test if the managed odata query option has the value.
+     * @param path The path fot test if the value is set
+     * @returns Boolean indicating if the value is set
+     */
     has(path: string): boolean;
+    /**
+     * Merge values from object into the managed odata query option.
+     * @param values Object to merge
+     * @returns
+     */
     assign(values: {
         [attr: string]: any;
     }): Object;
+    /**
+     * Clear the managed odata query option.
+     */
     clear(): void;
 }
 export declare class ODataQueryOptionsHandler<T> {
@@ -43,12 +100,22 @@ export declare class ODataQueryOptionsHandler<T> {
      * @returns The normalized value
      */
     normalize(value: any): any;
+    /**
+     * Build and return a handler for modifying the $select option.
+     * If opts is given then set te value as new value for $select.
+     * @param opts Select<T> value or builder function for SelectExpression<T>
+     */
     select(opts: (builder: {
         s: T;
         e: () => SelectExpression<T>;
     }, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
     select(opts: Select<T>): ODataQueryOptionHandler<T>;
     select(): ODataQueryOptionHandler<T>;
+    /**
+     * Build and return a handler for modifying the $expand option.
+     * If opts is given then set te value as new value for $expand.
+     * @param opts Expand<T> value or builder function for ExpandExpression<T>
+     */
     expand(opts: (builder: {
         s: T;
         e: () => ExpandExpression<T>;
@@ -56,7 +123,10 @@ export declare class ODataQueryOptionsHandler<T> {
     expand(opts: Expand<T>): ODataQueryOptionHandler<T>;
     expand(): ODataQueryOptionHandler<T>;
     /**
+     * Build and return a handler for modifying the $compute option.
+     * If opts is given then set te value as new value for $compute.
      * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptioncompute
+     * @param opts string value or builder function for ComputeExpression<T>
      */
     compute(opts: (builder: {
         s: T;
@@ -67,17 +137,35 @@ export declare class ODataQueryOptionsHandler<T> {
     compute(opts: string): ODataQueryOptionHandler<T>;
     compute(): 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.
      * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptionformat
+     * @param opts string value for format
      */
     format(opts: string): ODataQueryOptionHandler<T>;
     format(): ODataQueryOptionHandler<T>;
+    /**
+     * Build and return a handler for modifying the $transform option.
+     * If opts is given then set te value as new value for $transform.
+     * @param opts string value for transform
+     */
     transform(opts: Transform<T>): ODataQueryOptionHandler<T>;
     transform(): ODataQueryOptionHandler<T>;
+    /**
+     * Build and return a handler for modifying the $search option.
+     * If opts is given then set te value as new value for $search.
+     * @param opts string value or builder function for SearchExpression<T>
+     */
     search(opts: (builder: {
         e: (connector: SearchConnector) => SearchExpression<T>;
     }, current?: SearchExpression<T>) => SearchExpression<T>): SearchExpression<T>;
     search(opts: string): ODataQueryOptionHandler<T>;
     search(): ODataQueryOptionHandler<T>;
+    /**
+     * Build and return a handler for modifying the $filter option.
+     * If opts is given then set te value as new value for $filter.
+     * @param opts Filter<T> value or builder function for FilterExpression<T>
+     */
     filter(opts: (builder: {
         s: T;
         e: (connector?: FilterConnector) => FilterExpression<T>;
@@ -86,23 +174,54 @@ export declare class ODataQueryOptionsHandler<T> {
     }, current?: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
     filter(opts: Filter<T>): ODataQueryOptionHandler<T>;
     filter(): ODataQueryOptionHandler<T>;
+    /**
+     * Build and return a handler for modifying the $orderby option.
+     * If opts is given then set te value as new value for $orderby.
+     * @param opts OrderBy<T> value or builder function for OrderByExpression<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>;
+    /**
+     * Build and return a handler for modifying the $top option.
+     * If opts is given then set te value as new value for $top.
+     * @param opts number value
+     */
     top(opts: number): ODataQueryOptionHandler<T>;
     top(): ODataQueryOptionHandler<T>;
+    /**
+     * Build and return a handler for modifying the $skip option.
+     * If opts is given then set te value as new value for $skip.
+     * @param opts number value
+     */
     skip(opts: number): ODataQueryOptionHandler<T>;
     skip(): ODataQueryOptionHandler<T>;
+    /**
+     * Build and return a handler for modifying the $skiptoken option.
+     * If opts is given then set te value as new value for $skiptoken.
+     * @param opts string value
+     */
     skiptoken(opts: string): ODataQueryOptionHandler<T>;
     skiptoken(): ODataQueryOptionHandler<T>;
+    /**
+     * Shortcut for set $top, $skip, $skiptoken.
+     * @param param0 skip or top or skiptoken
+     */
     paging({ skip, skiptoken, top, }?: {
         skip?: number;
         skiptoken?: string;
         top?: number;
     }): void;
+    /**
+     * Shortcut for clear pagination by unset $top, $skip, $skiptoken.
+     */
     clearPaging(): void;
+    /**
+     * Apply the given query options to the current query.
+     * @param query The query to be applied.
+     */
     apply(query: ODataQueryArguments<T>): void;
 }

package/lib/resources/resource.d.ts

@@ -3,7 +3,7 @@ import { ODataApi } from '../api';
 import { ODataCollection, ODataModel } from '../models';
 import { ODataStructuredType } from '../schema';
 import { ODataSchemaElement } from '../schema/element';
-import { OptionsHelper, QueryOptionNames } from '../types';
+import { ParserOptions, QueryOptionNames } from '../types';
 import { ODataPathSegments, ODataPathSegmentsHandler } from './path';
 import { ODataQueryOptions, ODataQueryOptionsHandler, QueryCustomType } from './query';
 import { ODataEntitiesAnnotations, ODataEntityAnnotations } from './responses/index';
@@ -60,9 +60,9 @@ export declare class ODataResource<T> {
     toString(): string;
     clone(): ODataResource<T>;
     private __parser;
-    deserialize(value: any, options?: OptionsHelper): any;
-    serialize(value: any, options?: OptionsHelper): any;
-    encode(value: any, options?: OptionsHelper): any;
+    deserialize(value: any, options?: ParserOptions): any;
+    serialize(value: any, options?: ParserOptions): any;
+    encode(value: any, options?: ParserOptions): any;
     toJSON(): {
         segments: any[];
         options: {};

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

@@ -1,4 +1,4 @@
-import { ODataMetadataType, ODataVersion, OptionsHelper, ResponseOptions } from '../../types';
+import { ODataMetadataType, ODataVersion, ParserOptions, ResponseOptions } from '../../types';
 export declare class ODataResponseOptions implements ResponseOptions {
     version: ODataVersion;
     streaming?: boolean;
@@ -7,7 +7,7 @@ export declare class ODataResponseOptions implements ResponseOptions {
     location?: string;
     cacheability?: 'public' | 'private' | 'no-cache' | 'no-store';
     maxAge?: number;
-    constructor(config: OptionsHelper);
+    constructor(config: ParserOptions);
     get helper(): import("../../helper").ODataVersionHelper;
     clone(): ODataResponseOptions;
     setFeatures(features: string): void;

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

@@ -1,21 +1,16 @@
+import { HttpErrorResponse, HttpResponseBase } from '@angular/common/http';
 import { Observable, Subject } from 'rxjs';
 import { ODataApi } from '../../api';
 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>> {
+export declare class ODataBatchRequest<T> extends Subject<HttpResponseBase> {
     request: ODataRequest<any>;
     constructor(request: ODataRequest<any>);
     toString(): string;
-    onLoad(content: string[], status: {
-        code: number;
-        message: string;
-    }): void;
-    onError(content: string[], status: {
-        code: number;
-        text: string;
-    }): void;
+    onLoad(response: HttpResponseBase): void;
+    onError(response: HttpErrorResponse): void;
 }
 /**
  * OData Batch Resource
@@ -24,6 +19,8 @@ export declare class ODataBatchRequest<T> extends Subject<ODataResponse<T>> {
 export declare class ODataBatchResource extends ODataResource<any> {
     private _requests;
     requests(): ODataRequest<any>[];
+    private _responses;
+    responses(): HttpResponseBase[] | null;
     static factory(api: ODataApi): ODataBatchResource;
     clone(): ODataBatchResource;
     private storeRequester;
@@ -34,7 +31,7 @@ export declare class ODataBatchResource extends ODataResource<any> {
      * @returns The result of execute the context
      */
     add<R>(ctx: (batch: this) => Observable<R>): Observable<R>;
-    send(options?: ODataOptions): void;
+    send(options?: ODataOptions): Observable<null | ODataResponse<string>>;
     /**
      * Execute the batch request
      * @param ctx The context for the request
@@ -44,5 +41,5 @@ export declare class ODataBatchResource extends ODataResource<any> {
     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;
+    static parseResponse(requests: ODataBatchRequest<any>[], response: ODataResponse<string>): HttpResponseBase[];
 }

package/lib/schema/callable.d.ts

@@ -1,4 +1,4 @@
-import { CallableConfig, OptionsHelper, Parser } from '../types';
+import { CallableConfig, ParserOptions, Parser } from '../types';
 import { ODataSchemaElement } from './element';
 import { ODataCallableParser } from './parsers';
 import { ODataSchema } from './schema';
@@ -18,21 +18,21 @@ export declare class ODataCallable<R> extends ODataSchemaElement {
      * @param options Options for deserialization
      * @returns Deserialized value
      */
-    deserialize(value: any, options?: OptionsHelper): any;
+    deserialize(value: any, options?: ParserOptions): any;
     /**
      * Serialize the given value for the callable.
      * @param value Value to serialize
      * @param options Options for serialization
      * @returns Serialized value
      */
-    serialize(value: any, options?: OptionsHelper): any;
+    serialize(value: any, options?: ParserOptions): any;
     /**
      * Encode the given value for the callable.
      * @param value Value to encode
      * @param options Options for encoding
      * @returns Encoded value
      */
-    encode(value: any, options?: OptionsHelper): any;
+    encode(value: any, options?: ParserOptions): any;
     /**
      * Returns the binding parameter of the callable.
      * @returns The binding parameter of the callable.