angular-odata 0.90.0 → 0.99.2

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,11 +1,11 @@
 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;

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, ODataQueryArgumentsOptions, ODataQueryOptionsHandler } 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,14 +20,14 @@ 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;
+    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;
@@ -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,13 +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: ODataQueryOptionsHandler<T>) => void): this;
-    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>;
+    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;
@@ -116,6 +114,8 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     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;

package/lib/models/model.d.ts

@@ -1,13 +1,16 @@
 import { EventEmitter } from '@angular/core';
 import { Observable } from 'rxjs';
-import { ODataNavigationPropertyResource, ODataPropertyResource, ODataOptions, ODataEntityAnnotations, EntityKey, ODataQueryArgumentsOptions, ODataQueryOptionsHandler } from '../resources';
-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<R>(resource: ODataEntityResource<R> | ODataNavigationPropertyResource<R> | ODataPropertyResource<R> | ODataSingletonResource<R>): 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;
@@ -149,11 +155,17 @@ export declare class ODataModel<T> {
      * @returns The result of the context
      */
     asEntity<R>(ctx: (model: this) => R): 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>>;
+    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 { Subscription } from 'rxjs';
-import { ODataStructuredTypeFieldParser } from '../parsers';
-import { ODataEntitiesAnnotations, ODataEntityAnnotations, ODataEntityResource, ODataEntitySetResource, ODataNavigationPropertyResource, ODataPropertyResource, EntityKey, ODataResource, ODataSingletonResource, ODataQueryOptionsHandler } from '../resources';
-import { ODataEntitySet, ODataStructuredType } from '../schema';
-import { Options } from '../types';
+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,7 +117,7 @@ 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>(base: ODataModelResource<T>): ODataNavigationPropertyResource<F> | ODataPropertyResource<F>;
+    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, }: {
@@ -157,42 +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<F>(name: keyof T | string): ODataModelField<any> | undefined;
-    attach(self: ODataModel<T>, resource: ODataModelResource<T>): void;
+    field<F>(name: keyof T | string): ODataModelField<F>;
+    attach<R>(self: ODataModel<T>, resource: ODataEntityResource<R> | ODataNavigationPropertyResource<R> | ODataPropertyResource<R> | ODataSingletonResource<R>): 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>;
+    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: ODataQueryOptionsHandler<T>) => void): ODataModel<T>;
+    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, }?: {
@@ -258,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;

package/lib/options.d.ts

@@ -74,6 +74,7 @@ export declare class ODataApiOptions implements ApiOptions, OptionsHelper {
          */
         includeAnnotations?: string;
     };
+    deleteRefBy: 'path' | 'id';
     constructor(config: ApiOptions);
     get helper(): import("./helper").ODataVersionHelper;
 }

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

@@ -1,5 +1,5 @@
-import { EntityKey } from '../resource';
 import { PathSegmentNames } from '../../types';
+import { EntityKey } from '../resource';
 import { SegmentHandler } from './handlers';
 export declare type ODataSegment = {
     name: PathSegmentNames;
@@ -11,7 +11,7 @@ export declare type ODataSegment = {
 export declare class ODataPathSegments {
     private _segments;
     constructor(segments?: ODataSegment[]);
-    pathAndParams(): [string, {
+    pathAndParams(escape?: boolean): [string, {
         [name: string]: any;
     }];
     types({ key }?: {

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

@@ -83,10 +83,14 @@ export declare type QueryOptions<T> = ExpandOptions<T> & {
     };
     format: string;
     aliases: QueryCustomType[];
+    escape: boolean;
 };
 export declare const ITEM_ROOT = "";
-export default function <T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, aliases, }?: Partial<QueryOptions<T>>): string;
-export declare function buildPathAndQuery<T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, aliases, }?: Partial<QueryOptions<T>>): [string, {
+export default function <T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): string;
+export declare function buildPathAndQuery<T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): [string, {
     [name: string]: any;
 }];
-export declare function normalizeValue(value: Value, aliases?: QueryCustomType[]): any;
+export declare function normalizeValue(value: Value, { aliases, escape }: {
+    aliases?: QueryCustomType[];
+    escape?: boolean;
+}): any;

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

@@ -0,0 +1,19 @@
+import type { QueryCustomType } from '../builder';
+import { Renderable } from './syntax';
+export declare abstract class Expression<T> implements Renderable {
+    protected _children: Renderable[];
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    get [Symbol.toStringTag](): string;
+    abstract render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    children(): Renderable[];
+    length(): number;
+    toJSON(): {
+        children: any[];
+    };
+}

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

@@ -0,0 +1,26 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { ODataFunctions, ODataOperators, Renderable } from './syntax';
+export declare class ComputeExpression<T> extends Expression<T> {
+    names: string[];
+    constructor({ children, names, }?: {
+        children?: Renderable[];
+        names?: string[];
+    });
+    static e<T>(): ComputeExpression<T>;
+    static s<T extends object>(): T;
+    static compute<T extends object>(opts: (e: {
+        s: T;
+        e: () => ComputeExpression<T>;
+    }) => ComputeExpression<T>): ComputeExpression<T>;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    private _add;
+    field<T extends object>(name: string, opts: (e: {
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Renderable): ComputeExpression<T>;
+}

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

@@ -0,0 +1,40 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { Renderable } from './syntax';
+export declare class ExpandField<T> implements Renderable {
+    protected field: Renderable;
+    constructor(field: Renderable);
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        field: any;
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+    select(): void;
+    filter(): void;
+    levels(): void;
+    orderBy(): void;
+    top(): void;
+    skip(): void;
+}
+export declare class ExpandExpression<T> extends Expression<T> {
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    static e<T>(): ExpandExpression<T>;
+    static s<T extends object>(): T;
+    static expand<T extends object>(opts: (e: {
+        s: T;
+        e: () => ExpandExpression<T>;
+    }) => ExpandExpression<T>): ExpandExpression<T>;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    private _add;
+    field<T extends object>(field: any, opts?: (e: ExpandField<keyof T>) => void): ExpandExpression<T>;
+}