angular-odata 0.92.0 → 0.95.0

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

@@ -1,14 +1,20 @@
 import type { QueryCustomType } from './builder';
 export interface Renderable {
-    render({ aliases, escape, }: {
+    render({ aliases, escape, prefix, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
+        prefix?: string;
     }): string;
     toString(): string;
     toJSON(): any;
 }
-export declare type Funcs<T> = (x: ODataSyntax<T>) => Function<T> | Operator<T> | Grouping<T> | Navigation<T, any>;
-export declare type Field<T> = keyof T | Funcs<keyof T>;
+export declare type Funcs<T> = (x: ODataSyntax<T>) => Function<T> | Operator<T> | Grouping<T>;
+export declare class Field<T extends object> implements ProxyHandler<T> {
+    name: string;
+    constructor(name?: string);
+    static factory<T extends object>(): T;
+    get(target: T, p: string | symbol): any;
+}
 export declare class Function<T> implements Renderable {
     protected name: string;
     protected values: any[];
@@ -21,19 +27,20 @@ export declare class Function<T> implements Renderable {
         values: any[];
         normalize: boolean;
     };
-    render({ aliases, escape, }: {
+    render({ aliases, escape, prefix, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
+        prefix?: string;
     }): string;
 }
 export declare class StringAndCollectionFunctions<T> {
-    concat(field: T, value: any, normalize?: boolean): Function<T>;
-    contains(field: T, value: any, normalize?: boolean): Function<T>;
-    endsWith(field: T, value: any, normalize?: boolean): Function<T>;
-    indexOf(field: T, value: any, normalize?: boolean): Function<T>;
-    length(value: T, normalize?: boolean): Function<T>;
-    startsWith(field: T, value: any, normalize?: boolean): Function<T>;
-    subString(field: T, start: number, length?: number): Function<T>;
+    concat(field: any, value: any, normalize?: boolean): Function<T>;
+    contains(field: any, value: any, normalize?: boolean): Function<T>;
+    endsWith(field: any, value: any, normalize?: boolean): Function<T>;
+    indexOf(field: any, value: any, normalize?: boolean): Function<T>;
+    length(value: any, normalize?: boolean): Function<T>;
+    startsWith(field: any, value: any, normalize?: boolean): Function<T>;
+    subString(field: any, start: number, length?: number): Function<T>;
 }
 export declare class CollectionFunctions<T> {
     hasSubset(s1: T, s2: any): Function<T>;
@@ -46,20 +53,20 @@ export declare class StringFunctions<T> {
     trim(value: T): Function<T>;
 }
 export declare class DateAndTimeFunctions<T> {
-    date(value: T): Function<T>;
-    day(value: T): Function<T>;
-    fractionalseconds(value: T): Function<T>;
-    hour(value: T): Function<T>;
-    maxdatetime(value: T): Function<T>;
-    mindatetime(value: T): Function<T>;
-    minute(value: T): Function<T>;
-    month(value: T): Function<T>;
+    date(value: any): Function<T>;
+    day(value: any): Function<T>;
+    fractionalseconds(value: any): Function<T>;
+    hour(value: any): Function<T>;
+    maxdatetime(value: any): Function<T>;
+    mindatetime(value: any): Function<T>;
+    minute(value: any): Function<T>;
+    month(value: any): Function<T>;
     now(): Function<T>;
-    second(value: T): Function<T>;
-    time(value: T): Function<T>;
-    totaloffsetminutes(value: T): Function<T>;
-    totalseconds(value: T): Function<T>;
-    year(value: T): Function<T>;
+    second(value: any): Function<T>;
+    time(value: any): Function<T>;
+    totaloffsetminutes(value: any): Function<T>;
+    totalseconds(value: any): Function<T>;
+    year(value: any): Function<T>;
 }
 export declare class ArithmeticFunctions<T> {
     ceiling(value: T | string): Function<T>;
@@ -89,9 +96,10 @@ export declare class Operator<T> implements Renderable {
         values: any[];
         normalize: boolean;
     };
-    render({ aliases, escape, }: {
+    render({ aliases, escape, prefix, }: {
         aliases?: QueryCustomType[];
-        escape: boolean;
+        escape?: boolean;
+        prefix?: string;
     }): string;
 }
 export declare class LogicalOperators<T> {
@@ -101,8 +109,6 @@ export declare class LogicalOperators<T> {
     ge(left: any, right: any, normalize?: boolean): Operator<unknown>;
     lt(left: any, right: any, normalize?: boolean): Operator<unknown>;
     le(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    and(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    or(left: any, right: any, normalize?: boolean): Operator<unknown>;
     not(value: any, normalize?: boolean): Operator<T>;
     has(left: any, right: any, normalize?: boolean): Operator<unknown>;
     in(left: any, right: any, normalize?: boolean): Operator<unknown>;
@@ -122,47 +128,39 @@ export declare class Grouping<T> implements Renderable {
     toJSON(): {
         group: any;
     };
-    render({ aliases, escape, }: {
-        aliases?: QueryCustomType[];
-        escape: boolean;
-    }): string;
-}
-export declare class Navigation<T, N> implements Renderable {
-    protected field: T;
-    protected value: Field<N>;
-    constructor(field: T, value: Field<N>);
-    get [Symbol.toStringTag](): string;
-    toJSON(): {
-        field: T;
-        value: Field<N>;
-    };
-    render({ aliases, escape, }: {
+    render({ aliases, escape, prefix, }: {
         aliases?: QueryCustomType[];
-        escape: boolean;
+        escape?: boolean;
+        prefix?: string;
     }): string;
 }
-export declare class GroupingAndNavigationOperators<T> {
+export declare class GroupingOperators<T> {
     grouping(value: any): Grouping<unknown>;
-    navigation<N>(field: T, value: Field<N>): Navigation<T, N>;
 }
-export declare class Lambda<T> extends Operator<T> {
+export declare class Lambda<T> implements Renderable {
     protected op: string;
     protected values: any[];
-    protected normalize: boolean;
-    constructor(op: string, values: any[], normalize?: boolean);
+    protected alias?: string | undefined;
+    constructor(op: string, values: any[], alias?: string | undefined);
     get [Symbol.toStringTag](): string;
-    render({ aliases, escape, }: {
+    toJSON(): {
+        op: string;
+        values: any[];
+        alias: string | undefined;
+    };
+    render({ aliases, escape, prefix, }: {
         aliases?: QueryCustomType[];
-        escape: boolean;
+        escape?: boolean;
+        prefix?: string;
     }): string;
 }
 export declare class LambdaOperators<T> {
-    any(field: T, value: any): Lambda<unknown>;
-    all(field: T, value: any): Lambda<unknown>;
+    any(field: T, value: any, alias?: string): Lambda<unknown>;
+    all(field: T, value: any, alias?: string): Lambda<unknown>;
 }
 export declare class ODataOperators<T> {
 }
-export interface ODataOperators<T> extends LogicalOperators<T>, ArithmeticOperators<T>, GroupingAndNavigationOperators<T>, LambdaOperators<T> {
+export interface ODataOperators<T> extends LogicalOperators<T>, ArithmeticOperators<T>, GroupingOperators<T>, LambdaOperators<T> {
 }
 export declare const operators: ODataOperators<any>;
 export declare class ODataFunctions<T> {

package/lib/resources/request.d.ts

@@ -1,7 +1,7 @@
 import { HttpHeaders, HttpParams } from '@angular/common/http';
 import { ODataApi } from '../api';
-import { ODataResource } from './resource';
 import { QueryOptionNames } from '../types';
+import { ODataResource } from './resource';
 export declare class ODataRequest<T> {
     readonly api: ODataApi;
     readonly observe: 'events' | 'response';

package/lib/resources/resource.d.ts

@@ -1,18 +1,26 @@
 import { Observable } from 'rxjs';
 import { ODataApi } from '../api';
-import { ODataCallable, ODataStructuredType } from '../schema';
+import { ODataCollection, ODataModel } from '../models';
+import { ODataStructuredType } from '../schema';
+import { ODataSchemaElement } from '../schema/element';
 import { OptionsHelper, QueryOptionNames } from '../types';
 import { ODataPathSegments, ODataPathSegmentsHandler } from './path';
 import { ODataQueryOptions, ODataQueryOptionsHandler, QueryCustomType } from './query';
+import { ODataEntitiesAnnotations, ODataEntityAnnotations } from './responses/index';
 import { ODataOptions } from './types';
 export declare type EntityKey<T> = {
     readonly [P in keyof T]?: T[P];
 } | QueryCustomType | string | number;
-export declare abstract class ODataResource<T> {
+export declare class ODataResource<T> {
     api: ODataApi;
+    schema?: ODataSchemaElement;
     protected pathSegments: ODataPathSegments;
     protected queryOptions: ODataQueryOptions<T>;
-    constructor(api: ODataApi, segments?: ODataPathSegments, query?: ODataQueryOptions<T>);
+    constructor(api: ODataApi, { segments, query, schema, }?: {
+        segments?: ODataPathSegments;
+        query?: ODataQueryOptions<T>;
+        schema?: ODataSchemaElement;
+    });
     /**
      * @returns string The type of the resource
      */
@@ -30,17 +38,26 @@ export declare abstract class ODataResource<T> {
      */
     hasKey(): boolean;
     clearKey(): void | undefined;
+    asModel<M extends ODataModel<T>>(entity?: Partial<T> | {
+        [name: string]: any;
+    }, { annots, reset }?: {
+        annots?: ODataEntityAnnotations;
+        reset?: boolean;
+    }): M;
+    asCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(entities?: Partial<T>[] | {
+        [name: string]: any;
+    }[], { annots, reset, }?: {
+        annots?: ODataEntitiesAnnotations;
+        reset?: boolean;
+    }): C;
     isSubtypeOf(other: ODataResource<any>): boolean;
-    isParentOf(other: ODataResource<any>): boolean;
-    isChildOf(other: ODataResource<any>): boolean;
     isEqualTo(other: ODataResource<any>, test?: 'path' | 'params'): boolean;
     pathAndParams(escape?: boolean): [string, {
         [name: string]: any;
     }];
     endpointUrl(params?: boolean): string;
     toString(): string;
-    abstract clone(): ODataResource<T>;
-    abstract schema(): ODataStructuredType<T> | ODataCallable<T> | undefined;
+    clone<R extends ODataResource<T>>(): R;
     deserialize(value: any, options?: OptionsHelper): any;
     serialize(value: any, options?: OptionsHelper): any;
     encode(value: any, options?: OptionsHelper): any;
@@ -64,7 +81,7 @@ export declare abstract class ODataResource<T> {
      * @param f Function context for handle the query options
      */
     query(f: (q: ODataQueryOptionsHandler<T>) => void): this;
-    static resolveKey<T>(value: any, schema?: ODataStructuredType<T> | ODataCallable<T>): EntityKey<T> | undefined;
+    static resolveKey<T>(value: any, schema?: ODataStructuredType<T>): EntityKey<T> | undefined;
     protected resolveKey(value: any): EntityKey<T> | undefined;
     protected request(method: string, options: ODataOptions & {
         body?: any;

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

@@ -1,28 +1,21 @@
-import { ODataCollection, ODataModel } from '../../models';
-import { ODataEntities, ODataEntitiesAnnotations, ODataEntity, ODataEntityAnnotations, ODataProperty } from '../responses';
-import { ODataEntitiesOptions, ODataEntityOptions, ODataNoneOptions, ODataOptions, ODataPropertyOptions } from './options';
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
+import { ODataCollection, ODataModel } from '../../models';
+import { ODataCallable } from '../../schema/callable';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
+import { ODataEntities, ODataEntity, ODataProperty } from '../responses';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataNoneOptions, ODataOptions, ODataPropertyOptions } from './options';
 export declare class ODataActionResource<P, R> extends ODataResource<R> {
-    static factory<P, R>(api: ODataApi, path: string, type: string | undefined, segments: ODataPathSegments, query: ODataQueryOptions<R>): ODataActionResource<P, R>;
-    clone(): ODataActionResource<P, R>;
-    schema(): import("angular-odata").ODataCallable<R> | undefined;
+    static factory<P, R>(api: ODataApi, { path, schema, segments, query, }: {
+        path?: string;
+        schema?: ODataCallable<R>;
+        segments?: ODataPathSegments;
+        query?: ODataQueryOptions<R>;
+    }): ODataActionResource<P, R>;
+    static fromResource<P, R>(resource: ODataResource<any>, path: string): ODataActionResource<P, R>;
     returnType(): string | undefined;
-    asModel<M extends ODataModel<R>>(entity: Partial<R> | {
-        [name: string]: any;
-    }, { annots, reset }?: {
-        annots?: ODataEntityAnnotations;
-        reset?: boolean;
-    }): M;
-    asCollection<M extends ODataModel<R>, C extends ODataCollection<R, M>>(entities: Partial<R>[] | {
-        [name: string]: any;
-    }[], { annots, reset, }?: {
-        annots?: ODataEntitiesAnnotations;
-        reset?: boolean;
-    }): C;
     protected post(params: P | null, options?: ODataEntityOptions & ODataEntitiesOptions & ODataPropertyOptions): Observable<any>;
     /**
      * Execute the action

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

@@ -1,9 +1,9 @@
 import { Observable, Subject } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataOptions } from './options';
 import { ODataRequest } from '../request';
 import { ODataResource } from '../resource';
 import { ODataResponse } from '../responses';
+import { ODataOptions } from './options';
 export declare class ODataBatchRequest<T> extends Subject<ODataResponse<T>> {
     request: ODataRequest<any>;
     constructor(request: ODataRequest<any>);
@@ -25,8 +25,6 @@ export declare class ODataBatchResource extends ODataResource<any> {
     private _requests;
     requests(): ODataRequest<any>[];
     static factory(api: ODataApi): ODataBatchResource;
-    clone(): ODataBatchResource;
-    schema(): undefined;
     /**
      * Execute the batch request
      * @param ctx The context for the request

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

@@ -1,13 +1,14 @@
 import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataOptions } from './options';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
+import { ODataOptions } from './options';
 export declare class ODataCountResource<T> extends ODataResource<T> {
-    static factory<T>(api: ODataApi, segments: ODataPathSegments, query: ODataQueryOptions<T>): ODataCountResource<T>;
-    clone(): ODataCountResource<T>;
-    schema(): undefined;
+    static factory<T>(api: ODataApi, { segments, query, }: {
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<T>;
+    }): ODataCountResource<T>;
     protected get(options?: ODataOptions): Observable<number>;
     /**
      * Fetch the count of the set.

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

@@ -1,31 +1,27 @@
 import { Observable } from 'rxjs';
-import { ODataResource } from '../resource';
+import { ODataApi } from '../../api';
 import { ODataCollection, ODataModel } from '../../models';
-import { ODataEntities, ODataEntitiesAnnotations, ODataEntity } from '../responses';
+import { ODataStructuredType } from '../../schema/structured-type';
 import { QueryOptionNames } from '../../types';
+import { ODataQueryOptions } from '../query';
+import { ODataResource } from '../resource';
+import { ODataEntities, ODataEntity } from '../responses';
 import { ODataActionResource } from './action';
-import { ODataApi } from '../../api';
 import { ODataCountResource } from './count';
 import { ODataEntityResource } from './entity';
 import { ODataFunctionResource } from './function';
 import { ODataOptions } from './options';
-import { ODataPathSegments } from '../path';
-import { ODataQueryOptions } from '../query';
 export declare class ODataEntitySetResource<T> extends ODataResource<T> {
-    static factory<E>(api: ODataApi, path: string, type: string | undefined, segments: ODataPathSegments, query: ODataQueryOptions<E>): ODataEntitySetResource<E>;
-    clone(): ODataEntitySetResource<T>;
-    schema(): import("angular-odata").ODataStructuredType<T> | undefined;
-    asCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(entities: Partial<T>[] | {
-        [name: string]: any;
-    }[], { annots, reset, }?: {
-        annots?: ODataEntitiesAnnotations;
-        reset?: boolean;
-    }): C;
+    static factory<E>(api: ODataApi, { path, schema, query, }: {
+        path: string;
+        schema?: ODataStructuredType<E>;
+        query?: ODataQueryOptions<E>;
+    }): ODataEntitySetResource<E>;
     entity(key?: any): ODataEntityResource<T>;
-    cast<C>(type: string): ODataEntitySetResource<C>;
     action<P, R>(path: string): ODataActionResource<P, R>;
     function<P, R>(path: string): ODataFunctionResource<P, R>;
     count(): ODataCountResource<T>;
+    cast<C>(type: string): ODataEntitySetResource<C>;
     protected post(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
     protected get(options?: ODataOptions & {
         withCount?: boolean;

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

@@ -1,27 +1,24 @@
-import { ODataResource } from '../resource';
-import { ODataEntity, ODataEntityAnnotations } from '../responses';
 import { Observable } from 'rxjs';
+import { ODataApi } from '../../api';
+import { ODataModel } from '../../models';
+import { ODataStructuredType } from '../../schema/structured-type';
 import { QueryOptionNames } from '../../types';
+import { ODataPathSegments } from '../path';
+import { ODataQueryOptions } from '../query';
+import { ODataResource } from '../resource';
+import { ODataEntity } from '../responses/types';
 import { ODataActionResource } from './action';
-import { ODataApi } from '../../api';
 import { ODataFunctionResource } from './function';
 import { ODataMediaResource } from './media';
-import { ODataModel } from '../../models';
 import { ODataNavigationPropertyResource } from './navigation-property';
 import { ODataOptions } from './options';
-import { ODataPathSegments } from '../path';
 import { ODataPropertyResource } from './property';
-import { ODataQueryOptions } from '../query';
 export declare class ODataEntityResource<T> extends ODataResource<T> {
-    static factory<E>(api: ODataApi, segments: ODataPathSegments, options: ODataQueryOptions<E>): ODataEntityResource<E>;
-    clone(): ODataEntityResource<T>;
-    schema(): import("../../schema").ODataStructuredType<T> | undefined;
-    asModel<M extends ODataModel<T>>(entity: Partial<T> | {
-        [name: string]: any;
-    }, { annots, reset }?: {
-        annots?: ODataEntityAnnotations;
-        reset?: boolean;
-    }): M;
+    static factory<E>(api: ODataApi, { schema, segments, query, }: {
+        schema?: ODataStructuredType<E>;
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<E>;
+    }): ODataEntityResource<E>;
     key(value: any): ODataEntityResource<T>;
     keys(values: any[]): ODataEntityResource<T>;
     media(): ODataMediaResource;

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

@@ -1,29 +1,22 @@
-import { ODataEntities, ODataEntitiesAnnotations, ODataEntity, ODataEntityAnnotations, ODataProperty } from '../responses';
-import { ODataEntitiesOptions, ODataEntityOptions, ODataNoneOptions, ODataOptions, ODataPropertyOptions } from './options';
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
 import { ODataCollection } from '../../models/collection';
 import { ODataModel } from '../../models/model';
+import { ODataCallable } from '../../schema/callable';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
+import { ODataEntities, ODataEntity, ODataProperty } from '../responses';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataNoneOptions, ODataOptions, ODataPropertyOptions } from './options';
 export declare class ODataFunctionResource<P, R> extends ODataResource<R> {
-    static factory<P, R>(api: ODataApi, path: string, type: string | undefined, segments: ODataPathSegments, options: ODataQueryOptions<R>): ODataFunctionResource<P, R>;
-    clone(): ODataFunctionResource<P, R>;
+    static factory<P, R>(api: ODataApi, { path, schema, segments, query, }: {
+        path?: string;
+        schema?: ODataCallable<R>;
+        segments?: ODataPathSegments;
+        query?: ODataQueryOptions<R>;
+    }): ODataFunctionResource<P, R>;
+    static fromResource<P, R>(resource: ODataResource<any>, path: string): ODataFunctionResource<P, R>;
     returnType(): string | undefined;
-    schema(): import("angular-odata").ODataCallable<R> | undefined;
-    asModel<M extends ODataModel<R>>(entity: Partial<R> | {
-        [name: string]: any;
-    }, { annots, reset }?: {
-        annots?: ODataEntityAnnotations;
-        reset?: boolean;
-    }): M;
-    asCollection<M extends ODataModel<R>, C extends ODataCollection<R, M>>(entities: Partial<R>[] | {
-        [name: string]: any;
-    }[], { annots, reset, }?: {
-        annots?: ODataEntitiesAnnotations;
-        reset?: boolean;
-    }): C;
     parameters(params: P | null, { alias }?: {
         alias?: boolean;
     }): ODataFunctionResource<P, R>;

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

@@ -1,13 +1,14 @@
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataOptions } from './options';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
+import { ODataOptions } from './options';
 export declare class ODataMediaResource extends ODataResource<any> {
-    static factory<V>(api: ODataApi, segments: ODataPathSegments, options: ODataQueryOptions<V>): ODataMediaResource;
-    clone(): ODataMediaResource;
-    schema(): undefined;
+    static factory<V>(api: ODataApi, { segments, query, }: {
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<V>;
+    }): ODataMediaResource;
     protected get(options: {
         responseType: any;
     } & ODataOptions): Observable<any>;

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

@@ -1,14 +1,12 @@
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataMetadata } from '../responses';
-import { ODataOptions } from './options';
 import { ODataPathSegments } from '../path';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
+import { ODataMetadata } from '../responses';
+import { ODataOptions } from './options';
 export declare class ODataMetadataResource extends ODataResource<any> {
     constructor(api: ODataApi, segments?: ODataPathSegments);
     static factory(api: ODataApi): ODataMetadataResource;
-    clone(): ODataMetadataResource;
-    schema(): undefined;
     protected get(options?: ODataOptions): Observable<ODataMetadata>;
     fetch(options?: ODataOptions): Observable<ODataMetadata>;
 }

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

@@ -1,15 +1,16 @@
 import { Observable } from 'rxjs';
-import { ODataResource } from '../resource';
+import { ODataApi } from '../../api';
 import { ODataCollection, ODataModel } from '../../models';
-import { ODataEntities, ODataEntitiesAnnotations, ODataEntity, ODataEntityAnnotations } from '../responses';
-import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions } from './options';
+import { ODataStructuredType } from '../../schema';
 import { QueryOptionNames } from '../../types';
-import { ODataApi } from '../../api';
+import { ODataPathSegments } from '../path';
+import { ODataQueryOptions } from '../query';
+import { ODataResource } from '../resource';
+import { ODataEntities, ODataEntity } from '../responses';
 import { ODataCountResource } from './count';
 import { ODataMediaResource } from './media';
-import { ODataPathSegments } from '../path';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions } from './options';
 import { ODataPropertyResource } from './property';
-import { ODataQueryOptions } from '../query';
 import { ODataReferenceResource } from './reference';
 /**
  * OData Navigation Property Resource
@@ -17,21 +18,14 @@ import { ODataReferenceResource } from './reference';
  * https://www.odata.org/getting-started/advanced-tutorial/#derived
  */
 export declare class ODataNavigationPropertyResource<T> extends ODataResource<T> {
-    static factory<E>(api: ODataApi, path: string, type: string | undefined, segments: ODataPathSegments, options: ODataQueryOptions<E>): ODataNavigationPropertyResource<E>;
-    clone(): ODataNavigationPropertyResource<T>;
-    schema(): import("../../schema").ODataStructuredType<T> | undefined;
-    asModel<M extends ODataModel<T>>(entity: Partial<T> | {
-        [name: string]: any;
-    }, { annots, reset }?: {
-        annots?: ODataEntityAnnotations;
-        reset?: boolean;
-    }): M;
-    asCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(entities: Partial<T>[] | {
-        [name: string]: any;
-    }[], { annots, reset, }?: {
-        annots?: ODataEntitiesAnnotations;
-        reset?: boolean;
-    }): C;
+    static factory<N>(api: ODataApi, { path, type, schema, segments, query, }: {
+        path: string;
+        type?: string;
+        schema?: ODataStructuredType<N>;
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<N>;
+    }): ODataNavigationPropertyResource<N>;
+    static fromResource<N>(resource: ODataResource<any>, path: string): ODataNavigationPropertyResource<N>;
     key(value: any): ODataNavigationPropertyResource<T>;
     keys(values: any[]): ODataNavigationPropertyResource<T>;
     media(): ODataMediaResource;

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

@@ -1,28 +1,22 @@
 import { Observable } from 'rxjs';
-import { ODataResource } from '../resource';
-import { ODataCollection, ODataModel } from '../../models';
-import { ODataEntities, ODataEntitiesAnnotations, ODataEntity, ODataEntityAnnotations, ODataProperty } from '../responses';
-import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions, ODataPropertyOptions } from './options';
 import { ODataApi } from '../../api';
+import { ODataCollection, ODataModel } from '../../models';
+import { ODataStructuredType } from '../../schema';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
+import { ODataResource } from '../resource';
+import { ODataEntities, ODataEntity, ODataProperty } from '../responses';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions, ODataPropertyOptions } from './options';
 import { ODataValueResource } from './value';
 export declare class ODataPropertyResource<T> extends ODataResource<T> {
-    static factory<P>(api: ODataApi, path: string, type: string | undefined, segments: ODataPathSegments, options: ODataQueryOptions<P>): ODataPropertyResource<P>;
-    clone(): ODataPropertyResource<T>;
-    schema(): import("../../schema").ODataStructuredType<T> | undefined;
-    asModel<M extends ODataModel<T>>(entity: Partial<T> | {
-        [name: string]: any;
-    }, { annots, reset }?: {
-        annots?: ODataEntityAnnotations;
-        reset?: boolean;
-    }): M;
-    asCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(entities: Partial<T>[] | {
-        [name: string]: any;
-    }[], { annots, reset, }?: {
-        annots?: ODataEntitiesAnnotations;
-        reset?: boolean;
-    }): C;
+    static factory<P>(api: ODataApi, { path, type, schema, segments, query, }: {
+        path: string;
+        type?: string;
+        schema?: ODataStructuredType<P>;
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<P>;
+    }): ODataPropertyResource<P>;
+    static fromResource<N>(resource: ODataResource<any>, path: string): ODataPropertyResource<N>;
     key(value: any): ODataPropertyResource<T>;
     keys(values: any[]): ODataPropertyResource<T>;
     value(): ODataValueResource<T>;