angular-odata 0.78.1 → 0.95.0

package/lib/api.d.ts

@@ -1,11 +1,11 @@
 import { Observable } from 'rxjs';
-import { ApiConfig, Parser } from './types';
-import { ODataSchema, ODataEnumType, ODataCallable, ODataEntitySet, ODataStructuredType } from './schema/index';
-import { ODataModel, ODataCollection } from './models/index';
-import { ODataBatchResource, ODataMetadataResource, ODataEntitySetResource, ODataSingletonResource, ODataFunctionResource, ODataActionResource, ODataEntityResource, ODataSegment, ODataNavigationPropertyResource, ODataRequest } from './resources/index';
 import { ODataCache } from './cache/index';
+import { ODataCollection, ODataModel, ODataModelOptions } from './models/index';
 import { ODataApiOptions } from './options';
+import { ODataActionResource, ODataBatchResource, ODataEntityResource, ODataEntitySetResource, ODataFunctionResource, ODataMetadataResource, ODataNavigationPropertyResource, ODataRequest, ODataSegment, ODataSingletonResource } from './resources/index';
+import { ODataCallable, ODataEntitySet, ODataEnumType, ODataSchema, ODataStructuredType } from './schema';
 import { ODataEntityService } from './services/entity';
+import { ApiConfig, Parser } from './types';
 /**
  * Api abstraction for consuming OData services.
  */
@@ -52,38 +52,39 @@ export declare class ODataApi {
     batch(): ODataBatchResource;
     /**
      * Build a singleton resource.
-     * @param name Name of the singleton
+     * @param path Name of the singleton
      * @returns
      */
-    singleton<T>(name: string): ODataSingletonResource<T>;
+    singleton<T>(path: string): ODataSingletonResource<T>;
     /**
      * Build an entity set resource.
-     * @param name Name of the entity set
+     * @param path Name of the entity set
      * @returns
      */
-    entitySet<T>(name: string): ODataEntitySetResource<T>;
+    entitySet<T>(path: string): ODataEntitySetResource<T>;
     /**
      * Unbound Action
-     * @param  {string} name?
+     * @param  {string} path?
      * @returns ODataActionResource
      */
-    action<P, R>(name: string): ODataActionResource<P, R>;
+    action<P, R>(path: string): ODataActionResource<P, R>;
     /**
      * Unbound Function
-     * @param  {string} name?
+     * @param  {string} path?
      * @returns ODataFunctionResource
      */
-    function<P, R>(name: string): ODataFunctionResource<P, R>;
+    function<P, R>(path: string): ODataFunctionResource<P, R>;
     request(req: ODataRequest<any>): Observable<any>;
+    private memo;
     private findSchemaForType;
     findEnumTypeForType<T>(type: string): ODataEnumType<T> | undefined;
     findStructuredTypeForType<T>(type: string): ODataStructuredType<T> | undefined;
     findCallableForType<T>(type: string, bindingType?: string): ODataCallable<T> | undefined;
     findEntitySetForType(type: string): ODataEntitySet | undefined;
     findModelForType(type: string): typeof ODataModel | undefined;
-    modelForType(type?: string): typeof ODataModel;
+    modelForType(type: string): typeof ODataModel;
     findCollectionForType(type: string): typeof ODataCollection | undefined;
-    collectionForType(type?: string): typeof ODataCollection;
+    collectionForType(type: string): typeof ODataCollection;
     findServiceForType(type: string): typeof ODataEntityService | undefined;
     findEntitySetForEntityType(entityType: string): ODataEntitySet | undefined;
     findServiceForEntityType(entityType: string): typeof ODataEntityService | undefined;
@@ -94,6 +95,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<any>;
-    findOptionsForType<T>(type: string): import("./models/options").ODataModelOptions<any> | undefined;
+    parserForType<T>(type: string, bindingType?: string): Parser<T>;
+    findOptionsForType<T>(type: string): ODataModelOptions<T> | undefined;
 }

package/lib/cache/cache.d.ts

@@ -1,6 +1,6 @@
-import { Cache } from '../types';
-import { ODataRequest, ODataResponse } from '../resources';
 import { Observable } from 'rxjs';
