angular-odata 0.78.1 → 0.95.0

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

@@ -1,128 +1,143 @@
 import { Observable } from 'rxjs';
-import { ODataModel, ODataCollection } from '../../models';
 import { ODataApi } from '../../api';
-import { EntityKey, ODataResource } from '../resource';
-import { Expand, Select, Transform, Filter, OrderBy } from '../builder';
-import { ODataEntities, ODataEntitiesAnnotations, ODataEntity, ODataEntityAnnotations } from '../responses';
-import { ODataQueryOptions } from '../query-options';
-import { ODataPathSegments } from '../path-segments';
-import { ODataReferenceResource } from './reference';
+import { ODataCollection, ODataModel } from '../../models';
+import { ODataStructuredType } from '../../schema';
+import { QueryOptionNames } from '../../types';
+import { ODataPathSegments } from '../path';
+import { ODataQueryOptions } from '../query';
+import { ODataResource } from '../resource';
+import { ODataEntities, ODataEntity } from '../responses';
 import { ODataCountResource } from './count';
-import { ODataPropertyResource } from './property';
-import { HttpEntityOptions, HttpEntitiesOptions, HttpOptions } from './options';
 import { ODataMediaResource } from './media';
-import { QueryOptionNames } from '../../types';
+import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions } from './options';
+import { ODataPropertyResource } from './property';
+import { ODataReferenceResource } from './reference';
 /**
  * OData Navigation Property Resource
  * https://www.odata.org/getting-started/advanced-tutorial/#containment
  * 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").QueryArguments<T>): void;
-    };
-    get(options: HttpEntityOptions & {
+    protected post(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
+    protected put(attrs: Partial<T>, options?: ODataOptions & {
         etag?: string;
-        bodyQueryOptions?: QueryOptionNames[];
     }): Observable<ODataEntity<T>>;
-    get(options: HttpEntitiesOptions & {
+    protected patch(attrs: Partial<T>, options?: ODataOptions & {
+        etag?: string;
+    }): Observable<ODataEntity<T>>;
+    protected delete(options?: ODataOptions & {
+        etag?: string;
+    }): Observable<any>;
+    protected get(options?: ODataEntityOptions & ODataEntitiesOptions & {
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
-    }): Observable<ODataEntities<T>>;
-    post(attrs: Partial<T>, options?: HttpOptions): Observable<ODataEntity<T>>;
-    put(attrs: Partial<T>, options?: HttpOptions & {
+    }): 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>>;
-    patch(attrs: Partial<T>, options?: HttpOptions & {
+    /**
+     * 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(options?: HttpOptions & {
+    /**
+     * 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(options?: HttpEntityOptions & {
+    /**
+     * 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?: HttpEntitiesOptions & {
+    fetch(options?: ODataEntitiesOptions & {
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<ODataEntities<T>>;
-    fetchEntity(options?: HttpOptions & {
+    /**
+     * Fetch the entity
+     * @param options Options for the request
+     * @returns The entity
+     */
+    fetchEntity(options?: ODataOptions & {
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<T | null>;
-    fetchModel(options?: HttpOptions & {
+    /**
+     * 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<ODataModel<T> | null>;
-    fetchEntities(options?: HttpOptions & {
+    }): Observable<M | null>;
+    /**
+     * Fetch entities
+     * @param options Options for the request
+     * @returns The entities
+     */
+    fetchEntities(options?: ODataOptions & {
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<T[] | null>;
-    fetchCollection(options?: HttpOptions & {
+    /**
+     * 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<ODataCollection<T, ODataModel<T>> | null>;
-    fetchAll(options?: HttpOptions & {
+    }): 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,7 +1,7 @@
 import { HttpHeaders, HttpParams } from '@angular/common/http';
 import { FetchPolicy } from '../../types';
-import { QueryArguments } from '../query-options';
-export declare type HttpOptions = {
+import { ODataQueryArguments } from '../query';
+export declare type ODataOptions = {
     headers?: HttpHeaders | {
         [header: string]: string | string[];
     };
@@ -12,19 +12,19 @@ export declare type HttpOptions = {
     withCredentials?: boolean;
     fetchPolicy?: FetchPolicy;
 };
-export declare type HttpEntityOptions = HttpOptions & {
+export declare type ODataEntityOptions = ODataOptions & {
     responseType?: 'entity';
 };
-export declare type HttpEntitiesOptions = HttpOptions & {
+export declare type ODataEntitiesOptions = ODataOptions & {
     responseType?: 'entities';
     withCount?: boolean;
 };
-export declare type HttpPropertyOptions = HttpOptions & {
+export declare type ODataPropertyOptions = ODataOptions & {
     responseType?: 'property';
 };
-export declare type HttpNoneOptions = HttpOptions & {
+export declare type ODataNoneOptions = ODataOptions & {
     responseType?: 'none';
 };
-export declare type HttpQueryOptions<T> = QueryArguments<T> & {
+export declare type ODataQueryArgumentsOptions<T> = ODataQueryArguments<T> & {
     alias?: boolean;
-} & HttpOptions;
+} & ODataOptions;

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

@@ -1,91 +1,81 @@
 import { Observable } from 'rxjs';
-import { ODataValueResource } from './value';
-import { EntityKey, ODataResource } from '../resource';
-import { ODataQueryOptions } from '../query-options';
-import { ODataPathSegments } from '../path-segments';
-import { HttpPropertyOptions, HttpEntitiesOptions, HttpEntityOptions, HttpOptions } from './options';
-import { ODataProperty, ODataEntities, ODataEntity, ODataEntityAnnotations, ODataEntitiesAnnotations } from '../responses';
-import { ODataModel, ODataCollection } from '../../models';
 import { ODataApi } from '../../api';
-import { Expand, Filter, OrderBy, Select, Transform } from '../builder';
+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): 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").QueryArguments<T>): void;
-    };
-    get(options: HttpEntityOptions): Observable<ODataEntity<T>>;
-    get(options: HttpEntitiesOptions): Observable<ODataEntities<T>>;
-    get(options: HttpPropertyOptions): Observable<ODataProperty<T>>;
-    fetch(options?: HttpEntityOptions & {
+    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?: HttpEntitiesOptions): Observable<ODataEntities<T>>;
-    fetch(options?: HttpPropertyOptions): Observable<ODataProperty<T>>;
-    fetchProperty(options?: HttpOptions & {
+    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>;
-    fetchEntity(options?: HttpOptions & {
+    /**
+     * Fetch the entity
+     * @param options Options for the request
+     * @returns The entity
+     */
+    fetchEntity(options?: ODataOptions & {
         etag?: string;
     }): Observable<T | null>;
-    fetchModel(options?: HttpOptions & {
+    /**
+     * 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<ODataModel<T> | null>;
-    fetchEntities(options?: HttpOptions & {
+    }): Observable<M | null>;
+    /**
+     * Fetch the entities
+     * @param options Options for the request
+     * @returns The entities
+     */
+    fetchEntities(options?: ODataOptions & {
         withCount?: boolean;
     }): Observable<T[] | null>;
-    fetchCollection(options?: HttpOptions & {
+    /**
+     * 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<ODataCollection<T, ODataModel<T>> | null>;
-    fetchAll(options?: HttpOptions): Observable<T[]>;
+    }): 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,28 +1,84 @@
 import { Observable } from 'rxjs';
+import { ODataApi } from '../../api';
+import { QueryOptionNames } from '../../types';
+import { ODataPathSegments } from '../path';
+import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
-import { ODataPathSegments } from '../path-segments';
-import { ODataQueryOptions } from '../query-options';
+import { ODataEntities, ODataEntity } from '../responses/types';
 import { ODataEntityResource } from './entity';
-import { HttpOptions } from './options';
-import { ODataApi } from '../../api';
-export declare class ODataReferenceResource extends ODataResource<any> {
-    static factory<P>(api: ODataApi, segments: ODataPathSegments, options: ODataQueryOptions): ODataReferenceResource;
-    clone(): ODataReferenceResource;
-    schema(): undefined;
-    post(target: ODataEntityResource<any>, options?: HttpOptions): Observable<any>;
-    put(target: ODataEntityResource<any>, options?: HttpOptions & {
+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;
     }): Observable<any>;
-    delete({ etag, target, ...options }?: {
+    protected delete({ etag, target, ...options }?: {
         etag?: string;
         target?: ODataEntityResource<any>;
-    } & HttpOptions): Observable<any>;
-    add(target: ODataEntityResource<any>, options?: HttpOptions): Observable<any>;
-    remove(target?: ODataEntityResource<any>, options?: HttpOptions): Observable<any>;
-    set(target: ODataEntityResource<any>, options?: HttpOptions & {
+    } & 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(options?: HttpOptions & {
+    /**
+     * 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>;
 }