angular-odata 0.115.0 → 0.121.0

package/lib/api.d.ts

@@ -5,7 +5,7 @@ import { ODataApiOptions } from './options';
 import { ODataActionResource, ODataBatchResource, ODataEntityResource, ODataEntitySetResource, ODataFunctionResource, ODataMetadataResource, ODataNavigationPropertyResource, ODataOptions, ODataRequest, ODataResource, ODataSegment, ODataSingletonResource } from './resources/index';
 import { ODataCallable, ODataEntitySet, ODataEnumType, ODataSchema, ODataStructuredType } from './schema';
 import { ODataEntityService } from './services/entity';
-import { ApiConfig, Parser, QueryOptionNames } from './types';
+import { ApiConfig, EdmType, Parser, QueryOption } from './types';
 /**
  * Api abstraction for consuming OData services.
  */
@@ -78,7 +78,7 @@ export declare class ODataApi {
         responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
         observe?: 'body' | 'events' | 'response';
         withCount?: boolean;
-        bodyQueryOptions?: QueryOptionNames[];
+        bodyQueryOptions?: QueryOption[];
     }): Observable<any>;
     private memo;
     private findSchemaForType;
@@ -100,6 +100,6 @@ export declare class ODataApi {
     findModelByName(name: string): typeof ODataModel | undefined;
     findCollectionByName(name: string): typeof ODataCollection | undefined;
     findServiceByName(name: string): typeof ODataEntityService | undefined;
-    parserForType<T>(type: string, bindingType?: string): Parser<T>;
+    parserForType<T>(type: string | EdmType, bindingType?: string): Parser<T>;
     findOptionsForType<T>(type: string): ODataModelOptions<any> | ODataModelOptions<T> | undefined;
 }

package/lib/client.d.ts

