angular-odata 0.80.0 → 0.99.0

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

@@ -0,0 +1,104 @@
+import { QueryOptionNames } from '../../types';
+import { Expand, Filter, OrderBy, Select, Transform } from './builder';
+import { ComputeExpression, FilterConnector, FilterExpression, OrderByExpression, SearchConnector, SearchExpression, ODataFunctions, ODataOperators } from './expressions';
+import { ExpandExpression } from './expressions/expand';
+import { SelectExpression } from './expressions/select';
+import type { ODataQueryArguments, ODataQueryOptions } from './options';
+export declare class ODataQueryOptionHandler<T> {
+    private o;
+    private n;
+    constructor(o: {
+        [name: string]: any;
+    }, n: QueryOptionNames);
+    get name(): QueryOptionNames;
+    toJSON(): any;
+    empty(): boolean;
+    value(v?: any): any;
+    private assertArray;
+    push(value: any): void;
+    remove(value: any): void;
+    at(index: number): any;
+    private assertObject;
+    set(path: string, value: any): void;
+    get(path: string, def?: any): any;
+    unset(path: string): void;
+    has(path: string): boolean;
+    assign(values: {
+        [attr: string]: any;
+    }): Object;
+    clear(): void;
+}
+export declare class ODataQueryOptionsHandler<T> {
+    protected options: ODataQueryOptions<T>;
+    constructor(options: ODataQueryOptions<T>);
+    /**
+     * Create a new odata alias parameter
+     * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_ParameterAliases
+     * @param value The value of the alias
+     * @param name The name of the alias
+     * @returns The alias
+     */
+    alias(value: any, name?: string): import("./builder").QueryCustomType;
+    select(opts: (e: {
+        s: T;
+        e: () => SelectExpression<T>;
+    }) => SelectExpression<T>): SelectExpression<T>;
+    select(opts: Select<T>): ODataQueryOptionHandler<T>;
+    select(): ODataQueryOptionHandler<T>;
+    expand(opts: (e: {
+        s: T;
+        e: () => ExpandExpression<T>;
+    }) => ExpandExpression<T>): ExpandExpression<T>;
+    expand(opts: Expand<T>): ODataQueryOptionHandler<T>;
+    expand(): ODataQueryOptionHandler<T>;
+    /**
+     * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptioncompute
+     */
+    compute(opts: (e: {
+        s: T;
+        e: () => ComputeExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => ComputeExpression<T>): ComputeExpression<T>;
+    compute(opts: string): ODataQueryOptionHandler<T>;
+    compute(): ODataQueryOptionHandler<T>;
+    /**
+     * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptionformat
+     */
+    format(opts: string): ODataQueryOptionHandler<T>;
+    format(): ODataQueryOptionHandler<T>;
+    transform(opts: Transform<T>): ODataQueryOptionHandler<T>;
+    transform(): ODataQueryOptionHandler<T>;
+    search(opts: (e: {
+        e: (connector: SearchConnector) => SearchExpression<T>;
+    }) => SearchExpression<T>): SearchExpression<T>;
+    search(opts: string): ODataQueryOptionHandler<T>;
+    search(): ODataQueryOptionHandler<T>;
+    filter(opts: (e: {
+        s: T;
+        e: (connector?: FilterConnector) => FilterExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => FilterExpression<T>): FilterExpression<T>;
+    filter(opts: Filter<T>): ODataQueryOptionHandler<T>;
+    filter(): ODataQueryOptionHandler<T>;
+    orderBy(opts: (e: {
+        s: T;
+        e: () => OrderByExpression<T>;
+    }) => OrderByExpression<T>): OrderByExpression<T>;
+    orderBy(opts: OrderBy<T>): ODataQueryOptionHandler<T>;
+    orderBy(): ODataQueryOptionHandler<T>;
+    top(opts: number): ODataQueryOptionHandler<T>;
+    top(): ODataQueryOptionHandler<T>;
+    skip(opts: number): ODataQueryOptionHandler<T>;
+    skip(): ODataQueryOptionHandler<T>;
+    skiptoken(opts: string): ODataQueryOptionHandler<T>;
+    skiptoken(): ODataQueryOptionHandler<T>;
+    paging({ skip, skiptoken, top, }?: {
+        skip?: number;
+        skiptoken?: string;
+        top?: number;
+    }): void;
+    clearPaging(): void;
+    apply(query: ODataQueryArguments<T>): void;
+}

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

@@ -0,0 +1,3 @@
+export * from './builder';
+export * from './options';
+export * from './handlers';

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

@@ -0,0 +1,38 @@
+import { QueryOptionNames } from '../../types';
+import { Expand, Filter, OrderBy, Select, Transform } from './builder';
+import { Expression } from './expressions';
+import { ODataQueryOptionHandler } from './handlers';
+export declare type ODataQueryArguments<T> = {
+    [QueryOptionNames.select]?: Select<T>;
+    [QueryOptionNames.filter]?: Filter<T>;
+    [QueryOptionNames.search]?: string;
+    [QueryOptionNames.compute]?: string;
+    [QueryOptionNames.transform]?: Transform<T>;
+    [QueryOptionNames.orderBy]?: OrderBy<T>;
+    [QueryOptionNames.top]?: number;
+    [QueryOptionNames.skip]?: number;
+    [QueryOptionNames.skiptoken]?: string;
+    [QueryOptionNames.expand]?: Expand<T>;
+    [QueryOptionNames.format]?: string;
+};
+export declare class ODataQueryOptions<T> {
+    options: {
+        [name: string]: any;
+    };
+    constructor(options?: {
+        [name: string]: any;
+    });
+    pathAndParams(escape?: boolean): [string, {
+        [name: string]: any;
+    }];
+    toString(): string;
+    toJSON(): {};
+    toQueryArguments(): ODataQueryArguments<T>;
+    clone<O>(): ODataQueryOptions<O>;
+    expression(name: QueryOptionNames, exp: Expression<T>): Expression<T>;
+    option<O>(name: QueryOptionNames, opts?: O): ODataQueryOptionHandler<O>;
+    has(name: QueryOptionNames): boolean;
+    remove(...names: QueryOptionNames[]): void;
+    keep(...names: QueryOptionNames[]): void;
+    clear(): void;
+}

package/lib/resources/request.d.ts

@@ -1,16 +1,16 @@
 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';
     readonly reportProgress?: boolean;
     readonly withCredentials?: boolean;
     readonly bodyQueryOptions: QueryOptionNames[];
-    readonly responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
     readonly fetchPolicy: 'cache-first' | 'cache-and-network' | 'network-only' | 'no-cache' | 'cache-only';
     readonly resource: ODataResource<T>;
+    private readonly _responseType?;
     private readonly _method;
     private readonly _body;
     private readonly _headers;
@@ -31,11 +31,12 @@ export declare class ODataRequest<T> {
         params?: HttpParams | {
             [param: string]: string | string[];
         };
-        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
+        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
         fetchPolicy?: 'cache-first' | 'cache-and-network' | 'network-only' | 'no-cache' | 'cache-only';
         withCredentials?: boolean;
         bodyQueryOptions?: QueryOptionNames[];
     });
+    get responseType(): 'arraybuffer' | 'blob' | 'json' | 'text';
     get path(): string;
     get method(): string;
     get body(): any;

package/lib/resources/resource.d.ts

@@ -1,19 +1,26 @@
 import { Observable } from 'rxjs';
-import { ODataPathSegments } from './path-segments';
-import { ODataQueryArguments, ODataQueryOptions } from './query-options';
-import { ODataOptions } from './types';
 import { ODataApi } from '../api';
+import { ODataCollection, ODataModel } from '../models';
+import { ODataStructuredType } from '../schema';
+import { ODataSchemaElement } from '../schema/element';
 import { OptionsHelper, QueryOptionNames } from '../types';
-import { Expand, Filter, OrderBy, Select, Transform, QueryCustomType } from './builder';
-import { ODataStructuredType, ODataCallable } from '../schema/index';
+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;
-    constructor(api: ODataApi, segments?: ODataPathSegments, query?: ODataQueryOptions);
+    protected queryOptions: ODataQueryOptions<T>;
+    constructor(api: ODataApi, { segments, query, schema, }?: {
+        segments?: ODataPathSegments;
+        query?: ODataQueryOptions<T>;
+        schema?: ODataSchemaElement;
+    });
     /**
      * @returns string The type of the resource
      */
@@ -31,64 +38,51 @@ 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(): [string, {
+    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;
     toJSON(): {
         segments: any[];
-        options: any;
+        options: {};
     };
     cloneSegments(): ODataPathSegments;
     clearQuery(): void;
-    cloneQuery(): ODataQueryOptions;
+    cloneQuery<P>(): ODataQueryOptions<P>;
     /**
-     * Factorise an object handler for mutate query options for resources that match to entity
-     * @returns Object handler for mutate query options
+     * Handle the path segments of the resource
+     * Create an object handler for mutate the path segments of the resource
+     * @param f Function context for handle the segments
+     * @returns ODataActionResource
      */
-    protected entityQueryHandler(): {
-        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: ODataQueryArguments<T>): void;
-    };
-    static resolveKey<T>(value: any, schema?: ODataStructuredType<T> | ODataCallable<T>): EntityKey<T> | undefined;
-    protected resolveKey(value: any): EntityKey<T> | undefined;
+    segment(f: (q: ODataPathSegmentsHandler<T>) => void): this;
     /**
-     * Factorise an object handler for mutate query options for resources that match to entities
-     * @returns Object handler for mutate query options
+     * Handle the query options of the resource
+     * Create an object handler for mutate the query options of the resource
+     * @param f Function context for handle the query options
      */
-    protected entitiesQueryHandler(): {
-        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: ODataQueryArguments<T>): void;
-    };
+    query(f: (q: ODataQueryOptionsHandler<T>) => void): this;
+    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;
         etag?: string;

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

@@ -1,68 +1,21 @@
-import { Expand, Filter, OrderBy, Select, Transform } from '../builder';
-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 { ODataPathSegments } from '../path-segments';
-import { ODataQueryOptions } from '../query-options';
+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): 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;
-    select(opts: Select<R>): ODataActionResource<P, R>;
-    expand(opts: Expand<R>): ODataActionResource<P, R>;
-    transform(opts: Transform<R>): ODataActionResource<P, R>;
-    search(opts: string): ODataActionResource<P, R>;
-    filter(opts: Filter): ODataActionResource<P, R>;
-    orderBy(opts: OrderBy<R>): ODataActionResource<P, R>;
-    format(opts: string): ODataActionResource<P, R>;
-    top(opts: number): ODataActionResource<P, R>;
-    skip(opts: number): ODataActionResource<P, R>;
-    skiptoken(opts: string): ODataActionResource<P, R>;
-    get segment(): {
-        entitySet(): import("../path-segments").SegmentHandler;
-        singleton(): import("../path-segments").SegmentHandler;
-        action(): import("../path-segments").SegmentHandler;
-    };
-    /**
-     * Handle query options of the action
-     * @returns Handler for mutate the query of the action
-     */
-    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 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>);
@@ -24,9 +24,22 @@ export declare class ODataBatchRequest<T> extends Subject<ODataResponse<T>> {
 export declare class ODataBatchResource extends ODataResource<any> {
     private _requests;
     requests(): ODataRequest<any>[];
-    clone(): ODataBatchResource;
-    schema(): undefined;
     static factory(api: ODataApi): ODataBatchResource;
+    private storeRequester;
+    private restoreRequester;
+    /**
+     * Add to batch request
+     * @param ctx The context for the request
+     * @returns The result of execute the context
+     */
+    add<R>(ctx: (batch: this) => Observable<R>): Observable<R>;
+    send(options?: ODataOptions): void;
+    /**
+     * Execute the batch request
+     * @param ctx The context for the request
+     * @param options The options of the batch request
+     * @returns The result of execute the context
+     */
     exec<R>(ctx: (batch: this) => Observable<R>, options?: ODataOptions): Observable<R>;
     body(): string;
     static buildBody(batchBoundary: string, requests: ODataBatchRequest<any>[]): string;

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

@@ -1,22 +1,14 @@
-import { Filter } from '../builder';
+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 ODataCountResource extends ODataResource<any> {
-    static factory(api: ODataApi, segments: ODataPathSegments, query: ODataQueryOptions): ODataCountResource;
-    clone(): ODataCountResource;
-    schema(): undefined;
-    get segment(): {
-        entitySet(): import("../path-segments").SegmentHandler;
-        navigationProperty(): import("../path-segments").SegmentHandler;
-    };
-    get query(): {
-        search(opts?: string | undefined): import("../query-options").OptionHandler<string>;
-        filter(opts?: Filter | undefined): import("../query-options").OptionHandler<Filter>;
-    };
+import { ODataOptions } from './options';
+export declare class ODataCountResource<T> extends ODataResource<T> {
+    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,66 +1,27 @@
 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 } 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-segments';
-import { ODataQueryOptions } from '../query-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").ODataQueryArguments<T>): void;
-    };
+    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,50 +1,32 @@
-import { EntityKey, ODataResource } from '../resource';
-import { Expand, Select } from '../builder';
-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-segments';
 import { ODataPropertyResource } from './property';
-import { ODataQueryOptions } from '../query-options';
 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").ODataQueryArguments<T>): void;
-    };
     protected post(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
     protected put(attrs: Partial<T>, options?: ODataOptions & {
         etag?: string;