angular-odata 0.80.0 → 0.99.0

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

@@ -1,72 +1,25 @@
-import { Expand, Filter, OrderBy, Select, Transform } from '../builder';
-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 { ODataPathSegments } from '../path-segments';
-import { ODataQueryOptions } from '../query-options';
+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): 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;
-    clone(): ODataFunctionResource<P, R>;
-    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>;
-    select(opts: Select<R>): ODataFunctionResource<P, R>;
-    expand(opts: Expand<R>): ODataFunctionResource<P, R>;
-    transform(opts: Transform<R>): ODataFunctionResource<P, R>;
-    search(opts: string): ODataFunctionResource<P, R>;
-    filter(opts: Filter): ODataFunctionResource<P, R>;
-    orderBy(opts: OrderBy<R>): ODataFunctionResource<P, R>;
-    format(opts: string): ODataFunctionResource<P, R>;
-    top(opts: number): ODataFunctionResource<P, R>;
-    skip(opts: number): ODataFunctionResource<P, R>;
-    skiptoken(opts: string): ODataFunctionResource<P, R>;
-    get segment(): {
-        entitySet(): import("../path-segments").SegmentHandler;
-        singleton(): import("../path-segments").SegmentHandler;
-        function(): import("../path-segments").SegmentHandler;
-    };
-    /**
-     * Handle query options of the function
-     * @returns Handler for mutate the query of the function
-     */
-    get query(): {
-        select(opts?: Select<R> | undefined): import("../query-options").OptionHandler<Select<R>>;
-        expand(opts?: Expand<R> | undefined): import("../query-options").OptionHandler<Expand<R>>;
-        compute(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        transform(opts?: Transform<R> | undefined): import("../query-options").OptionHandler<Transform<R>>;
-        search(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        filter(opts?: Filter | undefined): import("../query-options").OptionHandler<Filter>;
-        orderBy(opts?: OrderBy<R> | undefined): import("../query-options").OptionHandler<OrderBy<R>>;
-        format(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        top(opts?: number | undefined): import("../query-options").OptionHandler<number>;
-        skip(opts?: number | undefined): import("../query-options").OptionHandler<number>;
-        skiptoken(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        paging({ skip, skiptoken, top, }?: {
-            skip?: number | undefined;
-            skiptoken?: string | undefined;
-            top?: number | undefined;
-        }): void;
-        clearPaging(): void;
-        apply(query: import("../query-options").ODataQueryArguments<R>): void;
-    };
     protected get(options?: ODataEntityOptions & ODataEntitiesOptions & ODataPropertyOptions): Observable<any>;
     /**
      * Execute the function

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-segments';
-import { ODataQueryOptions } from '../query-options';
+import { ODataPathSegments } from '../path';
+import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
-export declare class ODataMediaResource<T> extends ODataResource<T> {
-    static factory<V>(api: ODataApi, segments: ODataPathSegments, options: ODataQueryOptions): ODataMediaResource<V>;
-    clone(): ODataMediaResource<T>;
-    schema(): undefined;
+import { ODataOptions } from './options';
+export declare class ODataMediaResource extends ODataResource<any> {
+    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,13 +1,11 @@
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
+import { ODataPathSegments } from '../path';
+import { ODataResource } from '../resource';
 import { ODataMetadata } from '../responses';
 import { ODataOptions } from './options';
-import { ODataPathSegments } from '../path-segments';
-import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
 export declare class ODataMetadataResource extends ODataResource<any> {
     constructor(api: ODataApi, segments?: ODataPathSegments);
-    clone(): ODataMetadataResource;
-    schema(): undefined;
     static factory(api: ODataApi): ODataMetadataResource;
     protected get(options?: ODataOptions): Observable<ODataMetadata>;
     fetch(options?: ODataOptions): Observable<ODataMetadata>;

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

@@ -1,16 +1,16 @@
 import { Observable } from 'rxjs';
-import { EntityKey, ODataResource } from '../resource';
-import { Expand, Filter, OrderBy, Select, Transform } from '../builder';
+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-segments';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions } from './options';
 import { ODataPropertyResource } from './property';
-import { ODataQueryOptions } from '../query-options';
 import { ODataReferenceResource } from './reference';
 /**
  * OData Navigation Property Resource
@@ -18,69 +18,22 @@ 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): ODataNavigationPropertyResource<E>;
-    clone(): ODataNavigationPropertyResource<T>;
-    schema(): import("angular-odata").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<T>;
-    reference(): ODataReferenceResource;
+    media(): ODataMediaResource;
+    reference(): ODataReferenceResource<T>;
     navigationProperty<N>(path: string): ODataNavigationPropertyResource<N>;
     property<P>(path: string): ODataPropertyResource<P>;
-    count(): ODataCountResource;
+    count(): ODataCountResource<T>;
     cast<C>(type: string): ODataNavigationPropertyResource<C>;
-    select(opts: Select<T>): ODataNavigationPropertyResource<T>;
-    expand(opts: Expand<T>): ODataNavigationPropertyResource<T>;
-    transform(opts: Transform<T>): ODataNavigationPropertyResource<T>;
-    search(opts: string): ODataNavigationPropertyResource<T>;
-    filter(opts: Filter): ODataNavigationPropertyResource<T>;
-    orderBy(opts: OrderBy<T>): ODataNavigationPropertyResource<T>;
-    format(opts: string): ODataNavigationPropertyResource<T>;
-    top(opts: number): ODataNavigationPropertyResource<T>;
-    skip(opts: number): ODataNavigationPropertyResource<T>;
-    skiptoken(opts: string): ODataNavigationPropertyResource<T>;
-    get segment(): {
-        entitySet(): import("../path-segments").SegmentHandler;
-        singleton(): import("../path-segments").SegmentHandler;
-        navigationProperty(): import("../path-segments").SegmentHandler;
-        keys(values?: (EntityKey<T> | undefined)[] | undefined): (EntityKey<any> | undefined)[];
-    };
-    /**
-     * Handle query options of the navigation property
-     * @returns Handler for mutate the query of the navigation property
-     */
-    get query(): {
-        select(opts?: Select<T> | undefined): import("../query-options").OptionHandler<Select<T>>;
-        expand(opts?: Expand<T> | undefined): import("../query-options").OptionHandler<Expand<T>>;
-        compute(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        transform(opts?: Transform<T> | undefined): import("../query-options").OptionHandler<Transform<T>>;
-        search(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        filter(opts?: Filter | undefined): import("../query-options").OptionHandler<Filter>;
-        orderBy(opts?: OrderBy<T> | undefined): import("../query-options").OptionHandler<OrderBy<T>>;
-        format(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        top(opts?: number | undefined): import("../query-options").OptionHandler<number>;
-        skip(opts?: number | undefined): import("../query-options").OptionHandler<number>;
-        skiptoken(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        paging({ skip, skiptoken, top, }?: {
-            skip?: number | undefined;
-            skiptoken?: string | undefined;
-            top?: number | undefined;
-        }): void;
-        clearPaging(): void;
-        apply(query: import("../query-options").ODataQueryArguments<T>): void;
-    };
     protected post(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
     protected put(attrs: Partial<T>, options?: ODataOptions & {
         etag?: string;
@@ -95,16 +48,47 @@ export declare class ODataNavigationPropertyResource<T> extends ODataResource<T>
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<any>;
+    /**
+     * Create a new entity
+     * @param attrs The entity attributes
+     * @param options Options for the request
+     * @returns The created entity with the annotations
+     */
     create(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
+    /**
+     * Update an existing entity
+     * @param attrs The entity attributes
+     * @param options Options for the request
+     * @param etag The etag of the entity
+     * @returns The updated entity with the annotations
+     */
     update(attrs: Partial<T>, options?: ODataOptions & {
         etag?: string;
     }): Observable<ODataEntity<T>>;
+    /**
+     * Modify an existing entity
+     * @param attrs The entity attributes
+     * @param options Options for the request
+     * @param etag The etag of the entity
+     * @returns The modified entity with the annotations
+     */
     modify(attrs: Partial<T>, options?: ODataOptions & {
         etag?: string;
     }): Observable<ODataEntity<T>>;
+    /**
+     * Delete an existing entity
+     * @param options Options for the request
+     * @param etag The etag of the entity
+     * @returns An observable of the destroy
+     */
     destroy(options?: ODataOptions & {
         etag?: string;
     }): Observable<any>;
+    /**
+     * Fetch entity / entities
+     * @param options Options for the request
+     * @return An observable of the entity or entities with annotations
+     */
     fetch(options?: ODataEntityOptions & {
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
@@ -113,21 +97,46 @@ export declare class ODataNavigationPropertyResource<T> extends ODataResource<T>
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<ODataEntities<T>>;
+    /**
+     * Fetch the entity
+     * @param options Options for the request
+     * @returns The entity
+     */
     fetchEntity(options?: ODataOptions & {
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<T | null>;
+    /**
+     * Fetch the entity and return as model
+     * @param options Options for the request
+     * @returns The model
+     */
     fetchModel<M extends ODataModel<T>>(options?: ODataOptions & {
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<M | null>;
+    /**
+     * Fetch entities
+     * @param options Options for the request
+     * @returns The entities
+     */
     fetchEntities(options?: ODataOptions & {
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<T[] | null>;
+    /**
+     * Fetch entities and return as collection
+     * @param options Options for the request
+     * @returns The collection
+     */
     fetchCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(options?: ODataOptions & {
         withCount?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<C | null>;
+    /**
+     * Fetch all entities
+     * @param options Options for the request
+     * @returns All entities
+     */
     fetchAll(options?: ODataOptions & {
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<T[]>;

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

@@ -1,6 +1,6 @@
 import { HttpHeaders, HttpParams } from '@angular/common/http';
 import { FetchPolicy } from '../../types';
-import { ODataQueryArguments } from '../query-options';
+import { ODataQueryArguments } from '../query';
 export declare type ODataOptions = {
     headers?: HttpHeaders | {
         [header: string]: string | string[];

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

@@ -1,89 +1,81 @@
 import { Observable } from 'rxjs';
-import { EntityKey, ODataResource } from '../resource';
-import { Expand, Filter, OrderBy, Select, Transform } from '../builder';
+import { ODataApi } from '../../api';
 import { ODataCollection, ODataModel } from '../../models';
-import { ODataEntities, ODataEntitiesAnnotations, ODataEntity, ODataEntityAnnotations, ODataProperty } from '../responses';
+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 { ODataApi } from '../../api';
-import { ODataPathSegments } from '../path-segments';
-import { ODataQueryOptions } from '../query-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): ODataPropertyResource<P>;
-    clone(): ODataPropertyResource<T>;
-    schema(): import("angular-odata").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>;
     property<P>(path: string): ODataPropertyResource<P>;
-    select(opts: Select<T>): ODataPropertyResource<T>;
-    expand(opts: Expand<T>): ODataPropertyResource<T>;
-    transform(opts: Transform<T>): ODataPropertyResource<T>;
-    search(opts: string): ODataPropertyResource<T>;
-    filter(opts: Filter): ODataPropertyResource<T>;
-    orderBy(opts: OrderBy<T>): ODataPropertyResource<T>;
-    format(opts: string): ODataPropertyResource<T>;
-    top(opts: number): ODataPropertyResource<T>;
-    skip(opts: number): ODataPropertyResource<T>;
-    skiptoken(opts: string): ODataPropertyResource<T>;
-    get segment(): {
-        entitySet(): import("../path-segments").SegmentHandler;
-        singleton(): import("../path-segments").SegmentHandler;
-        property(): import("../path-segments").SegmentHandler;
-        keys(values?: (EntityKey<any> | undefined)[] | undefined): (EntityKey<any> | undefined)[];
-    };
-    get query(): {
-        select(opts?: Select<T> | undefined): import("../query-options").OptionHandler<Select<T>>;
-        expand(opts?: Expand<T> | undefined): import("../query-options").OptionHandler<Expand<T>>;
-        compute(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        transform(opts?: Transform<T> | undefined): import("../query-options").OptionHandler<Transform<T>>;
-        search(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        filter(opts?: Filter | undefined): import("../query-options").OptionHandler<Filter>;
-        orderBy(opts?: OrderBy<T> | undefined): import("../query-options").OptionHandler<OrderBy<T>>;
-        format(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        top(opts?: number | undefined): import("../query-options").OptionHandler<number>;
-        skip(opts?: number | undefined): import("../query-options").OptionHandler<number>;
-        skiptoken(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        paging({ skip, skiptoken, top, }?: {
-            skip?: number | undefined;
-            skiptoken?: string | undefined;
-            top?: number | undefined;
-        }): void;
-        clearPaging(): void;
-        apply(query: import("../query-options").ODataQueryArguments<T>): void;
-    };
     protected get(options: ODataEntityOptions & ODataEntitiesOptions & ODataPropertyOptions): Observable<any>;
+    /**
+     * Fetch the property
+     * @param options Options for the request
+     * @return The entity / entities / property value
+     */
     fetch(options?: ODataEntityOptions & {
         etag?: string;
     }): Observable<ODataEntity<T>>;
     fetch(options?: ODataEntitiesOptions): Observable<ODataEntities<T>>;
     fetch(options?: ODataPropertyOptions): Observable<ODataProperty<T>>;
+    /**
+     * Fetch the property value
+     * @param options Options for the request
+     * @returns The property value
+     */
     fetchProperty(options?: ODataOptions & {
         etag?: string;
     }): Observable<T | null>;
+    /**
+     * Fetch the entity
+     * @param options Options for the request
+     * @returns The entity
+     */
     fetchEntity(options?: ODataOptions & {
         etag?: string;
     }): Observable<T | null>;
+    /**
+     * Fetch the entity and return as model
+     * @param options Options for the request
+     * @returns The model
+     */
     fetchModel<M extends ODataModel<T>>(options?: ODataOptions & {
         etag?: string;
     }): Observable<M | null>;
+    /**
+     * Fetch the entities
+     * @param options Options for the request
+     * @returns The entities
+     */
     fetchEntities(options?: ODataOptions & {
         withCount?: boolean;
     }): Observable<T[] | null>;
+    /**
+     * Fetch the entities and return as collection
+     * @param options Options for the request
+     * @returns The collection
+     */
     fetchCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(options?: ODataOptions & {
         withCount?: boolean;
     }): Observable<C | null>;
+    /**
+     * Fetch all entities
+     * @param options Options for the request
+     * @returns All entities
+     */
     fetchAll(options?: ODataOptions): Observable<T[]>;
 }

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

@@ -1,14 +1,17 @@
+import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataEntityResource } from './entity';
-import { ODataOptions } from './options';
-import { ODataPathSegments } from '../path-segments';
-import { ODataQueryOptions } from '../query-options';
+import { QueryOptionNames } from '../../types';
+import { ODataPathSegments } from '../path';
+import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
-import { Observable } from 'rxjs';
-export declare class ODataReferenceResource extends ODataResource<any> {
-    static factory<P>(api: ODataApi, segments: ODataPathSegments, options: ODataQueryOptions): ODataReferenceResource;
-    clone(): ODataReferenceResource;
-    schema(): undefined;
+import { ODataEntities, ODataEntity } from '../responses/types';
+import { ODataEntityResource } from './entity';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions } from './options';
+export declare class ODataReferenceResource<T> extends ODataResource<T> {
+    static factory<P>(api: ODataApi, { segments, query, }: {
+        segments: ODataPathSegments;
+        query?: ODataQueryOptions<P>;
+    }): ODataReferenceResource<P>;
     protected post(target: ODataEntityResource<any>, options?: ODataOptions): Observable<any>;
     protected put(target: ODataEntityResource<any>, options?: ODataOptions & {
         etag?: string;
@@ -17,12 +20,65 @@ export declare class ODataReferenceResource extends ODataResource<any> {
         etag?: string;
         target?: ODataEntityResource<any>;
     } & ODataOptions): Observable<any>;
+    /**
+     * Add the given target to the collection.
+     * @param target The target resource
+     * @param options Options for the request
+     * @returns Observable of the response
+     */
     add(target: ODataEntityResource<any>, options?: ODataOptions): Observable<any>;
+    /**
+     * Remove the given target from the collection.
+     * @param target The target resource
+     * @param options Options for the request
+     * @returns Observable of the response
+     */
     remove(target?: ODataEntityResource<any>, options?: ODataOptions): Observable<any>;
+    /**
+     * Set the reference to the given target.
+     * @param target The target resource
+     * @param options Options for the request
+     * @returns Observable of the response
+     */
     set(target: ODataEntityResource<any>, options?: ODataOptions & {
         etag?: string;
     }): Observable<any>;
+    /**
+     * Unset the reference to the given target.
+     * @param options Options for the request.
+     * @returns Observable of the response
+     */
     unset(options?: ODataOptions & {
         etag?: string;
     }): Observable<any>;
+    /**
+     * Fetch entity / entities
+     * @param options Options for the request
+     * @return An observable of the entity or entities with annotations
+     */
+    fetch(options?: ODataEntityOptions & {
+        etag?: string;
+        bodyQueryOptions?: QueryOptionNames[];
+    }): Observable<ODataEntity<T>>;
+    fetch(options?: ODataEntitiesOptions & {
+        etag?: string;
+        bodyQueryOptions?: QueryOptionNames[];
+    }): Observable<ODataEntities<T>>;
+    /**
+     * Fetch the entity
+     * @param options Options for the request
+     * @returns The entity
+     */
+    fetchEntity(options?: ODataOptions & {
+        etag?: string;
+        bodyQueryOptions?: QueryOptionNames[];
+    }): Observable<T | null>;
+    /**
+     * Fetch entities
+     * @param options Options for the request
+     * @returns The entities
+     */
+    fetchEntities(options?: ODataOptions & {
+        bodyQueryOptions?: QueryOptionNames[];
+    }): Observable<T[] | null>;
 }