+import { ODataRequest, ODataResponse } from '../resources';
+import { Cache } from '../types';
 export interface ODataCacheEntry<T> {
     payload: T;
     lastRead: number;

package/lib/client.d.ts

@@ -1,33 +1,84 @@
+import { HttpClient, HttpEvent, HttpHeaders, HttpParams, HttpResponse } from '@angular/common/http';
 import { Injector } from '@angular/core';
-import { HttpClient, HttpHeaders, HttpParams, HttpResponse, HttpEvent } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { ODataModel, ODataCollection } from './models/index';
-import { ODataResource, ODataBatchResource, ODataMetadataResource, ODataEntitySetResource, ODataSingletonResource, ODataFunctionResource, ODataActionResource, ODataEntityResource, ODataSegment, ODataResponse, ODataNavigationPropertyResource } from './resources/index';
-import { ODataSettings } from './settings';
 import { ODataApi } from './api';
+import { ODataCollection, ODataModel } from './models/index';
+import { ODataActionResource, ODataBatchResource, ODataEntityResource, ODataEntitySetResource, ODataFunctionResource, ODataMetadataResource, ODataNavigationPropertyResource, ODataResource, ODataResponse, ODataSegment, ODataSingletonResource } from './resources/index';
 import { ODataEntityService } from './services/entity';
+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);
+    /**
+     * Resolve the api for the given value.
+     * Where value is: string type or an string name or an instance of resource.
+     * @param value The value to resolve.
+     * @returns The api for the value.
+     */
     apiFor(value?: ODataResource<any> | string): ODataApi;
+    /**
+     * Resolve the parser for the given string type.
+     * @param type The string type of the parser.
+     * @returns The parser for the given type.
+     */
     parserForType<T>(type: string): import("angular-odata").Parser<T>;
+    /**
+     * Resolve the enum type for the given string type.
+     * @param type The string type of the enum type.
+     * @returns The enum type for the given type.
+     */
     enumTypeForType<T>(type: string): import("angular-odata").ODataEnumType<T>;
-    enumTypeByName<T>(name: string): import("angular-odata").ODataEnumType<T>;
+    /**
+     * Resolve the structured type for the given string type.
+     * @param type The string type of the structured type.
+     * @returns The structured type for the given type.
+     */
     structuredTypeForType<T>(type: string): import("angular-odata").ODataStructuredType<T>;
-    structuredTypeByName<T>(name: string): import("angular-odata").ODataStructuredType<T>;
+    /**
+     * Resolve the callable for the given string type.
+     * @param type The string type of the callable.
+     * @returns The callable for the given type.
+     */
     callableForType<T>(type: string): import("angular-odata").ODataCallable<T>;
-    callableByName<T>(name: string): import("angular-odata").ODataCallable<T>;
+    /**
+     * Resolve the entity set for the given string type.
+     * @param type The string type of the entity set.
+     * @returns The entity set for the given type.
+     */
     entitySetForType(type: string): import("angular-odata").ODataEntitySet;
-    entitySetByName(name: string): import("angular-odata").ODataEntitySet;
+    /**
+     * Resolve the model for the given string type.
+     * @param type The string type of the model.
+     * @returns The model for the given type.
+     */
     modelForType(type: string): typeof ODataModel;
-    modelByName(name: string): typeof ODataModel;
+    /**
+     * Resolve the collection for the given string type.
+     * @param type The string type of the collection.
+     * @returns The collection for the given type.
+     */
     collectionForType(type: string): typeof ODataCollection;
-    collectionByName(name: string): typeof ODataCollection;
+    /**
+     * Resolve the service for the given string type.
+     * @param type The string type of the service.
+     * @returns The service for the given type.
+     */
     serviceForType(type: string): ODataEntityService<any>;
+    /**
+     * 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>;
+    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>;
     fromJSON<E>(json: {
         segments: ODataSegment[];
@@ -35,20 +86,44 @@ export declare class ODataClient {
             [name: string]: any;
         };
     }, apiNameOrType?: string): ODataEntityResource<E> | ODataEntitySetResource<E> | ODataNavigationPropertyResource<E> | ODataSingletonResource<E>;
-    metadata(apiNameOrType?: string): ODataMetadataResource;
-    batch(apiNameOrType?: string): ODataBatchResource;
+    /**
+     * Build a resource for the metadata.
+     * @param apiName The name of the API.
+     * @returns The metadata resource.
+     */
+    metadata(apiName?: string): ODataMetadataResource;
+    /**
+     * Build a resource for the batch.
+     * @param apiName The name of the API.
+     * @returns The batch resource.
+     */
+    batch(apiName?: string): ODataBatchResource;
+    /**
+     * Build a resource for the singleton.
+     * @param path The full path to the singleton.
+     * @param apiNameOrType The name of the API or the type of the singleton.
+     * @returns The singleton resource.
+     */
     singleton<T>(path: string, apiNameOrType?: string): ODataSingletonResource<T>;
