angular-odata 0.78.1 → 0.95.0

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

@@ -1,84 +1,46 @@
 import { Observable } from 'rxjs';
-import { Expand, Select, Transform, Filter, OrderBy } from '../builder';
-import { ODataPathSegments } from '../path-segments';
-import { ODataActionResource } from './action';
-import { ODataFunctionResource } from './function';
-import { ODataQueryOptions } from '../query-options';
-import { ODataEntityResource } from './entity';
-import { ODataCountResource } from './count';
-import { EntityKey, ODataResource } from '../resource';
-import { HttpOptions } from './options';
-import { ODataEntity, ODataEntities, ODataEntitiesAnnotations } from '../responses';
-import { ODataModel, ODataCollection } from '../../models';
 import { ODataApi } from '../../api';
+import { ODataCollection, ODataModel } from '../../models';
+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 { ODataCountResource } from './count';
+import { ODataEntityResource } from './entity';
+import { ODataFunctionResource } from './function';
+import { ODataOptions } from './options';
 export declare class ODataEntitySetResource<T> extends ODataResource<T> {
-    static factory<E>(api: ODataApi, path: string, type: string | undefined, segments: ODataPathSegments, query: ODataQueryOptions): 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;
-    select(opts: Select<T>): ODataEntitySetResource<T>;
-    expand(opts: Expand<T>): ODataEntitySetResource<T>;
-    transform(opts: Transform<T>): ODataEntitySetResource<T>;
-    search(opts: string): ODataEntitySetResource<T>;
-    filter(opts: Filter): ODataEntitySetResource<T>;
-    orderBy(opts: OrderBy<T>): ODataEntitySetResource<T>;
-    format(opts: string): ODataEntitySetResource<T>;
-    top(opts: number): ODataEntitySetResource<T>;
-    skip(opts: number): ODataEntitySetResource<T>;
-    skiptoken(opts: string): ODataEntitySetResource<T>;
-    get segment(): {
-        entitySet(): import("../path-segments").SegmentHandler;
-        keys(values?: (EntityKey<T> | 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;
-    };
-    post(attrs: Partial<T>, options?: HttpOptions): Observable<ODataEntity<T>>;
-    get(options?: HttpOptions & {
+    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;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<ODataEntities<T>>;
-    fetch(options?: HttpOptions & {
+    create(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
+    fetch(options?: ODataOptions & {
         withCount?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<ODataEntities<T>>;
-    fetchEntities(options?: HttpOptions & {
+    fetchEntities(options?: ODataOptions & {
         withCount?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<T[] | null>;
-    fetchCollection(options?: HttpOptions & {
+    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 & {
+    fetchAll(options?: ODataOptions & {
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<T[]>;
 }

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

@@ -1,74 +1,66 @@
 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 { ODataFunctionResource } from './function';
+import { ODataMediaResource } from './media';
 import { ODataNavigationPropertyResource } from './navigation-property';
+import { ODataOptions } from './options';
 import { ODataPropertyResource } from './property';
-import { Expand, Select } from '../builder';
-import { ODataQueryOptions } from '../query-options';
-import { ODataPathSegments } from '../path-segments';
-import { EntityKey, ODataResource } from '../resource';
-import { HttpOptions } from './options';
-import { ODataMediaResource } from './media';
-import { ODataEntity, ODataEntityAnnotations } from '../responses';
-import { ODataModel } from '../../models';
-import { ODataApi } from '../../api';
-import { QueryOptionNames } from '../../types';
 export declare class ODataEntityResource<T> extends ODataResource<T> {
-    static factory<E>(api: ODataApi, segments: ODataPathSegments, options: ODataQueryOptions): ODataEntityResource<E>;
-    clone(): ODataEntityResource<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;
+    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<T>;
+    media(): ODataMediaResource;
     navigationProperty<N>(path: string): ODataNavigationPropertyResource<N>;
     property<P>(path: string): ODataPropertyResource<P>;
     action<P, R>(path: string): ODataActionResource<P, R>;
     function<P, R>(path: string): ODataFunctionResource<P, R>;
     cast<C>(type: string): ODataEntityResource<C>;
-    select(opts: Select<T>): ODataEntityResource<T>;
-    expand(opts: Expand<T>): ODataEntityResource<T>;
-    format(opts: string): ODataEntityResource<T>;
-    get segment(): {
-        entitySet(): import("../path-segments").SegmentHandler;
-        keys(values?: (EntityKey<T> | 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>;
-        format(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        apply(query: import("../query-options").QueryArguments<T>): void;
-    };
-    get(options?: HttpOptions & {
+    protected post(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
+    protected put(attrs: Partial<T>, options?: ODataOptions & {
+        etag?: string;
+    }): Observable<ODataEntity<T>>;
+    protected patch(attrs: Partial<T>, options?: ODataOptions & {
+        etag?: string;
+    }): Observable<ODataEntity<T>>;
+    protected delete(options?: ODataOptions & {
+        etag?: string;
+    }): Observable<any>;
+    protected get(options?: ODataOptions & {
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<ODataEntity<T>>;
-    post(attrs: Partial<T>, options?: HttpOptions): Observable<ODataEntity<T>>;
-    put(attrs: Partial<T>, options?: HttpOptions & {
+    create(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
+    update(attrs: Partial<T>, options?: ODataOptions & {
         etag?: string;
     }): Observable<ODataEntity<T>>;
-    patch(attrs: Partial<T>, options?: HttpOptions & {
+    modify(attrs: Partial<T>, options?: ODataOptions & {
         etag?: string;
     }): Observable<ODataEntity<T>>;
-    delete(options?: HttpOptions & {
+    destroy(options?: ODataOptions & {
         etag?: string;
     }): Observable<any>;
-    fetch(options?: HttpOptions & {
+    fetch(options?: ODataOptions & {
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<ODataEntity<T>>;
-    fetchEntity(options?: HttpOptions & {
+    fetchEntity(options?: ODataOptions & {
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
     }): Observable<T | null>;
-    fetchModel(options?: HttpOptions & {
+    fetchModel<M extends ODataModel<T>>(options?: ODataOptions & {
         etag?: string;
         bodyQueryOptions?: QueryOptionNames[];
-    }): Observable<ODataModel<T> | null>;
+    }): Observable<M | null>;
 }

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

@@ -1,100 +1,92 @@
 import { Observable } from 'rxjs';
-import { ODataPathSegments } from '../path-segments';
-import { ODataQueryOptions } from '../query-options';
-import { HttpEntityOptions, HttpEntitiesOptions, HttpPropertyOptions, HttpOptions, HttpNoneOptions } from './options';
-import { ODataEntity, ODataEntities, ODataProperty, ODataEntityAnnotations, ODataEntitiesAnnotations } from '../responses';
 import { ODataApi } from '../../api';
 import { ODataCollection } from '../../models/collection';
 import { ODataModel } from '../../models/model';
-import { Expand, Filter, OrderBy, Select, Transform } from '../builder';
+import { ODataCallable } from '../../schema/callable';
+import { ODataPathSegments } from '../path';
+import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
+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("../../schema").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;
-    };
+    protected get(options?: ODataEntityOptions & ODataEntitiesOptions & ODataPropertyOptions): Observable<any>;
     /**
-     * Handle query options of the function
-     * @returns Handler for mutate the query of the function
+     * Execute the function
+     * @param params Parameters to be sent to the function
+     * @param alias If true, the parameters will be send using aliases
+     * @param options Options for the request
      */
-    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").QueryArguments<R>): void;
-    };
-    get(options?: HttpEntityOptions): Observable<ODataEntity<R>>;
-    get(options?: HttpEntitiesOptions): Observable<ODataEntities<R>>;
-    get(options?: HttpPropertyOptions): Observable<ODataProperty<R>>;
     call(params: P | null, options?: {
         alias?: boolean;
-    } & HttpEntityOptions): Observable<ODataEntity<R>>;
+    } & ODataEntityOptions): Observable<ODataEntity<R>>;
     call(params: P | null, options?: {
         alias?: boolean;
-    } & HttpEntitiesOptions): Observable<ODataEntities<R>>;
+    } & ODataEntitiesOptions): Observable<ODataEntities<R>>;
     call(params: P | null, options?: {
         alias?: boolean;
-    } & HttpPropertyOptions): Observable<ODataProperty<R>>;
+    } & ODataPropertyOptions): Observable<ODataProperty<R>>;
     call(params: P | null, options?: {
         alias?: boolean;
-    } & HttpNoneOptions): Observable<null>;
+    } & ODataNoneOptions): Observable<null>;
+    /**
+     * Execute the function with the given parameters and return the result as a property
+     * @param params Parameters to be sent to the function
+     * @param alias If true, the parameters will be send using aliases
+     * @param options Options for the request
+     * @returns Observable of the result of the function
+     */
     callProperty(params: P | null, { alias, ...options }?: {
         alias?: boolean;
-    } & HttpOptions): Observable<R | null>;
+    } & ODataOptions): Observable<R | null>;
+    /**
+     * Execute the function with the given parameters and return the result as a entity
+     * @param params Parameters to be sent to the function
+     * @param alias If true, the parameters will be send using aliases
+     * @param options Options for the request
+     * @returns Observable of the result of the function
+     */
     callEntity(params: P | null, { alias, ...options }?: {
         alias?: boolean;
-    } & HttpOptions): Observable<R | null>;
-    callModel(params: P | null, { alias, ...options }?: {
+    } & ODataOptions): Observable<R | null>;
+    /**
+     * Execute the function with the given parameters and return the result as a model
+     * @param params Parameters to be sent to the function
+     * @param alias If true, the parameters will be send using aliases
+     * @param options Options for the request
+     * @returns Observable of the result of the function
+     */
+    callModel<M extends ODataModel<R>>(params: P | null, { alias, ...options }?: {
         alias?: boolean;
-    } & HttpOptions): Observable<ODataModel<R> | null>;
+    } & ODataOptions): Observable<M | null>;
+    /**
+     * Execute the function with the given parameters and return the result as a entities
+     * @param params Parameters to be sent to the function
+     * @param alias If true, the parameters will be send using aliases
+     * @param options Options for the request
+     * @returns Observable of the result of the function
+     */
     callEntities(params: P | null, { alias, ...options }?: {
         alias?: boolean;
-    } & HttpOptions): Observable<R[] | null>;
-    callCollection(params: P | null, { alias, ...options }?: {
+    } & ODataOptions): Observable<R[] | null>;
+    /**
+     * Execute the function with the given parameters and return the result as a collection
+     * @param params Parameters to be sent to the function
+     * @param alias If true, the parameters will be send using aliases
+     * @param options Options for the request
+     * @returns Observable of the result of the function
+     */
+    callCollection<M extends ODataModel<R>, C extends ODataCollection<R, M>>(params: P | null, { alias, ...options }?: {
         alias?: boolean;
-    } & HttpOptions): Observable<ODataCollection<R, ODataModel<R>> | null>;
+    } & ODataOptions): Observable<C | null>;
 }

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

@@ -1,37 +1,35 @@
 import { Observable } from 'rxjs';
-import { ODataResource } from '../resource';
-import { ODataPathSegments } from '../path-segments';
-import { ODataQueryOptions } from '../query-options';
-import { HttpOptions } from './options';
 import { ODataApi } from '../../api';
-export declare class ODataMediaResource<T> extends ODataResource<T> {
-    static factory<V>(api: ODataApi, segments: ODataPathSegments, options: ODataQueryOptions): ODataMediaResource<V>;
-    clone(): ODataMediaResource<T>;
-    schema(): undefined;
-    get(options?: {
-        responseType: 'arraybuffer';
-    } & HttpOptions): Observable<ArrayBuffer>;
-    get(options?: {
-        responseType: 'blob';
-    } & HttpOptions): Observable<Blob>;
-    put(data: ArrayBuffer | Blob, options?: HttpOptions & {
+import { ODataPathSegments } from '../path';
+import { ODataQueryOptions } from '../query';
+import { ODataResource } from '../resource';
+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>;
+    protected put(data: ArrayBuffer | Blob, options?: ODataOptions & {
         etag?: string;
     }): Observable<any>;
     fetch(options?: {
         responseType: 'arraybuffer';
-    } & HttpOptions): Observable<ArrayBuffer>;
+    } & ODataOptions): Observable<ArrayBuffer>;
     fetch(options?: {
         responseType: 'blob';
-    } & HttpOptions): Observable<Blob>;
-    fetchArraybuffer(options?: HttpOptions): Observable<ArrayBuffer>;
-    fetchBlob(options?: HttpOptions): Observable<Blob>;
-    upload(data: ArrayBuffer | Blob, options?: HttpOptions & {
+    } & ODataOptions): Observable<Blob>;
+    fetchArraybuffer(options?: ODataOptions): Observable<ArrayBuffer>;
+    fetchBlob(options?: ODataOptions): Observable<Blob>;
+    upload(data: ArrayBuffer | Blob, options?: ODataOptions & {
         etag?: string;
     }): Observable<any>;
-    uploadArrayBuffer(data: ArrayBuffer, contentType: string, options?: HttpOptions & {
+    uploadArrayBuffer(data: ArrayBuffer, contentType: string, options?: ODataOptions & {
         etag?: string;
     }): Observable<any>;
-    uploadBlob(data: Blob, options?: HttpOptions & {
+    uploadBlob(data: Blob, options?: ODataOptions & {
         etag?: string;
     }): Observable<any>;
 }

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

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