angular-odata 0.110.0 → 0.120.0

package/lib/client.d.ts

@@ -2,6 +2,7 @@ import { HttpClient, HttpEvent } from '@angular/common/http';
 import { Injector } from '@angular/core';
 import { Observable } from 'rxjs';
 import { ODataApi } from './api';
+import { ODataConfigLoader } from './loaders';
 import { ODataCollection, ODataModel } from './models/index';
 import { ODataActionResource, ODataBatchResource, ODataEntityResource, ODataEntitySetResource, ODataFunctionResource, ODataMetadataResource, ODataNavigationPropertyResource, ODataOptions, ODataResource, ODataResponse, ODataSegment, ODataSingletonResource } from './resources/index';
 import { ODataEntityService } from './services/entity';
@@ -9,9 +10,10 @@ import { ODataSettings } from './settings';
 import * as i0 from "@angular/core";
 export declare class ODataClient {
     private http;
-    private settings;
+    private loader;
     private injector;
-    constructor(http: HttpClient, settings: ODataSettings, injector: Injector);
+    settings?: ODataSettings;
+    constructor(http: HttpClient, loader: ODataConfigLoader, injector: Injector);
     /**
      * Resolve the api for the given value.
      * Where value is: string type or an string name or an instance of resource.
@@ -19,6 +21,7 @@ export declare class ODataClient {
      * @returns The api for the value.
      */
     apiFor(value?: ODataResource<any> | string): ODataApi;
+    defaultApi(): ODataApi;
     /**
      * Resolve the parser for the given string type.
      * @param type The string type of the parser.

package/lib/constants.d.ts

@@ -10,20 +10,21 @@ export declare const $INLINECOUNT = "$inlinecount";
 export declare const IF_MATCH_HEADER = "If-Match";
 export declare const IF_NONE_MATCH_HEADER = "If-None-Match";
 export declare const CONTENT_TYPE = "Content-Type";
-export declare const CACHE_CONTROL = "Cache-Control";
 export declare const HTTP11 = "HTTP/1.1";
 export declare const ACCEPT = "Accept";
 export declare const PREFER = "Prefer";
+export declare const CACHE_CONTROL = "Cache-Control";
+export declare const CACHE_CONTROL_HEADERS: string[];
 export declare const ODATA_VERSION = "OData-Version";
 export declare const ODATA_VERSION_HEADERS: string[];
-export declare const ETAG_HEADER = "ETag";
-export declare const ETAG_HEADERS: string[];
 export declare const LOCATION_HEADER = "Location";
 export declare const LOCATION_HEADERS: string[];
 export declare const ODATA_ENTITYID = "OData-EntityId";
 export declare const ODATA_ENTITYID_HEADERS: string[];
 export declare const PREFERENCE_APPLIED = "Preference-Applied";
 export declare const PREFERENCE_APPLIED_HEADERS: string[];
+export declare const ETAG_HEADER = "ETag";
+export declare const ETAG_HEADERS: string[];
 export declare const RETRY_AFTER = "Retry-After";
 export declare const RETRY_AFTER_HEADERS: string[];
 export declare const APPLICATION_JSON = "application/json";
@@ -62,3 +63,4 @@ export declare const COMPUTED: RegExp;
 export declare const OPTIMISTIC_CONCURRENCY: RegExp;
 export declare const DESCRIPTION: RegExp;
 export declare const LONG_DESCRIPTION: RegExp;
+export declare const OPTIONARL_PARAMETER: RegExp;

package/lib/index.d.ts

@@ -2,8 +2,8 @@ export * from './types';
 export * from './settings';
 export * from './api';
 export * from './client';
-export * from './tokens';
 export * from './module';
+export * from './loaders';
 export * from './utils/index';
 export * from './services/index';
 export * from './schema/index';

package/lib/loaders.d.ts

@@ -0,0 +1,15 @@
+import { Observable } from 'rxjs';
+import { ApiConfig } from './types';
+export declare abstract class ODataConfigLoader {
+    abstract loadConfigs(): Observable<ApiConfig[]>;
+}
+export declare class ODataConfigSyncLoader implements ODataConfigLoader {
+    private readonly passedConfigs;
+    constructor(passedConfigs: ApiConfig | ApiConfig[]);
+    loadConfigs(): Observable<ApiConfig[]>;
+}
+export declare class ODataConfigAsyncLoader implements ODataConfigLoader {
+    private readonly configs$;
+    constructor(configs$: Observable<ApiConfig> | Observable<ApiConfig>[] | Observable<ApiConfig[]>);
+    loadConfigs(): Observable<ApiConfig[]>;
+}

package/lib/models/collection.d.ts

@@ -11,6 +11,13 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
         ODataModelField<any> | null
     ] | null;
     _resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null;
+    _resources: {
+        parent: [
+            ODataModel<any> | ODataCollection<any, ODataModel<any>>,
+            ODataModelField<any> | null
+        ] | null;
+        resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null;
+    }[];
     _annotations: ODataEntitiesAnnotations<T>;
     _entries: ODataModelEntry<T, M>[];
     _model: typeof ODataModel;
@@ -28,6 +35,11 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     });
     isParentOf(child: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
     resource(): ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>;
+    pushResource(resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>): void;
+    popResource(): {
+        parent: [ODataModel<any> | ODataCollection<any, ODataModel<any>>, ODataModelField<any> | null] | null;
+        resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null;
+    } | undefined;
     attach(resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>): void;
     asEntitySet<R>(func: (collection: this) => R): R;
     annots(): ODataEntitiesAnnotations<T>;
@@ -56,12 +68,15 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     fetch({ withCount, ...options }?: ODataOptions & {
         withCount?: boolean;
     }): Observable<this>;
-    fetchMany(top: number, { withCount, ...options }?: ODataOptions & {
+    fetchAll({ withCount, ...options }?: ODataOptions & {
         withCount?: boolean;
     }): Observable<this>;
-    fetchAll({ withCount, ...options }?: ODataOptions & {
+    fetchMany(top: number, { withCount, ...options }?: ODataOptions & {
         withCount?: boolean;
     }): Observable<this>;
+    fetchOne({ withCount, ...options }?: ODataOptions & {
+        withCount?: boolean;
+    }): Observable<M | null>;
     /**
      * Save all models in the collection
      * @param relModel The model is relationship

package/lib/models/model.d.ts

@@ -15,10 +15,17 @@ export declare class ODataModel<T> {
         ODataModel<any> | ODataCollection<any, ODataModel<any>>,
         ODataModelField<any> | null
     ] | null;
+    _resource: ODataResource<T> | null;
+    _resources: {
+        parent: [
+            ODataModel<any> | ODataCollection<any, ODataModel<any>>,
+            ODataModelField<any> | null
+        ] | null;
+        resource: ODataResource<T> | null;
+    }[];
     _attributes: Map<string, any>;
     _changes: Map<string, any>;
     _relations: Map<string, ODataModelRelation<any>>;
-    _resource: ODataResource<T> | null;
     _annotations: ODataEntityAnnotations<T> | null;
     _reset: boolean;
     _reparent: boolean;
@@ -37,6 +44,11 @@ export declare class ODataModel<T> {
         reset?: boolean;
     });
     resource(): ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T>;
+    pushResource(resource: ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T>): void;
+    popResource(): {
+        parent: [ODataModel<any> | ODataCollection<any, ODataModel<any>>, ODataModelField<any> | null] | null;
+        resource: ODataResource<T> | null;
+    } | undefined;
     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;
@@ -48,7 +60,6 @@ export declare class ODataModel<T> {
     }): EntityKey<T> | {
         [name: string]: any;
     } | undefined;
-    isNew(): boolean;
     isParentOf(child: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
     referential(field: ODataModelField<any>, { field_mapping, resolve, }?: {
         field_mapping?: boolean;
@@ -144,14 +155,15 @@ export declare class ODataModel<T> {
     hasChanged({ include_navigation, }?: {
         include_navigation?: boolean;
     }): boolean;
+    isNew(): boolean;
     /**
      * Create an execution context for a given function, where the model is bound to its entity endpoint
      * @param ctx Context function
      * @returns The result of the context
      */
     asEntity<R>(ctx: (model: this) => R): R;
-    callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataFunctionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
-    callAction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataActionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
+    callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none' | 'blob' | 'arraybuffer', { ...options }?: {} & ODataFunctionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null | Blob | ArrayBuffer>;
+    callAction<P, R>(name: string, params: P | null, responseType?: 'property' | 'model' | 'collection' | 'none' | 'blob' | 'arraybuffer', { ...options }?: {} & ODataActionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null | Blob | ArrayBuffer>;
     cast<S>(type: string): ODataModel<S>;
     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>;

package/lib/models/options.d.ts

@@ -136,7 +136,7 @@ export declare class ODataModelField<F> {
             [name: string]: any;
         }[];
         reset?: boolean;
-    }): ODataModel<F> | ODataCollection<F, ODataModel<F>>;
+    }): ODataCollection<F, ODataModel<F>>;
 }
 export declare type ODataModelRelation<T> = {
     state: ODataModelState;
@@ -242,6 +242,7 @@ export declare class ODataModelOptions<T> {
     hasChanged(self: ODataModel<T>, { include_navigation }?: {
         include_navigation?: boolean;
     }): boolean;
+    hasKey(self: ODataModel<T>): boolean;
     asEntity<R, M extends ODataModel<T>>(self: M, func: (model: M) => R): R;
     toEntity(self: ODataModel<T>, { client_id, include_navigation, include_concurrency, include_computed, include_key, include_non_field, changes_only, field_mapping, chain, }?: {
         client_id?: boolean;

package/lib/module.d.ts

@@ -1,12 +1,18 @@
-import { ModuleWithProviders } from '@angular/core';
-import { ODataSettings } from './settings';
+import { InjectionToken, ModuleWithProviders, Provider } from '@angular/core';
+import { ODataConfigSyncLoader } from './loaders';
 import { ApiConfig } from './types';
 import * as i0 from "@angular/core";
-import * as i1 from "@angular/common/http";
-export declare function createSettings(configs: ApiConfig[]): ODataSettings;
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/common/http";
+export interface PassedInitialConfig {
+    config?: ApiConfig | ApiConfig[];
+    loader?: Provider;
+}
+export declare const ODATA_CONFIG: InjectionToken<ApiConfig>;
+export declare function createSyncLoader(passedConfig: PassedInitialConfig): ODataConfigSyncLoader;
 export declare class ODataModule {
-    static forRoot(...configs: ApiConfig[]): ModuleWithProviders<ODataModule>;
+    static forRoot(passedConfig: PassedInitialConfig): ModuleWithProviders<ODataModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ODataModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ODataModule, never, [typeof i1.HttpClientModule], never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ODataModule, never, [typeof i1.CommonModule, typeof i2.HttpClientModule], never>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ODataModule>;
 }

package/lib/options.d.ts

@@ -20,6 +20,10 @@ export declare class ODataApiOptions implements ApiOptions {
      * Strip metadata from the response
      */
     stripMetadata: ODataMetadataType;
+    /**
+     * Use JSON Batch Format
+     */
+    jsonBatchFormat: boolean;
     /**
      * Cache fetch policy
      */
@@ -81,6 +85,10 @@ export declare class ODataApiOptions implements ApiOptions {
          * @link http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part1-protocol/odata-v4.0-errata02-os-part1-protocol-complete.html#_Toc406398237
          */
         includeAnnotations?: string;
+        /**
+         * @link https://devblogs.microsoft.com/odata/extension-omit-null-value-properties-in-asp-net-core-odata/
+         */
+        omitNullValues?: boolean;
     };
     constructor(config: ApiOptions);
     get parserOptions(): ParserOptions;

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

@@ -0,0 +1,44 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { FilterExpression, FilterExpressionBuilder } from './filter';
+import { Renderable } from './syntax';
+export declare class CountField<T extends object> 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;
+    filter(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): any;
+    clone(): CountField<object>;
+    private option;
+}
+export declare type CountExpressionBuilder<T> = {
+    t: Readonly<Required<T>>;
+    e: () => CountExpression<T>;
+};
+export declare class CountExpression<T> extends Expression<T> {
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    static count<T extends object>(opts: (builder: CountExpressionBuilder<T>, current?: CountExpression<T>) => CountExpression<T>, current?: CountExpression<T>): CountExpression<T>;
+    private _add;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    clone(): CountExpression<unknown>;
+    field<F extends Object>(field: F[], opts?: (e: {
+        t: F;
+        f: CountField<F>;
+    }) => CountExpression<F>): CountExpression<F>;
+}

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

@@ -1,5 +1,6 @@
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
+import { CountExpression, CountField } from './count';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
 export declare type FilterConnector = 'and' | 'or';
 export declare type FilterExpressionBuilder<T> = {
@@ -53,6 +54,10 @@ export declare class FilterExpression<F> extends Expression<F> {
         t: N;
         e: (connector?: FilterConnector) => FilterExpression<N>;
     }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
+    count<N extends object>(left: N[], opts?: (e: {
+        t: N;
+        f: CountField<N>;
+    }) => CountExpression<N>): FilterExpression<F>;
     isof(type: string): FilterExpression<F>;
     isof(left: F, type: string): FilterExpression<F>;
 }

package/lib/resources/resource.d.ts

@@ -41,7 +41,7 @@ export declare class ODataResource<T> {
     clearKey(): void | undefined;
     asModel<M extends ODataModel<T>>(entity?: Partial<T> | {
         [name: string]: any;
-    }, { annots, reset }?: {
+    }, { annots, reset, }?: {
         annots?: ODataEntityAnnotations<T>;
         reset?: boolean;
     }): M;

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

@@ -13,5 +13,6 @@ export declare class ODataResponseOptions implements ResponseOptions {
     setFeatures(features: string): void;
     setVersion(version: string): void;
     setLocation(location: string): void;
+    setPreferenceApplied(preference: string): void;
     setCache(cacheControl: string): void;
 }

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

@@ -6,7 +6,7 @@ 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';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions, ODataPropertyOptions } from './options';
 export declare class ODataActionResource<P, R> extends ODataResource<R> {
     static factory<P, R>(api: ODataApi, { path, schema, segments, query, }: {
         path?: string;
@@ -26,7 +26,18 @@ export declare class ODataActionResource<P, R> extends ODataResource<R> {
     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>;
+    call(params: P | null, options?: {
+        alias?: boolean;
+        responseType?: 'blob';
+    } & ODataOptions): Observable<Blob>;
+    call(params: P | null, options?: {
+        alias?: boolean;
+        responseType?: 'arraybuffer';
+    } & ODataOptions): Observable<ArrayBuffer>;
+    call(params: P | null, options?: {
+        alias?: boolean;
+        responseType?: 'none';
+    } & ODataOptions): Observable<null>;
     /**
      * Execute the action and return the result as a property
      * @param params Parameters for the action
@@ -62,4 +73,10 @@ export declare class ODataActionResource<P, R> extends ODataResource<R> {
      * @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>;
+    callArraybuffer(params: P | null, { alias, ...options }?: {
+        alias?: boolean;
+    } & ODataOptions): Observable<ArrayBuffer>;
+    callBlob(params: P | null, { alias, ...options }?: {
+        alias?: boolean;
+    } & ODataOptions): Observable<Blob>;
 }

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

@@ -7,8 +7,14 @@ import { ODataResponse } from '../responses';
 import { ODataOptions } from './options';
 export declare class ODataBatchRequest<T> extends Subject<HttpResponseBase> {
     request: ODataRequest<any>;
+    id: string;
+    group: string;
     constructor(request: ODataRequest<any>);
     toString(): string;
+    toLegacy(): string;
+    toJson(): {
+        [name: string]: any;
+    };
     onLoad(response: HttpResponseBase): void;
     onError(response: HttpErrorResponse): void;
 }
@@ -30,16 +36,21 @@ export declare class ODataBatchResource extends ODataResource<any> {
      * @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): Observable<null | ODataResponse<string>>;
+    add<R>(ctx: (batch: this) => R): R;
+    send(options?: ODataOptions): Observable<ODataResponse<any>>;
+    private sendJson;
+    private sendLegacy;
     /**
      * 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>;
+    exec<R>(ctx: (batch: this) => R, options?: ODataOptions): Observable<[R, ODataResponse<string>]>;
     body(): string;
-    static buildBody(batchBoundary: string, requests: ODataBatchRequest<any>[]): string;
-    static parseResponse(requests: ODataBatchRequest<any>[], response: ODataResponse<string>): HttpResponseBase[];
+    json(): Object;
+    static buildLegacyBody(batchBoundary: string, requests: ODataBatchRequest<any>[]): string;
+    static buildJsonBody(requests: ODataBatchRequest<any>[]): Object;
+    static parseLegacyResponse(requests: ODataBatchRequest<any>[], response: ODataResponse<string>): HttpResponseBase[];
+    static parseJsonResponse(requests: ODataBatchRequest<any>[], response: ODataResponse<any>): HttpResponseBase[];
 }

package/lib/resources/types/entity-set.d.ts

@@ -33,10 +33,11 @@ export declare class ODataEntitySetResource<T> extends ODataResource<T> {
         withCount?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<ODataEntities<T>>;
-    fetchOne(options?: ODataOptions & {
+    fetchAll(options?: ODataOptions & {
+        withCount?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<{
-        entity: T | null;
+        entities: T[];
         annots: ODataEntitiesAnnotations<T>;
     }>;
     fetchMany(top: number, options?: ODataOptions & {
@@ -46,11 +47,11 @@ export declare class ODataEntitySetResource<T> extends ODataResource<T> {
         entities: T[];
         annots: ODataEntitiesAnnotations<T>;
     }>;
-    fetchAll(options?: ODataOptions & {
+    fetchOne(options?: ODataOptions & {
         withCount?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<{
-        entities: T[];
+        entity: T | null;
         annots: ODataEntitiesAnnotations<T>;
     }>;
     fetchEntities(options?: ODataOptions & {

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

@@ -7,7 +7,7 @@ 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';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions, ODataPropertyOptions } from './options';
 export declare class ODataFunctionResource<P, R> extends ODataResource<R> {
     static factory<P, R>(api: ODataApi, { path, schema, segments, query, }: {
         path?: string;
@@ -42,7 +42,16 @@ export declare class ODataFunctionResource<P, R> extends ODataResource<R> {
     } & ODataPropertyOptions): Observable<ODataProperty<R>>;
     call(params: P | null, options?: {
         alias?: boolean;
-    } & ODataNoneOptions): Observable<null>;
+        responseType?: 'blob';
+    } & ODataOptions): Observable<Blob>;
+    call(params: P | null, options?: {
+        alias?: boolean;
+        responseType?: 'arraybuffer';
+    } & ODataOptions): Observable<ArrayBuffer>;
+    call(params: P | null, options?: {
+        alias?: boolean;
+        responseType?: 'none';
+    } & ODataOptions): Observable<null>;
     /**
      * Execute the function with the given parameters and return the result as a property
      * @param params Parameters to be sent to the function
@@ -93,4 +102,10 @@ export declare class ODataFunctionResource<P, R> extends ODataResource<R> {
     callCollection<M extends ODataModel<R>, C extends ODataCollection<R, M>>(params: P | null, { alias, ...options }?: {
         alias?: boolean;
     } & ODataOptions): Observable<C | null>;
+    callArraybuffer(params: P | null, { alias, ...options }?: {
+        alias?: boolean;
+    } & ODataOptions): Observable<ArrayBuffer>;
+    callBlob(params: P | null, { alias, ...options }?: {
+        alias?: boolean;
+    } & ODataOptions): Observable<Blob>;
 }

package/lib/resources/types/navigation-property.d.ts

@@ -113,11 +113,16 @@ export declare class ODataNavigationPropertyResource<T> extends ODataResource<T>
         withCount?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<C | null>;
-    fetchOne(options?: ODataOptions & {
+    /**
+     * Fetch all entities
+     * @param options Options for the request
+     * @returns All entities
+     */
+    fetchAll(options?: ODataOptions & {
         withCount?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<{
-        entity: T | null;
+        entities: T[];
         annots: ODataEntitiesAnnotations<T>;
     }>;
     fetchMany(top: number, options?: ODataOptions & {
@@ -127,16 +132,11 @@ export declare class ODataNavigationPropertyResource<T> extends ODataResource<T>
         entities: T[];
         annots: ODataEntitiesAnnotations<T>;
     }>;
-    /**
-     * Fetch all entities
-     * @param options Options for the request
-     * @returns All entities
-     */
-    fetchAll(options?: ODataOptions & {
+    fetchOne(options?: ODataOptions & {
         withCount?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<{
-        entities: T[];
+        entity: T | null;
         annots: ODataEntitiesAnnotations<T>;
     }>;
 }

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

@@ -24,9 +24,6 @@ export declare type ODataEntitiesOptions = ODataOptions & {
 export declare type ODataPropertyOptions = ODataOptions & {
     responseType?: 'property';
 };
-export declare type ODataNoneOptions = ODataOptions & {
-    responseType?: 'none';
-};
 export declare type ODataQueryArgumentsOptions<T> = ODataOptions & ODataQueryArguments<T>;
 export declare type ODataActionOptions<T> = ODataQueryArgumentsOptions<T>;
 export declare type ODataFunctionOptions<T> = ODataQueryArgumentsOptions<T> & {

package/lib/schema/parsers/structured-type.d.ts

@@ -100,7 +100,7 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
     findChildParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): ODataStructuredTypeParser<any> | undefined;
     childParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): Parser<any>;
     deserialize(value: any, options?: ParserOptions): T;
-    serialize(value: T, options?: ParserOptions): any;
+    serialize(value: Partial<T>, options?: ParserOptions): any;
     encode(value: T, options?: ParserOptions): any;
     configure({ options, parserForType, findOptionsForType, }: {
         options: ParserOptions;

package/lib/services/entity-set.d.ts

@@ -28,7 +28,12 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
      * @param options The options for the request.
      */
     fetchAll(options?: ODataOptions): Observable<{
-        entities: T[];
+        entities: T[]; /**
+         * Delete an entity in the entity set.
+         * @param key The entity key.
+         * @param etag The etag for the entity.
+         * @param options The options for the request.
+         */
         annots: import("../resources").ODataEntitiesAnnotations<T>;
     }>;
     /**

package/lib/settings.d.ts

@@ -7,7 +7,7 @@ import { ODataEntityService } from './services/entity';
 import { ApiConfig, Parser } from './types';
 export declare class ODataSettings {
     apis: ODataApi[];
-    constructor(...configs: ApiConfig[]);
+    constructor(configs: ApiConfig[]);
     configure(settings: {
         requester?: (request: ODataRequest<any>) => Observable<any>;
     }): void;

package/lib/types.d.ts

@@ -63,6 +63,7 @@ export interface ApiOptions {
     stringAsEnum?: boolean;
     deleteRefBy?: 'path' | 'id';
     nonParenthesisForEmptyParameterFunction?: boolean;
+    jsonBatchFormat?: boolean;
 }
 export interface ParserOptions {
     version?: ODataVersion;

package/lib/utils/enums.d.ts

@@ -1,8 +1,20 @@
 export declare const Enums: {
-    names<E>(Enum: E): string[];
-    values<E_1>(Enum: E_1): number[];
-    toValue<E_2>(Enum: E_2, value: any): number | undefined;
-    toValues<E_3>(Enum: E_3, value: any): number[];
-    toName<E_4>(Enum: E_4, value: any): string | undefined;
-    toNames<E_5>(Enum: E_5, value: any): string[];
+    names<E extends {
+        [key: string]: any;
+    }>(enums: E): string[];
+    values<E_1 extends {
+        [key: string]: any;
+    }>(enums: E_1): number[];
+    toValue<E_2 extends {
+        [key: string]: any;
+    }>(enums: E_2, value: any): number | undefined;
+    toValues<E_3 extends {
+        [key: string]: any;
+    }>(enums: E_3, value: any): number[];
+    toName<E_4 extends {
+        [key: string]: any;
+    }>(enums: E_4, value: any): string | undefined;
+    toNames<E_5 extends {
+        [key: string]: any;
+    }>(enums: E_5, value: any): string[];
 };

package/lib/utils/strings.d.ts

@@ -1,4 +1,7 @@
 export declare const Strings: {
-    uniqueId(prefix?: string, suffix?: string): string;
+    uniqueId({ prefix, suffix, }?: {
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+    }): string;
     titleCase(text: string): string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-odata",
-  "version": "0.110.0",
+  "version": "0.120.0",
   "license": "MIT",
   "description": "Client side OData typescript library for Angular",
   "repository": {

package/esm2020/lib/tokens.mjs

@@ -1,3 +0,0 @@
-import { InjectionToken } from '@angular/core';
-export const ODATA_CONFIGURATIONS = new InjectionToken('odata.configuraions');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1vZGF0YS9zcmMvbGliL3Rva2Vucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLElBQUksY0FBYyxDQUNwRCxxQkFBcUIsQ0FDdEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFwaUNvbmZpZyB9IGZyb20gJy4vdHlwZXMnO1xuaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGNvbnN0IE9EQVRBX0NPTkZJR1VSQVRJT05TID0gbmV3IEluamVjdGlvblRva2VuPEFwaUNvbmZpZz4oXG4gICdvZGF0YS5jb25maWd1cmFpb25zJ1xuKTtcbiJdfQ==

package/lib/tokens.d.ts

@@ -1,3 +0,0 @@
-import { ApiConfig } from './types';
-import { InjectionToken } from '@angular/core';
-export declare const ODATA_CONFIGURATIONS: InjectionToken<ApiConfig>;