+    /**
+     * Build a resource for the entity set.
+     * @param path The full path to the entity set.
+     * @param apiNameOrType The name of the API or the type of the entity set.
+     * @returns The entity set resource.
+     */
     entitySet<T>(path: string, apiNameOrType?: string): ODataEntitySetResource<T>;
     /**
-     * Unbound Action
-     * @param  {string} path?
-     * @returns ODataActionResource
+     * Build a resource for unbound action.
+     * @param path The full path to the action.
+     * @param apiNameOrType The name of the API or the type of the entity.
+     * @returns The unbound action resource.
      */
     action<P, R>(path: string, apiNameOrType?: string): ODataActionResource<P, R>;
     /**
-     * Unbound Function
-     * @param  {string} path?
-     * @returns ODataFunctionResource
+     * Build a resource for unbound function.
+     * @param path The full path to the function.
+     * @param apiNameOrType The name of the API or the type of the callable.
+     * @returns The unbound function resource.
      */
     function<P, R>(path: string, apiNameOrType?: string): ODataFunctionResource<P, R>;
     request(method: string, resource: ODataResource<any>, options: {

package/lib/constants.d.ts

@@ -46,6 +46,7 @@ export declare const DEFAULT_STRIP_METADATA = "full";
 export declare const DEFAULT_FETCH_POLICY = "network-only";
 export declare const DEFAULT_TIMEOUT = 60;
 export declare const CALLABLE_BINDING_PARAMETER = "bindingParameter";
+export declare const XSSI_PREFIX: RegExp;
 export declare const QUERY_SEPARATOR = "?";
 export declare const PARAM_SEPARATOR = "&";
 export declare const VALUE_SEPARATOR = "=";
@@ -55,5 +56,8 @@ export declare const ODATA_ALIAS_PREFIX = "@";
 export declare const NEWLINE = "\r\n";
 export declare const NEWLINE_REGEXP: RegExp;
 export declare const CACHE_KEY_SEPARATOR = ":";
-export declare const COMPUTED = "Org.OData.Core.V1.Computed";
-export declare const OPTIMISTIC_CONCURRENCY = "Org.OData.Core.V1.OptimisticConcurrency";
+export declare const CID_FIELD_NAME = "_cid";
+export declare const COMPUTED: RegExp;
+export declare const OPTIMISTIC_CONCURRENCY: RegExp;
+export declare const DESCRIPTION: RegExp;
+export declare const LONG_DESCRIPTION: RegExp;

package/lib/helper.d.ts

@@ -44,6 +44,9 @@ export interface ODataVersionHelper {
     etag(value: {
         [name: string]: any;
     }, etag?: string): string | undefined;
+    type(value: {
+        [name: string]: any;
+    }, type?: string): string | undefined;
     count(value: {
         [name: string]: any;
     }): number | undefined;
@@ -66,9 +69,6 @@ export interface ODataVersionHelper {
     metadataEtag(value: {
         [name: string]: any;
     }): string | undefined;
-    type(value: {
-        [name: string]: any;
-    }): string | undefined;
     nextLink(value: {
         [name: string]: any;
     }): string | undefined;

package/lib/index.d.ts

@@ -6,7 +6,6 @@ export * from './tokens';
 export * from './module';
 export * from './utils/index';
 export * from './services/index';
-export * from './parsers/index';
 export * from './schema/index';
 export * from './models/index';
 export * from './resources/index';

package/lib/models/collection.d.ts

@@ -1,15 +1,15 @@
-import { Observable } from 'rxjs';
-import { ODataEntitiesAnnotations, HttpOptions, Select, Expand, OptionHandler, Transform, Filter, OrderBy, QueryArguments, HttpQueryOptions } from '../resources/index';
 import { EventEmitter } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ODataEntitiesAnnotations, ODataEntitySetResource, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryArgumentsOptions, ODataQueryOptionsHandler, ODataResource } from '../resources';
 import { ODataModel } from './model';
-import { ODataCollectionResource, ODataModelEvent, ODataModelField, ODataModelEntry } from './options';
+import { ODataModelEntry, ODataModelEvent, ODataModelField } from './options';
 export declare class ODataCollection<T, M extends ODataModel<T>> implements Iterable<M> {
     static model: typeof ODataModel | null;
     _parent: [
         ODataModel<any> | ODataCollection<any, ODataModel<any>>,
         ODataModelField<any> | null
     ] | null;
-    _resource?: ODataCollectionResource<T>;
+    _resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null;
     _annotations: ODataEntitiesAnnotations;
     _entries: ODataModelEntry<T, M>[];
     _model: typeof ODataModel;
@@ -20,15 +20,15 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
         [name: string]: any;
     }[], { parent, resource, annots, model, reset, }?: {
         parent?: [ODataModel<any>, ODataModelField<any>];
-        resource?: ODataCollectionResource<T>;
+        resource?: ODataResource<T>;
         annots?: ODataEntitiesAnnotations;
         model?: typeof ODataModel;
         reset?: boolean;
     });
     isParentOf(child: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
-    resource(): ODataCollectionResource<T>;
-    attach(resource: ODataCollectionResource<T>): void;
-    asEntitySet<R>(func: (collection: this) => Observable<R>): Observable<R>;
+    resource(): ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>;
+    attach(resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>): void;
+    asEntitySet<R>(func: (collection: this) => R): R;
     annots(): ODataEntitiesAnnotations;
     private modelFactory;
     toEntities({ client_id, include_navigation, include_concurrency, include_computed, include_key, include_non_field, changes_only, field_mapping, chain, }?: {
@@ -44,43 +44,39 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     }): (T | {
         [name: string]: any;
     })[];
+    toJSON(): (T | {
+        [name: string]: any;
+    })[];
     hasChanged({ include_navigation }?: {
         include_navigation?: boolean;
     }): boolean;
     clone<C extends ODataCollection<T, M>>(): C;
-    fetch({ withCount, ...options }?: HttpOptions & {
+    fetch({ withCount, ...options }?: ODataOptions & {
         withCount?: boolean;
     }): Observable<this>;
-    fetchAll(options?: HttpOptions): Observable<this>;
+    fetchAll(options?: ODataOptions): Observable<this>;
     /**
      * Save all models in the collection
      * @param relModel The model is relationship
      * @param method The method to use
      * @param options HttpOptions
      */
-    save({ relModel, refOnly, method, ...options }?: HttpOptions & {
+    save({ relModel, method, ...options }?: ODataOptions & {
         relModel?: boolean;
-        refOnly?: boolean;
-        method?: 'update' | 'patch';
+        method?: 'update' | 'modify';
     }): Observable<this>;
     private addReference;
     private _addModel;
-    protected addModel(model: M, { silent, reset, position, }?: {
-        silent?: boolean;
-        reset?: boolean;
-        position?: number;
-    }): void;
-    add(model: M, { silent, server, position, }?: {
+    private addModel;
+    add(model: M, { silent, reparent, server, position, }?: {
         silent?: boolean;
+        reparent?: boolean;
         server?: boolean;
         position?: number;
     }): Observable<this>;
     private removeReference;
     private _removeModel;
-    protected removeModel(model: M, { silent, reset, }?: {
-        silent?: boolean;
-        reset?: boolean;
-    }): void;
+    private removeModel;
     remove(model: M, { silent, server, }?: {
         silent?: boolean;
         server?: boolean;
@@ -90,47 +86,40 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
         server?: boolean;
     }): Observable<M>;
     set(path: string | string[], value: any): any;
-    get(path: string | string[] | number): any;
+    get(path: number): M | undefined;
+    get(path: string | string[]): any;
     reset({ path, silent, }?: {
         path?: string | string[];
         silent?: boolean;
     }): void;
     assign(objects: Partial<T>[] | {
         [name: string]: any;
-    }[] | M[], { reset, silent, }?: {
+    }[] | M[], { reset, reparent, silent, }?: {
         reset?: boolean;
+        reparent?: boolean;
         silent?: boolean;
     }): void;
-    query(func: (q: {
-        select(opts?: Select<T>): OptionHandler<Select<T>>;
-        expand(opts?: Expand<T>): OptionHandler<Expand<T>>;
-        transform(opts?: Transform<T>): OptionHandler<Transform<T>>;
-        search(opts?: string): OptionHandler<string>;
-        filter(opts?: Filter): OptionHandler<Filter>;
-        orderBy(opts?: OrderBy<T>): OptionHandler<OrderBy<T>>;
-        format(opts?: string): OptionHandler<string>;
-        top(opts?: number): OptionHandler<number>;
-        skip(opts?: number): OptionHandler<number>;
-        skiptoken(opts?: string): OptionHandler<string>;
-        paging({ skip, skiptoken, top, }: {
-            skip?: number;
-            skiptoken?: string;
-            top?: number;
-        }): void;
-        clearPaging(): void;
-        apply(query: QueryArguments<T>): void;
-    }) => void): void;
-    protected callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & HttpQueryOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
-    protected callAction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & HttpQueryOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
+    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 _findEntry;
+    equals(other: ODataCollection<T, ODataModel<T>>): boolean;
     get [Symbol.toStringTag](): string;
     [Symbol.iterator](): {
         next(): IteratorResult<M>;
     };
+    filter(predicate: (m: M, index: number) => boolean): M[];
+    find(predicate: (m: M, index: number) => boolean): M | undefined;
+    first(): M | undefined;
+    last(): M | undefined;
+    next(model: M): M | undefined;
+    prev(model: M): M | undefined;
+    every(predicate: (m: M, index: number) => boolean): boolean;
+    some(predicate: (m: M, index: number) => boolean): boolean;
     contains(model: M): boolean;
-    filter(predicate: (m: M) => boolean): M[];
+    indexOf(model: M): number;
     private _bisect;
     private _compare;
     _sortBy: {

package/lib/models/model.d.ts

@@ -1,13 +1,16 @@
 import { EventEmitter } from '@angular/core';
 import { Observable } from 'rxjs';
-import { ODataNavigationPropertyResource, ODataPropertyResource, HttpOptions, ODataEntityAnnotations, Select, Expand, EntityKey, OptionHandler, QueryArguments, HttpQueryOptions } from '../resources/index';
-import { ODataCollection } from './collection';
+import { EntityKey, ODataEntityAnnotations, ODataEntityResource, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryArgumentsOptions, ODataQueryOptionsHandler, ODataResource, ODataSingletonResource } from '../resources';
 import { ODataStructuredType } from '../schema';
-import { ModelOptions, ODataModelEvent, ODataModelOptions, ODataModelRelation, ODataModelResource, ODataModelField } from './options';
+import { ODataCollection } from './collection';
+import { ModelOptions, ODataModelEvent, ODataModelField, ODataModelOptions, ODataModelRelation } from './options';
 export declare class ODataModel<T> {
     static options: ModelOptions;
     static meta: ODataModelOptions<any>;
-    static buildMeta<T>(options: ModelOptions, schema: ODataStructuredType<T>): void;
+    static buildMeta<T>({ options, schema, }: {
+        options?: ModelOptions;
+        schema: ODataStructuredType<T>;
+    }): void;
     _parent: [
         ODataModel<any> | ODataCollection<any, ODataModel<any>>,
         ODataModelField<any> | null
@@ -21,9 +24,10 @@ export declare class ODataModel<T> {
     _relations: {
         [name: string]: ODataModelRelation<any>;
     };
-    _resource?: ODataModelResource<T>;
+    _resource: ODataResource<T> | null;
     _annotations: ODataEntityAnnotations;
-    _resetting: boolean;
+    _reset: boolean;
+    _reparent: boolean;
     _silent: boolean;
     _meta: ODataModelOptions<T>;
     events$: EventEmitter<ODataModelEvent<T>>;
@@ -34,16 +38,14 @@ export declare class ODataModel<T> {
             ODataModel<any> | ODataCollection<any, ODataModel<any>>,
             ODataModelField<any> | null
         ];
-        resource?: ODataModelResource<T>;
+        resource?: ODataResource<T>;
         annots?: ODataEntityAnnotations;
         reset?: boolean;
     });
-    get [Symbol.toStringTag](): string;
-    equals(other: ODataModel<T>): boolean;
-    resource(): ODataModelResource<T>;
-    navigationProperty<N>(name: string): ODataNavigationPropertyResource<N>;
+    resource(): ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T>;
+    navigationProperty<N>(name: keyof T | string): ODataNavigationPropertyResource<N>;
     property<N>(name: string): ODataPropertyResource<N>;
-    attach(resource: ODataModelResource<T>): void;
+    attach(resource: ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T>): void;
     schema(): ODataStructuredType<T>;
     annots(): ODataEntityAnnotations;
     key({ field_mapping, resolve, }?: {
@@ -69,17 +71,17 @@ export declare class ODataModel<T> {
     _errors?: {
         [key: string]: any;
     };
-    protected validate({ method, navigation, }?: {
-        method?: 'create' | 'update' | 'patch';
+    validate({ method, navigation, }?: {
+        method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
     }): {
         [name: string]: string[];
     } | undefined;
     isValid({ method, navigation, }?: {
-        method?: 'create' | 'update' | 'patch';
+        method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
     }): boolean;
-    protected defaults(): {
+    defaults(): {
         [name: string]: any;
     };
     toEntity({ client_id, include_navigation, include_concurrency, include_computed, include_key, include_non_field, changes_only, field_mapping, chain, }?: {
@@ -95,6 +97,9 @@ export declare class ODataModel<T> {
     }): T | {
         [name: string]: any;
     };
+    toJSON(): T | {
+        [name: string]: any;
+    };
     attributes({ changes_only, include_concurrency, include_computed, include_non_field, field_mapping, }?: {
         changes_only?: boolean;
         include_concurrency?: boolean;
@@ -112,34 +117,30 @@ export declare class ODataModel<T> {
     }): void;
     assign(entity: Partial<T> | {
         [name: string]: any;
-    }, { reset, silent, }?: {
+    }, { reset, reparent, silent, }?: {
         reset?: boolean;
+        reparent?: boolean;
         silent?: boolean;
     }): void;
     clone<M extends ODataModel<T>>(): M;
     private _request;
-    fetch({ ...options }?: HttpOptions & {
-        options?: HttpOptions;
+    fetch({ ...options }?: ODataOptions & {
+        options?: ODataOptions;
     }): Observable<this>;
-    save({ method, navigation, validate, ...options }?: HttpOptions & {
-        method?: 'create' | 'update' | 'patch';
+    save({ method, navigation, validate, ...options }?: ODataOptions & {
+        method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
         validate?: boolean;
-        options?: HttpOptions;
+        options?: ODataOptions;
     }): Observable<this>;
-    destroy({ ...options }?: HttpOptions & {
-        options?: HttpOptions;
+    destroy({ ...options }?: ODataOptions & {
+        options?: ODataOptions;
     }): Observable<this>;
     /**
      * Create an execution context for change the internal query of a resource
      * @param func Function to execute
      */
-    query(func: (q: {
-        select(opts?: Select<T>): OptionHandler<Select<T>>;
-        expand(opts?: Expand<T>): OptionHandler<Expand<T>>;
-        format(opts?: string): OptionHandler<string>;
-        apply(query: QueryArguments<T>): void;
-    }) => void): void;
+    query(func: (q: ODataQueryOptionsHandler<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
@@ -150,15 +151,21 @@ export declare class ODataModel<T> {
     }): boolean;
     /**
      * Create an execution context for a given function, where the model is bound to its entity endpoint
-     * @param func Context function
-     * @returns Observable of R
+     * @param ctx Context function
+     * @returns The result of the context
      */
-    asEntity<R>(func: (model: this) => Observable<R>): Observable<R>;
-    protected callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & HttpQueryOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
-    protected callAction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & HttpQueryOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
-    protected cast<S>(type: string): ODataModel<S>;
-    protected fetchNavigationProperty<S>(name: string, responseType: 'model' | 'collection', { ...options }?: {} & HttpQueryOptions<S>): Observable<ODataModel<S> | ODataCollection<S, ODataModel<S>> | null>;
-    protected getValue<P>(name: string, options?: HttpOptions): Observable<P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null>;
-    protected setReference<P>(name: string, model: ODataModel<P> | ODataCollection<P, ODataModel<P>> | null, options?: HttpOptions): Observable<this>;
-    protected getReference<P>(name: string): ODataModel<P> | ODataCollection<P, ODataModel<P>>;
+    asEntity<R>(ctx: (model: this) => R): R;
+    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>;
+    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>;
+    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>>;
+    equals(other: ODataModel<T>): boolean;
+    get [Symbol.toStringTag](): string;
+    collection(): ODataCollection<T, ODataModel<T>> | undefined;
+    next(): ODataModel<T> | undefined;
+    prev(): ODataModel<T> | undefined;
 }
+export declare const RESERVED_FIELD_NAMES: string[];