angular-odata 0.80.0 → 0.99.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, ODataModelOptions } 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,28 +52,28 @@ 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;
@@ -82,9 +82,9 @@ export declare class ODataApi {
     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;

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/cache/storage.d.ts

@@ -1,5 +1,5 @@
-import { ODataCache } from './cache';
 import { ODataRequest, ODataResponse } from '../resources';
+import { ODataCache } from './cache';
 export declare class ODataInStorageCache extends ODataCache {
     name: string;
     storage: Storage;

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 { ODataActionResource, ODataBatchResource, ODataEntityResource, ODataEntitySetResource, ODataFunctionResource, ODataMetadataResource, ODataNavigationPropertyResource, ODataResource, ODataResponse, ODataSegment, ODataSingletonResource } from './resources/index';
-import { ODataCollection, ODataModel } from './models/index';
+import { Observable } from 'rxjs';
 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 { Observable } from 'rxjs';
 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[];

package/lib/constants.d.ts

@@ -56,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/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, ODataOptions, Select, Expand, OptionHandler, Transform, Filter, OrderBy, ODataQueryArguments, ODataQueryArgumentsOptions } 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,6 +44,9 @@ 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;
@@ -64,22 +67,16 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     }): 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;
@@ -89,7 +86,7 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
         server?: boolean;
     }): Observable<M>;
     set(path: string | string[], value: any): any;