@@ -1,7 +1,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 +9,9 @@ import { ODataSettings } from './settings';
 import * as i0 from "@angular/core";
 export declare class ODataClient {
     private http;
-    private settings;
-    private injector;
-    constructor(http: HttpClient, settings: ODataSettings, injector: Injector);
+    private loader;
+    settings?: ODataSettings;
+    constructor(http: HttpClient, loader: ODataConfigLoader);
     /**
      * Resolve the api for the given value.
      * Where value is: string type or an string name or an instance of resource.
@@ -19,6 +19,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.
@@ -66,20 +67,20 @@ export declare class ODataClient {
      * @param type The string type of the service.
      * @returns The service for the given type.
      */
-    serviceForType(type: string): ODataEntityService<any>;
+    serviceForType(type: string): ODataEntityService<any> | undefined;
     /**
      * Resolve the service for the given string entity type.
      * @param type The string entity type binding to the service.
      * @returns The service for the given entity type.
      */
-    serviceForEntityType(type: string): ODataEntityService<any>;
+    serviceForEntityType(type: string): ODataEntityService<any> | undefined;
     enumTypeByName<T>(name: string): import("angular-odata").ODataEnumType<T>;
     structuredTypeByName<T>(name: string): import("angular-odata").ODataStructuredType<T>;
     callableByName<T>(name: string): import("angular-odata").ODataCallable<T>;
     entitySetByName(name: string): import("angular-odata").ODataEntitySet;
     modelByName(name: string): typeof ODataModel;
     collectionByName(name: string): typeof ODataCollection;
-    serviceByName(name: string): ODataEntityService<any>;
+    serviceByName(name: string): ODataEntityService<any> | undefined;
     fromJSON<E>(json: {
         segments: ODataSegment[];
         options: {

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

@@ -3,7 +3,7 @@ import { Observable } from 'rxjs';
 import { ODataActionOptions, ODataEntitiesAnnotations, ODataEntitySetResource, ODataFunctionOptions, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryOptionsHandler, ODataResource } from '../resources';
 import { ODataStructuredType } from '../schema/structured-type';
 import { ODataModel } from './model';
-import { ODataModelEntry, ODataModelEvent, ODataModelField } from './options';
+import { ModelFieldOptions, ODataModelEntry, ODataModelEvent, ODataModelField } from './options';
 export declare class ODataCollection<T, M extends ODataModel<T>> implements Iterable<M> {
     static model: typeof ODataModel | null;
     _parent: [
@@ -41,7 +41,8 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
         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;
+    withResource<R>(resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>, ctx: (collection: this) => R): R;
+    asEntitySet<R>(ctx: (collection: this) => R): R;
     annots(): ODataEntitiesAnnotations<T>;
     private modelFactory;
     toEntities({ client_id, include_navigation, include_concurrency, include_computed, include_key, include_non_field, changes_only, field_mapping, chain, }?: {
@@ -65,18 +66,22 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     }): boolean;
     clone<C extends ODataCollection<T, M>>(): C;
     private _request;
-    fetch({ withCount, ...options }?: ODataOptions & {
+    fetch({ withCount, remove, ...options }?: ODataOptions & {
+        remove?: boolean;
         withCount?: boolean;
-    }): Observable<this>;
-    fetchAll({ withCount, ...options }?: ODataOptions & {
+    }): Observable<M[]>;
+    fetchAll({ withCount, remove, ...options }?: ODataOptions & {
+        remove?: boolean;
         withCount?: boolean;
-    }): Observable<this>;
-    fetchMany(top: number, { withCount, ...options }?: ODataOptions & {
+    }): Observable<M[]>;
+    fetchMany(top: number, { withCount, remove, ...options }?: ODataOptions & {
+        remove?: boolean;
         withCount?: boolean;
-    }): Observable<this>;
-    fetchOne({ withCount, ...options }?: ODataOptions & {
+    }): Observable<M[]>;
+    fetchOne({ withCount, remove, ...options }?: ODataOptions & {
+        remove?: boolean;
         withCount?: boolean;
-    }): Observable<M | null>;
+    }): Observable<M>;
     /**
      * Save all models in the collection
      * @param relModel The model is relationship
@@ -104,13 +109,15 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
         silent?: boolean;
         server?: boolean;
     }): Observable<M>;
+    private _moveModel;
     create(attrs?: T, { silent, server, }?: {
         silent?: boolean;
         server?: boolean;
     }): Observable<M>;
-    set(path: string | string[], value: any): any;
+    set(path: string | string[], value: any, {}: {} & ModelFieldOptions): any;
     get(path: number): M | undefined;
     get(path: string | string[]): any;
+    has(path: number | string | string[]): boolean;
     reset({ path, silent, }?: {
         path?: string | string[];
         silent?: boolean;
@@ -120,12 +127,13 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     }): void;
     assign(objects: Partial<T>[] | {
         [name: string]: any;
-    }[] | M[], { reset, reparent, silent, }?: {
+    }[] | M[], { remove, reset, reparent, silent, }?: {
+        remove?: boolean;
         reset?: boolean;
         reparent?: boolean;
         silent?: boolean;
     }): void;
-    query(func: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): this;
+    query(ctx: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): this;
     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>;
     private _unlink;

package/lib/models/model.d.ts

@@ -60,6 +60,7 @@ export declare class ODataModel<T> {
     }): EntityKey<T> | {
         [name: string]: any;
     } | undefined;
+    isOpenModel(): boolean;
     isParentOf(child: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
     referential(field: ODataModelField<any>, { field_mapping, resolve, }?: {
         field_mapping?: boolean;
@@ -112,8 +113,11 @@ export declare class ODataModel<T> {
     }): {
         [name: string]: any;
     };
-    set(path: string | string[], value: any): any;
+    set(path: string | string[], value: any, { type }?: {
+        type?: string;
+    }): any;
     get(path: string | string[]): any;
+    has(path: string | string[]): boolean;
     reset({ path, silent, }?: {
         path?: string | string[];
         silent?: boolean;
@@ -144,9 +148,9 @@ export declare class ODataModel<T> {
     }): Observable<this>;
     /**
      * Create an execution context for change the internal query of a resource
-     * @param func Function to execute
+     * @param ctx Function to execute
      */
-    query(func: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): this;
+    query(ctx: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): this;
     /**
      * Perform a check on the internal state of the model and return true if the model is changed.
      * @param include_navigation Check in navigation properties
@@ -156,14 +160,15 @@ export declare class ODataModel<T> {
         include_navigation?: boolean;
     }): boolean;
     isNew(): boolean;
+    withResource<R>(resource: any, ctx: (model: this) => R): R;
     /**
      * 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

@@ -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 { Parser, ParserOptions } from '../types';
+import { EdmType, Parser, 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';
@@ -59,6 +59,7 @@ export declare type ModelOptions = {
 };
 export declare type ModelFieldOptions = {
     field?: string;
+    parser?: ODataStructuredTypeFieldParser<any>;
     default?: any;
     required?: boolean;
     concurrency?: boolean;
@@ -136,7 +137,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;
@@ -170,6 +171,7 @@ export declare class ODataModelOptions<T> {
     type({ alias }?: {
         alias?: boolean;
     }): string;
+    isOpenType(): boolean;
     isTypeOf(type: string): boolean;
     isModelFor(entity: T | {
         [name: string]: any;
@@ -185,6 +187,10 @@ export declare class ODataModelOptions<T> {
         include_navigation: boolean;
     }): ODataModelField<any>[];
     field<F>(name: keyof T | string): ODataModelField<F>;
+    findField<F>(name: keyof T | string): ODataModelField<F> | undefined;
+    addField<F>(name: string, options: ModelFieldOptions): ODataModelField<F>;
+    tsToEdm: Record<string, EdmType>;
+    private modelFieldFactory;
     attach(self: ODataModel<T>, resource: ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T>): void;
     static chain(child: ODataModel<any> | ODataCollection<any, ODataModel<any>>): [
         ODataModel<any> | ODataCollection<any, ODataModel<any>>,
@@ -243,7 +249,8 @@ export declare class ODataModelOptions<T> {
         include_navigation?: boolean;
     }): boolean;
     hasKey(self: ODataModel<T>): boolean;
-    asEntity<R, M extends ODataModel<T>>(self: M, func: (model: M) => R): R;
+    withResource<R, M extends ODataModel<T>>(self: M, resource: ODataEntityResource<T> | ODataPropertyResource<T> | ODataNavigationPropertyResource<T> | ODataSingletonResource<T>, ctx: (model: M) => R): R;
+    asEntity<R, M extends ODataModel<T>>(self: M, ctx: (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;
         include_navigation?: boolean;
@@ -279,12 +286,18 @@ export declare class ODataModelOptions<T> {
     }): void;
     static isModel(obj: any): boolean;
     static isCollection(obj: any): boolean;
-    private updateCollection;
-    private updateModel;
-    private _get;
+    private _updateCollection;
+    private _updateModel;
+    get<F>(self: ODataModel<T>, field: ODataModelField<F> | string): F | ODataModel<F> | ODataCollection<F, ODataModel<F>> | null | undefined;
     private _setStructured;
     private _setValue;
-    private _set;
+    set<F>(self: ODataModel<T>, field: ODataModelField<F> | string, value: F | F[] | {
+        [name: string]: any;
+    } | {
+        [name: string]: any;
+    }[] | ODataModel<F> | ODataCollection<F, ODataModel<F>> | null, { type }?: {
+        type?: string;
+    }): boolean;
     private _unlink;
     private _link;
 }

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

@@ -1,4 +1,4 @@
-import { ApiOptions, FetchPolicy, ODataMetadataType, ODataVersion, ParserOptions, QueryOptionNames } from './types';
+import { ApiOptions, FetchPolicy, ODataMetadataType, ODataVersion, ParserOptions, QueryOption } from './types';
 export declare class ODataApiOptions implements ApiOptions {
     /**
      * Default OData version
@@ -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
      */
@@ -43,7 +47,7 @@ export declare class ODataApiOptions implements ApiOptions {
     /**
      * Send query options in the request body
      */
-    bodyQueryOptions: QueryOptionNames[];
+    bodyQueryOptions: QueryOption[];
     /**
      * Customize accept header with OData options
      * @link http://docs.oasis-open.org/odata/odata-json-format/v4.01/odata-json-format-v4.01.html#sec_RequestingtheJSONFormat

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

@@ -1,10 +1,10 @@
-import { PathSegmentNames } from '../../types';
+import { PathSegment } from '../../types';
 import { EntityKey } from '../resource';
 import type { ODataPathSegments, ODataSegment } from './segments';
 export declare class SegmentHandler {
     private segment;
     constructor(segment: ODataSegment);
-    get name(): PathSegmentNames;
+    get name(): PathSegment;
     type(value?: string): string | undefined;
     path(value?: string): string;
     key<T>(value?: EntityKey<T>): EntityKey<T>;

package/lib/resources/path/segments.d.ts

@@ -1,8 +1,8 @@
-import { PathSegmentNames } from '../../types';
+import { PathSegment } from '../../types';
 import { EntityKey } from '../resource';
 import { SegmentHandler } from './handlers';
 export declare type ODataSegment = {
-    name: PathSegmentNames;
+    name: PathSegment;
     path: string;
     type?: string;
     key?: any;

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

@@ -20,7 +20,10 @@ export declare type Aggregate = string | {
 };
 export declare type OrderBy<T> = OrderByType<T> | OrderByType<T>[];
 export declare type OrderByType<T> = string | OrderByObject<T>;
-export declare type OrderByObject<T> = keyof T | [keyof T | string, 'asc' | 'desc'];
+export declare type OrderByObject<T> = keyof T | [keyof T | string, 'asc' | 'desc'] | NestedOrderBy<T>;
+export declare type NestedOrderBy<T> = {
+    [P in keyof T]?: T[P] extends Array<infer E> ? OrderBy<E> : OrderBy<T[P]>;
+};
 export declare type Expand<T> = ExpandType<T> | ExpandType<T>[];
 export declare type ExpandType<T> = string | ExpandObject<T>;
 export declare type ExpandObject<T> = keyof T | NestedExpandOptions<T>;

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

@@ -1,15 +1,15 @@
-import { QueryOptionNames } from '../../types';
+import { QueryOption } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
 import { ComputeExpression, ComputeExpressionBuilder, FilterExpression, FilterExpressionBuilder, OrderByExpression, OrderByExpressionBuilder, SearchExpression, SearchExpressionBuilder, ExpandExpression, ExpandExpressionBuilder, SelectExpression, SelectExpressionBuilder } from './expressions';
 import type { ODataQueryArguments, ODataQueryOptions } from './options';
 export declare class ODataQueryOptionHandler<T> {
     private o;
     private n;
-    constructor(o: Map<QueryOptionNames, any>, n: QueryOptionNames);
+    constructor(o: Map<QueryOption, any>, n: QueryOption);
     /**
      * The name of the managed odata query option.
      */
-    get name(): QueryOptionNames;
+    get name(): QueryOption;
     /**
      * Converts the managed odata query option to a json object.
      * @returns {any}

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

@@ -1,27 +1,27 @@
-import { QueryOptionNames } from '../../types';
+import { QueryOption } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
 import { ComputeExpression, Expression, FilterExpression, OrderByExpression, SearchExpression } from './expressions';
 import { ExpandExpression } from './expressions/expand';
 import { SelectExpression } from './expressions/select';
 import { ODataQueryOptionHandler } from './handlers';
 export declare type ODataQueryArguments<T> = {
-    [QueryOptionNames.select]?: Select<T> | SelectExpression<T> | null;
-    [QueryOptionNames.expand]?: Expand<T> | ExpandExpression<T> | null;
-    [QueryOptionNames.compute]?: string | ComputeExpression<T> | null;
-    [QueryOptionNames.filter]?: Filter<T> | FilterExpression<T> | null;
-    [QueryOptionNames.search]?: string | SearchExpression<T> | null;
-    [QueryOptionNames.transform]?: Transform<T> | null;
-    [QueryOptionNames.orderBy]?: OrderBy<T> | OrderByExpression<T> | null;
-    [QueryOptionNames.top]?: number | null;
-    [QueryOptionNames.skip]?: number | null;
-    [QueryOptionNames.skiptoken]?: string | null;
-    [QueryOptionNames.format]?: string | null;
-    [QueryOptionNames.levels]?: number | 'max' | null;
-    [QueryOptionNames.count]?: boolean | null;
+    [QueryOption.select]?: Select<T> | SelectExpression<T> | null;
+    [QueryOption.expand]?: Expand<T> | ExpandExpression<T> | null;
+    [QueryOption.compute]?: string | ComputeExpression<T> | null;
+    [QueryOption.filter]?: Filter<T> | FilterExpression<T> | null;
+    [QueryOption.search]?: string | SearchExpression<T> | null;
+    [QueryOption.transform]?: Transform<T> | null;
+    [QueryOption.orderBy]?: OrderBy<T> | OrderByExpression<T> | null;
+    [QueryOption.top]?: number | null;
+    [QueryOption.skip]?: number | null;
+    [QueryOption.skiptoken]?: string | null;
+    [QueryOption.format]?: string | null;
+    [QueryOption.levels]?: number | 'max' | null;
+    [QueryOption.count]?: boolean | null;
 };
 export declare class ODataQueryOptions<T> {
-    values: Map<QueryOptionNames, any>;
-    constructor(values?: Map<QueryOptionNames, any> | {
+    values: Map<QueryOption, any>;
+    constructor(values?: Map<QueryOption, any> | {
         [name: string]: any;
     });
     pathAndParams(escape?: boolean): [string, {
@@ -31,10 +31,10 @@ export declare class ODataQueryOptions<T> {
     toJSON(): {};
     toQueryArguments(): ODataQueryArguments<T>;
     clone<O>(): ODataQueryOptions<O>;
-    expression(key: QueryOptionNames, exp?: Expression<T>): any;
-    option<O>(key: QueryOptionNames, opts?: O): ODataQueryOptionHandler<O>;
-    has(key: QueryOptionNames): boolean;
-    remove(...keys: QueryOptionNames[]): void;
-    keep(...keys: QueryOptionNames[]): void;
+    expression(key: QueryOption, exp?: Expression<T>): any;
+    option<O>(key: QueryOption, opts?: O): ODataQueryOptionHandler<O>;
+    has(key: QueryOption): boolean;
+    remove(...keys: QueryOption[]): void;
+    keep(...keys: QueryOption[]): void;
     clear(): void;
 }

package/lib/resources/request.d.ts

@@ -1,6 +1,6 @@
 import { HttpContext, HttpHeaders, HttpParams } from '@angular/common/http';
 import { ODataApi } from '../api';
-import { QueryOptionNames } from '../types';
+import { QueryOption } from '../types';
 import { ODataResource } from './resource';
 import { ODataOptions } from './types';
 export declare class ODataRequest<T> {
@@ -9,7 +9,7 @@ export declare class ODataRequest<T> {
     readonly context?: HttpContext;
     readonly reportProgress?: boolean;
     readonly withCredentials?: boolean;
-    readonly bodyQueryOptions: QueryOptionNames[];
+    readonly bodyQueryOptions: QueryOption[];
     readonly fetchPolicy: 'cache-first' | 'cache-and-network' | 'network-only' | 'no-cache' | 'cache-only';
     readonly resource: ODataResource<T>;
     private readonly _responseType?;
@@ -36,7 +36,7 @@ export declare class ODataRequest<T> {
         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[];
+        bodyQueryOptions?: QueryOption[];
     });
     static factory(api: ODataApi, method: string, resource: ODataResource<any>, options: ODataOptions & {
         body?: any;
@@ -44,7 +44,7 @@ export declare class ODataRequest<T> {
         responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
         observe: 'events' | 'response';
         withCount?: boolean;
-        bodyQueryOptions?: QueryOptionNames[];
+        bodyQueryOptions?: QueryOption[];
     }): ODataRequest<any>;
     get responseType(): 'arraybuffer' | 'blob' | 'json' | 'text';
     get path(): string;

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 { ParserOptions, QueryOptionNames } from '../types';
+import { ParserOptions, QueryOption } from '../types';
 import { ODataPathSegments, ODataPathSegmentsHandler } from './path';
 import { ODataQueryOptions, ODataQueryOptionsHandler, QueryCustomType } from './query';
 import { ODataEntitiesAnnotations, ODataEntityAnnotations } from './responses/index';
@@ -41,15 +41,13 @@ export declare class ODataResource<T> {
     clearKey(): void | undefined;
     asModel<M extends ODataModel<T>>(entity?: Partial<T> | {
         [name: string]: any;
-    }, { annots, reset, }?: {
+    }, { annots }?: {
         annots?: ODataEntityAnnotations<T>;
-        reset?: boolean;
     }): M;
     asCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(entities?: Partial<T>[] | {
         [name: string]: any;
-    }[], { annots, reset, }?: {
+    }[], { annots }?: {
         annots?: ODataEntitiesAnnotations<T>;
-        reset?: boolean;
     }): C;
     isSubtypeOf(other: ODataResource<any>): boolean;
     isSupertypeOf(other: ODataResource<any>): boolean;
@@ -90,7 +88,7 @@ export declare class ODataResource<T> {
         etag?: string;
         responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
         withCount?: boolean;
-        bodyQueryOptions?: QueryOptionNames[];
+        bodyQueryOptions?: QueryOption[];
     }): Observable<any>;
     protected post(body: any, options?: ODataOptions & {
         responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';

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>;
 }