-    get(path: number): M;
+    get(path: number): M | undefined;
     get(path: string | string[]): any;
     reset({ path, silent, }?: {
         path?: string | string[];
@@ -97,31 +94,14 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     }): 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: ODataQueryArguments<T>): void;
-    }) => void): void;
-    protected 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>;
-    protected 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>;
+    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;
@@ -130,8 +110,16 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     [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, ODataOptions, ODataEntityAnnotations, Select, Expand, EntityKey, OptionHandler, ODataQueryArguments, ODataQueryArgumentsOptions } 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,7 +71,7 @@ export declare class ODataModel<T> {
     _errors?: {
         [key: string]: any;
     };
-    protected validate({ method, navigation, }?: {
+    validate({ method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
     }): {
@@ -79,7 +81,7 @@ export declare class ODataModel<T> {
         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,8 +117,9 @@ 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;
@@ -134,12 +140,7 @@ export declare class ODataModel<T> {
      * 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: ODataQueryArguments<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
@@ -151,14 +152,20 @@ export declare class ODataModel<T> {
     /**
      * Create an execution context for a given function, where the model is bound to its entity endpoint
      * @param ctx Context function
-     * @returns Observable of R
+     * @returns The result of the context
      */
-    asEntity<R>(ctx: (model: this) => Observable<R>): Observable<R>;
-    protected 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>;
-    protected 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>;
-    protected cast<S>(type: string): ODataModel<S>;
-    protected fetchNavigationProperty<S>(name: string, responseType: 'model' | 'collection', { ...options }?: {} & ODataQueryArgumentsOptions<S>): Observable<ODataModel<S> | ODataCollection<S, ODataModel<S>> | null>;
-    protected getValue<P>(name: string, options?: ODataOptions): Observable<P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null>;
-    protected setReference<P>(name: string, model: ODataModel<P> | ODataCollection<P, ODataModel<P>> | null, options?: ODataOptions): 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[];

package/lib/models/options.d.ts

@@ -1,13 +1,9 @@
-import { Observable, Subscription } from 'rxjs';
-import { ODataStructuredTypeFieldParser } from '../parsers';
-import { Expand, ODataEntitiesAnnotations, ODataEntityAnnotations, ODataEntityResource, ODataEntitySetResource, ODataNavigationPropertyResource, ODataPropertyResource, EntityKey, ODataResource, ODataSingletonResource, OptionHandler, ODataQueryArguments, Select } from '../resources';
-import { ODataEntitySet, ODataStructuredType } from '../schema';
-import { Options } from '../types';
+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 { Options, OptionsHelper } from '../types';
 import type { ODataCollection } from './collection';
 import type { ODataModel } from './model';
-export declare const CID = "_cid";
-export declare type ODataModelResource<T> = ODataEntityResource<T> | ODataSingletonResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>;
-export declare type ODataCollectionResource<T> = ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>;
 export declare type ODataModelEventType = 'change' | 'reset' | 'update' | 'destroy' | 'add' | 'remove' | 'invalid' | 'request' | 'sync' | 'attach';
 export declare class ODataModelEvent<T> {
     name: ODataModelEventType;
@@ -100,18 +96,19 @@ export declare class ODataModelField<F> {
     get type(): string;
     get navigation(): boolean;
     get collection(): boolean;
-    get computed(): boolean;
-    configure({ findOptionsForType, concurrency, }: {
+    annotatedValue<T>(term: string | RegExp): T | undefined;
+    configure({ findOptionsForType, concurrency, options, }: {
         findOptionsForType: (type: string) => ODataModelOptions<any> | undefined;
         concurrency: boolean;
+        options: OptionsHelper;
     }): void;
     isKey(): boolean;
     hasReferentials(): boolean;
-    get referentials(): import("../parsers").ODataReferential[];
+    get referentials(): import("../schema").ODataReferential[];
     isStructuredType(): boolean;
-    structured(): ODataStructuredType<F> | undefined;
+    structured(): ODataStructuredType<F>;
     isEnumType(): boolean;
-    enum(): import("../schema").ODataEnumType<F> | undefined;
+    enum(): import("../schema").ODataEnumType<F>;
     validate(value: any, { method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
@@ -120,9 +117,9 @@ export declare class ODataModelField<F> {
     deserialize(value: any, options?: Options): F;
     serialize(value: F, options?: Options): any;
     encode(value: F, options?: Options): any;
-    resourceFactory<T, F>(resource: ODataModelResource<T>): ODataNavigationPropertyResource<F> | ODataPropertyResource<F>;
-    annotationsFactory(annots: ODataEntityAnnotations): ODataEntityAnnotations | ODataEntitiesAnnotations;
-    schemaFactory<T, F>(schema: ODataStructuredType<T>): ODataStructuredType<F> | undefined;
+    resourceFactory<T, F>(base: ODataResource<T>): ODataNavigationPropertyResource<F> | ODataPropertyResource<F>;
+    annotationsFactory(base: ODataEntityAnnotations): ODataEntityAnnotations | ODataEntitiesAnnotations;
+    schemaFactory<T, F>(base: ODataStructuredType<T>): ODataStructuredType<F> | undefined;
     modelCollectionFactory<T, F>({ parent, value, reset, }: {
         parent: ODataModel<any>;
         value?: F | F[] | {
@@ -157,47 +154,41 @@ export declare class ODataModelOptions<T> {
     entitySet?: ODataEntitySet;
     parent?: ODataModelOptions<any>;
     children: ODataModelOptions<any>[];
-    constructor(options: ModelOptions, schema: ODataStructuredType<T>);
+    constructor({ options, schema, }: {
+        options: ModelOptions;
+        schema: ODataStructuredType<T>;
+    });
     get api(): import("angular-odata").ODataApi;
     type(): string;
     isTypeOf(type: string): boolean;
     findChildOptions(predicate: (options: ODataModelOptions<any>) => boolean): ODataModelOptions<any> | undefined;
-    configure({ findOptionsForType, }: {
+    configure({ findOptionsForType, options, }: {
         findOptionsForType: (type: string) => ODataModelOptions<any> | undefined;
+        options: OptionsHelper;
     }): void;
     fields({ include_navigation, include_parents, }?: {
         include_parents?: boolean;
         include_navigation?: boolean;
     }): ODataModelField<any>[];
-    field(name: keyof T | string): ODataModelField<any> | undefined;
-    attach(self: ODataModel<T>, resource: ODataModelResource<T>): void;
+    field<F>(name: keyof T | string): ODataModelField<any>;
+    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>>,
         ODataModelField<any> | null
     ][];
-    static resource<T>(child: ODataModel<T> | ODataCollection<T, ODataModel<T>>): ODataModelResource<T> | ODataCollectionResource<T>;
-    collectionResourceFactory({ baseResource, }?: {
-        baseResource?: ODataResource<T>;
-    }): ODataCollectionResource<T>;
-    modelResourceFactory({ baseResource, }?: {
-        fromSet?: boolean;
-        baseResource?: ODataResource<T>;
-    }): ODataModelResource<T>;
-    entityResource(self: ODataModel<T>): ODataModelResource<T>;
+    static resource<T>(child: ODataModel<T> | ODataCollection<T, ODataModel<T>>): ODataResource<T> | ODataResource<T>;
+    collectionResourceFactory(query?: ODataQueryOptions<T>): ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | undefined;
+    modelResourceFactory(query?: ODataQueryOptions<T>): ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T> | undefined;
+    entityResource(self: ODataModel<T>): ODataResource<T>;
     bind(self: ODataModel<T>, { parent, resource, annots, }?: {
         parent?: [
             ODataModel<any> | ODataCollection<any, ODataModel<any>>,
             ODataModelField<any> | null
         ];
-        resource?: ODataModelResource<T>;
+        resource?: ODataResource<T>;
         annots?: ODataEntityAnnotations;
     }): void;
-    query(self: ODataModel<T>, resource: ODataModelResource<T>, func: (q: {
-        select(opts?: Select<T>): OptionHandler<Select<T>>;
-        expand(opts?: Expand<T>): OptionHandler<Expand<T>>;
-        format(opts?: string): OptionHandler<string>;
-        apply(query: ODataQueryArguments<T>): void;
-    }) => void): void;
+    query(self: ODataModel<T>, resource: ODataEntityResource<T> | ODataPropertyResource<T> | ODataNavigationPropertyResource<T> | ODataSingletonResource<T>, func: (q: ODataQueryOptionsHandler<T>) => void): ODataModel<T>;
     resolveKey(value: ODataModel<T> | T | {
         [name: string]: any;
     }, { field_mapping, resolve, }?: {
@@ -234,7 +225,7 @@ export declare class ODataModelOptions<T> {
     hasChanged(self: ODataModel<T>, { include_navigation }?: {
         include_navigation?: boolean;
     }): boolean;
-    asEntity<R, M extends ODataModel<T>>(self: M, func: (model: M) => Observable<R>): Observable<R>;
+    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;
         include_navigation?: boolean;
@@ -263,8 +254,9 @@ export declare class ODataModelOptions<T> {
     }): void;
     assign(self: ODataModel<T>, entity: Partial<T> | {
         [name: string]: any;
-    }, { reset, silent, }?: {
+    }, { reset, reparent, silent, }?: {
         reset?: boolean;
+        reparent?: boolean;
         silent?: boolean;
     }): void;
     static isModel(obj: any): boolean;

package/lib/module.d.ts

@@ -1,6 +1,6 @@
 import { ModuleWithProviders } from '@angular/core';
-import { ApiConfig } from './types';
 import { ODataSettings } from './settings';
+import { ApiConfig } from './types';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common/http";
 export declare function createSettings(configs: ApiConfig[]): ODataSettings;