angular-odata 0.131.0 → 0.140.0

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

@@ -1,60 +0,0 @@
-import { Parser, ParserOptions, QueryOption } from '../../types';
-import { Expand, Filter, OrderBy, Select, Transform } from './builder';
-import { ComputeExpression, Expression, FilterExpression, OrderByExpression, SearchExpression } from './expressions';
-import { ApplyExpression } from './expressions/apply';
-import { ExpandExpression } from './expressions/expand';
-import { SelectExpression } from './expressions/select';
-import { ODataQueryOptionHandler } from './handlers';
-export type ODataQueryArguments<T> = {
-    [QueryOption.select]?: Select<T> | SelectExpression<T> | null;
-    [QueryOption.expand]?: Expand<T> | ExpandExpression<T> | null;
-    [QueryOption.compute]?: string | ComputeExpression<T> | null;
-    [QueryOption.apply]?: string | ApplyExpression<T> | null;
-    [QueryOption.filter]?: Filter<T> | FilterExpression<T> | null;
-    [QueryOption.search]?: string | SearchExpression<T> | null;
-    [QueryOption.transform]?: Transform<T> | null;
-    [QueryOption.orderBy]?: OrderBy<T> | OrderByExpression<T> | null;
-    [QueryOption.top]?: number | null;
-    [QueryOption.skip]?: number | null;
-    [QueryOption.skiptoken]?: string | null;
-    [QueryOption.format]?: string | null;
-    [QueryOption.levels]?: number | 'max' | null;
-    [QueryOption.count]?: boolean | null;
-};
-export declare const pathAndParamsFromQueryOptions: <T>(values: Map<QueryOption, any>, { escape, parser, options, }?: {
-    escape?: boolean;
-    parser?: Parser<T>;
-    options?: ParserOptions;
-}) => [string, {
-    [name: string]: any;
-}];
-export declare class ODataQueryOptions<T> {
-    private _values;
-    constructor(values?: Map<QueryOption, any>);
-    pathAndParams({ escape, parser, options, }?: {
-        escape?: boolean;
-        parser?: Parser<T>;
-        options?: ParserOptions;
-    }): [string, {
-        [name: string]: any;
-    }];
-    toString({ escape, parser, }?: {
-        escape?: boolean;
-        parser?: Parser<T>;
-    }): string;
-    toJson(): {};
-    fromJson<T>(json: {
-        [name: string]: any;
-    }): this;
-    static fromJson<T>(json: {
-        [name: string]: any;
-    }): ODataQueryOptions<T>;
-    toQueryArguments(): ODataQueryArguments<T>;
-    clone<O>(): ODataQueryOptions<O>;
-    expression(key: QueryOption, exp?: Expression<T>): any;
-    option<O>(key: QueryOption, opts?: O): ODataQueryOptionHandler<O>;
-    has(key: QueryOption): boolean;
-    remove(...keys: QueryOption[]): void;
-    keep(...keys: QueryOption[]): void;
-    clear(): void;
-}

package/lib/resources/request.d.ts

@@ -1,64 +0,0 @@
-import { HttpContext, HttpHeaders, HttpParams } from '@angular/common/http';
-import { ODataApi } from '../api';
-import { FetchPolicy, ParserOptions, QueryOption } from '../types';
-import { ODataResource } from './resource';
-import { ODataOptions } from './types';
-export declare class ODataRequest<T> {
-    readonly api: ODataApi;
-    readonly observe: 'events' | 'response';
-    readonly context?: HttpContext;
-    readonly reportProgress?: boolean;
-    readonly withCredentials?: boolean;
-    readonly bodyQueryOptions: QueryOption[];
-    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;
-    private readonly _params;
-    private readonly _path;
-    constructor(init: {
-        method: string;
-        api: ODataApi;
-        resource: ODataResource<T>;
-        body: any;
-        observe: 'events' | 'response';
-        context?: HttpContext;
-        etag?: string;
-        headers?: HttpHeaders | {
-            [header: string]: string | string[];
-        };
-        reportProgress?: boolean;
-        params?: HttpParams | {
-            [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
-        };
-        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
-        fetchPolicy?: FetchPolicy;
-        parserOptions?: ParserOptions;
-        withCredentials?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    });
-    static factory(api: ODataApi, method: string, resource: ODataResource<any>, options: ODataOptions & {
-        body?: any;
-        etag?: string;
-        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
-        observe: 'events' | 'response';
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    }): ODataRequest<any>;
-    get responseType(): 'arraybuffer' | 'blob' | 'json' | 'text';
-    get path(): string;
-    get method(): string;
-    get body(): any;
-    get params(): HttpParams;
-    get headers(): HttpHeaders;
-    get pathWithParams(): string;
-    get url(): string;
-    get urlWithParams(): string;
-    get cacheKey(): string;
-    isQueryBody(): boolean;
-    isBatch(): boolean;
-    isFetch(): boolean;
-    isMutate(): boolean;
-}

package/lib/resources/resource.d.ts

@@ -1,161 +0,0 @@
-import { Observable } from 'rxjs';
-import { ODataApi } from '../api';
-import { ModelInterface, ODataCollection, ODataModel } from '../models';
-import { ODataStructuredType } from '../schema';
-import { ParserOptions, QueryOption, ODataStructuredTypeFieldConfig } from '../types';
-import { ODataPathSegments, ODataPathSegmentsHandler } from './path';
-import { ODataQueryOptions, ODataQueryOptionsHandler } from './query';
-import { ApplyExpression, ApplyExpressionBuilder, QueryCustomType } from './query';
-import { ODataOptions } from './types';
-import { ODataEntitiesAnnotations, ODataEntityAnnotations } from '../annotations';
-export type EntityKey<T> = {
-    readonly [P in keyof T]?: T[P];
-} | QueryCustomType | string | number;
-export declare class ODataResource<T> {
-    api: ODataApi;
-    protected pathSegments: ODataPathSegments;
-    protected queryOptions: ODataQueryOptions<T>;
-    constructor(api: ODataApi, { segments, query, }?: {
-        segments?: ODataPathSegments;
-        query?: ODataQueryOptions<T>;
-    });
-    /**
-     * @returns string The outgoing type of the resource
-     */
-    outgoingType(): string | undefined;
-    /**
-     * @returns string The incoming type of the resource
-     */
-    incomingType(): string | undefined;
-    /**
-     * @returns string The binding type of the resource
-     */
-    bindingType(): string | undefined;
-    /**
-     * @returns string All covered types of the resource
-     */
-    types(): string[];
-    callable(): import("angular-odata").ODataCallable<any> | undefined;
-    enumType(): import("angular-odata").ODataEnumType<any> | undefined;
-    structuredType(): ODataStructuredType<any> | ODataStructuredType<T> | undefined;
-    /**
-     * @returns boolean The resource has key ?
-     */
-    hasKey(): boolean;
-    hasEntityKey(): boolean;
-    clearKey(): void | undefined;
-    asModel(entity?: Partial<T> | {
-        [name: string]: any;
-    }): ODataModel<T> & ModelInterface<T>;
-    asModel(entity: Partial<T> | {
-        [name: string]: any;
-    }, { reset, annots, ModelType, }: {
-        reset?: boolean;
-        annots?: ODataEntityAnnotations<T>;
-        ModelType?: typeof ODataModel;
-    }): ODataModel<T> & ModelInterface<T>;
-    asModel<M extends ODataModel<T>>(entity?: Partial<T> | {
-        [name: string]: any;
-    }): M;
-    asModel<M extends ODataModel<T>>(entity: Partial<T> | {
-        [name: string]: any;
-    }, { reset, annots, ModelType, }: {
-        reset?: boolean;
-        annots?: ODataEntityAnnotations<T>;
-        ModelType?: typeof ODataModel;
-    }): M;
-    asCollection(entities?: Partial<T>[] | {
-        [name: string]: any;
-    }[]): ODataCollection<T, ODataModel<T> & ModelInterface<T>>;
-    asCollection(entities: Partial<T>[] | {
-        [name: string]: any;
-    }[], { reset, annots, CollectionType, }: {
-        reset?: boolean;
-        annots?: ODataEntitiesAnnotations<T>;
-        CollectionType?: typeof ODataCollection;
-    }): ODataCollection<T, ODataModel<T> & ModelInterface<T>>;
-    asCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(entities?: Partial<T>[] | {
-        [name: string]: any;
-    }[]): C;
-    asCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(entities: Partial<T>[] | {
-        [name: string]: any;
-    }[], { reset, annots, CollectionType, }: {
-        reset?: boolean;
-        annots?: ODataEntitiesAnnotations<T>;
-        CollectionType?: typeof ODataCollection;
-    }): C;
-    isTypeOf(other: ODataResource<any>): boolean;
-    isSubtypeOf(other: ODataResource<any>): boolean;
-    isSupertypeOf(other: ODataResource<any>): boolean;
-    isEqualTo(other: ODataResource<any>, test?: 'path' | 'params'): boolean;
-    pathAndParams({ escape, ...options }?: ParserOptions & {
-        escape?: boolean;
-    }): [string, {
-        [name: string]: any;
-    }];
-    endpointUrl({ escape, params, ...options }?: ParserOptions & {
-        escape?: boolean;
-        params?: boolean;
-    }): string;
-    toString({ escape, ...options }?: ParserOptions & {
-        escape?: boolean;
-    }): string;
-    clone(): ODataResource<T>;
-    private __parser;
-    deserialize(value: any, options?: ParserOptions): any;
-    serialize(value: any, options?: ParserOptions): any;
-    encode(value: any, options?: ParserOptions): any;
-    toJson(): {
-        segments: any[];
-        options: {};
-    };
-    cloneSegments(): ODataPathSegments;
-    clearQuery(): this;
-    cloneQuery<P>(): ODataQueryOptions<P>;
-    /**
-     * 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
-     */
-    segment(f: (q: ODataPathSegmentsHandler<T>, s?: ODataStructuredType<T>) => void): this;
-    /**
-     * 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
-     */
-    query(f: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): this;
-    transform<R>(opts: (builder: ApplyExpressionBuilder<T>, current?: ApplyExpression<T>) => ApplyExpression<T>, { type, fields, }?: {
-        type?: string;
-        fields?: {
-            [name: string]: ODataStructuredTypeFieldConfig;
-        };
-    }): ODataResource<R>;
-    static resolveKey<T>(value: any, schema?: ODataStructuredType<T>): EntityKey<T> | undefined;
-    protected resolveKey(value: any): EntityKey<T> | undefined;
-    protected get(options?: ODataOptions & {
-        etag?: string;
-        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<any>;
-    protected post(body: any, options?: ODataOptions & {
-        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
-        withCount?: boolean;
-    }): Observable<any>;
-    protected put(body: any, options?: ODataOptions & {
-        etag?: string;
-        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
-        withCount?: boolean;
-    }): Observable<any>;
-    protected patch(body: any, options?: ODataOptions & {
-        etag?: string;
-        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
-        withCount?: boolean;
-    }): Observable<any>;
-    protected delete(options?: ODataOptions & {
-        etag?: string;
-        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
-        withCount?: boolean;
-    }): Observable<any>;
-}

package/lib/resources/response.d.ts

@@ -1,82 +0,0 @@
-import { HttpHeaders, HttpResponse } from '@angular/common/http';
-import { ODataEntityAnnotations, ODataEntitiesAnnotations, ODataPropertyAnnotations } from '../annotations';
-import { ODataResource } from './resource';
-import { ODataApi } from '../api';
-import { ODataRequest } from './request';
-import { ODataContext } from '../helper';
-import { ODataResponseOptions } from './options';
-export type ODataEntity<T> = {
-    entity: T | null;
-    annots: ODataEntityAnnotations<T>;
-};
-export type ODataEntities<T> = {
-    entities: T[] | null;
-    annots: ODataEntitiesAnnotations<T>;
-};
-export type ODataProperty<T> = {
-    property: T | null;
-    annots: ODataPropertyAnnotations<T>;
-};
-/**
- * OData Response
- */
-export declare class ODataResponse<T> extends HttpResponse<T> {
-    readonly api: ODataApi;
-    readonly resource: ODataResource<T>;
-    constructor(init: {
-        api: ODataApi;
-        resource: ODataResource<T>;
-        body: T | null;
-        headers: HttpHeaders;
-        status: number;
-        statusText: string;
-        url?: string;
-    });
-    static fromHttpResponse<T>(req: ODataRequest<T>, res: HttpResponse<T>): ODataResponse<T>;
-    static fromJson<T>(req: ODataRequest<T>, json: {
-        body: T | null;
-        headers: {
-            [name: string]: string | string[];
-        };
-        status: number;
-        statusText: string;
-        url: string | null;
-    }): ODataResponse<T>;
-    toJson(): {
-        body: T | null;
-        headers: {
-            [x: string]: string[];
-        };
-        status: number;
-        statusText: string;
-        url: string | null;
-    };
-    private _options?;
-    get options(): ODataResponseOptions;
-    private _payload?;
-    get payload(): any;
-    private _context?;
-    get context(): ODataContext;
-    private _annotations?;
-    get annotations(): Map<string, any>;
-    /**
-     * Handle the response body as an entity
-     * @returns
-     */
-    entity(): ODataEntity<T>;
-    /**
-     * Handle the response body as entities
-     * @returns
-     */
-    entities(): ODataEntities<T>;
-    /**
-     * Handle the response body as a property
-     * @returns
-     */
-    property(): ODataProperty<T>;
-    /**
-     * Handle the response body as a value
-     * @returns
-     */
-    value(): T | null;
-}

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

@@ -1,84 +0,0 @@
-import { Observable } from 'rxjs';
-import { ODataApi } from '../../api';
-import { ODataCollection, ODataModel } from '../../models';
-import { ODataPathSegments } from '../path';
-import { ODataResource } from '../resource';
-import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions, ODataPropertyOptions } from './options';
-import { ODataEntities, ODataEntity, ODataProperty } from '../response';
-export declare class ODataActionResource<P, R> extends ODataResource<R> {
-    static factory<P, R>(api: ODataApi, { path, outgoingType, incomingType, bindingType, segments, }: {
-        path: string;
-        outgoingType?: string;
-        incomingType?: string;
-        bindingType?: string;
-        segments?: ODataPathSegments;
-    }): ODataActionResource<P, R>;
-    static fromResource<P, R>(resource: ODataResource<any>, path: string): ODataActionResource<P, R>;
-    clone(): ODataActionResource<P, R>;
-    protected post(params: P | null, options?: ODataEntityOptions & ODataEntitiesOptions & ODataPropertyOptions): Observable<any>;
-    /**
-     * Execute the action
-     * @param params Parameters to be sent to the action
-     * @param options Options for the request
-     */
-    call(params: P | null, options?: ODataEntityOptions): Observable<ODataEntity<R>>;
-    call(params: P | null, options?: ODataEntitiesOptions): Observable<ODataEntities<R>>;
-    call(params: P | null, options?: ODataPropertyOptions): Observable<ODataProperty<R>>;
-    call(params: P | null, options?: {
-        alias?: boolean;
-        responseType?: 'blob';
-    } & ODataOptions): Observable<Blob>;
-    call(params: P | null, options?: {
-        alias?: boolean;
-        responseType?: 'arraybuffer';
-    } & ODataOptions): Observable<ArrayBuffer>;
-    call(params: P | null, options?: {
-        alias?: boolean;
-        responseType?: 'none';
-    } & ODataOptions): Observable<null>;
-    /**
-     * Execute the action and return the result as a property
-     * @param params Parameters for the action
-     * @param options Options for the request
-     * @returns Observable of the result of the action
-     */
-    callProperty(params: P | null, options?: ODataOptions): Observable<R | null>;
-    /**
-     * Execute the action and return the result as a entity
-     * @param params Parameters for the action
-     * @param options Options for the request
-     * @returns Observable of the result of the action
-     */
-    callEntity(params: P | null, options?: ODataOptions): Observable<R | null>;
-    /**
-     * Execute the action and return the result as a model
-     * @param params Parameters for the action
-     * @param options Options for the request
-     * @returns Observable of the result of the action
-     */
-    callModel(params: P | null, options?: ODataOptions & {
-        ModelType?: typeof ODataModel;
-    }): Observable<(ODataModel<R> & import("angular-odata").ModelInterface<R>) | null>;
-    /**
-     * Execute the action and return the result as a entities
-     * @param params Parameters for the action
-     * @param options Options for the request
-     * @returns Observable of the result of the action
-     */
-    callEntities(params: P | null, options?: ODataOptions): Observable<R[] | null>;
-    /**
-     * Execute the action and return the result as a collection
-     * @param params Parameters for the action
-     * @param options Options for the request
-     * @returns Observable of the result of the action
-     */
-    callCollection(params: P | null, options?: ODataOptions & {
-        CollectionType?: typeof ODataCollection;
-    }): Observable<ODataCollection<R, ODataModel<R> & import("angular-odata").ModelInterface<R>> | null>;
-    callArraybuffer(params: P | null, { alias, ...options }?: {
-        alias?: boolean;
-    } & ODataOptions): Observable<ArrayBuffer>;
-    callBlob(params: P | null, { alias, ...options }?: {
-        alias?: boolean;
-    } & ODataOptions): Observable<Blob>;
-}

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

@@ -1,62 +0,0 @@
-import { HttpErrorResponse, HttpResponseBase } from '@angular/common/http';
-import { Observable } from 'rxjs';
-import { Subject } from 'rxjs';
-import { ODataApi } from '../../api';
-import { ODataRequest } from '../request';
-import { ODataResource } from '../resource';
-import { ODataOptions } from './options';
-import { ODataApiOptions } from '../../options';
-import { ODataResponse } from '../response';
-export declare class ODataBatchRequest<T> extends Subject<HttpResponseBase> {
-    request: ODataRequest<any>;
-    id: string;
-    group: string;
-    constructor(request: ODataRequest<any>);
-    toString(): string;
-    toLegacy({ relativeUrls }?: {
-        relativeUrls?: boolean;
-    }): string;
-    toJson({ relativeUrls }?: {
-        relativeUrls?: boolean;
-    }): {
-        [name: string]: any;
-    };
-    onLoad(response: HttpResponseBase): void;
-    onError(response: HttpErrorResponse): void;
-}
-/**
- * OData Batch Resource
- * https://www.odata.org/getting-started/advanced-tutorial/#batch
- */
-export declare class ODataBatchResource extends ODataResource<any> {
-    private _requests;
-    requests(): ODataRequest<any>[];
-    private _responses;
-    responses(): HttpResponseBase[] | null;
-    static factory(api: ODataApi): ODataBatchResource;
-    clone(): 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) => R): R;
-    send(options?: ODataOptions): Observable<ODataResponse<any>>;
-    private sendJson;
-    private sendLegacy;
-    /**
-     * 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) => R, options?: ODataOptions): Observable<[R, ODataResponse<string>]>;
-    body(): string;
-    json(): Object;
-    static buildLegacyBody(batchBoundary: string, requests: ODataBatchRequest<any>[], options: ODataApiOptions): string;
-    static buildJsonBody(requests: ODataBatchRequest<any>[], options: ODataApiOptions): Object;
-    static parseLegacyResponse(requests: ODataBatchRequest<any>[], response: ODataResponse<string>): HttpResponseBase[];
-    static parseJsonResponse(requests: ODataBatchRequest<any>[], response: ODataResponse<any>): HttpResponseBase[];
-}

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

@@ -1,20 +0,0 @@
-import { Observable } from 'rxjs';
-import { ODataApi } from '../../api';
-import { ODataPathSegments } from '../path';
-import { ODataQueryOptions } from '../query';
-import { ODataResource } from '../resource';
-import { ODataOptions } from './options';
-export declare class ODataCountResource<T> extends ODataResource<T> {
-    static factory<T>(api: ODataApi, { segments, query, }: {
-        segments: ODataPathSegments;
-        query?: ODataQueryOptions<T>;
-    }): ODataCountResource<T>;
-    clone(): ODataCountResource<T>;
-    protected get(options?: ODataOptions): Observable<any>;
-    /**
-     * Fetch the count of the set.
-     * @param options Options for the request
-     * @returns The count of the set
-     */
-    fetch(options?: ODataOptions): Observable<number>;
-}

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

@@ -1,79 +0,0 @@
-import { Observable } from 'rxjs';
-import { ODataApi } from '../../api';
-import type { ModelInterface, ODataCollection, ODataModel } from '../../models';
-import { QueryOption, ODataStructuredTypeFieldConfig } from '../../types';
-import { ApplyExpression, ApplyExpressionBuilder, ODataQueryOptions } from '../query';
-import { ODataResource } from '../resource';
-import { ODataActionResource } from './action';
-import { ODataCountResource } from './count';
-import { ODataEntityResource } from './entity';
-import { ODataFunctionResource } from './function';
-import { ODataOptions } from './options';
-import { ODataEntities, ODataEntity } from '../response';
-export declare class ODataEntitySetResource<T> extends ODataResource<T> {
-    static factory<E>(api: ODataApi, { path, type, query, }: {
-        path: string;
-        type?: string;
-        query?: ODataQueryOptions<E>;
-    }): ODataEntitySetResource<E>;
-    clone(): ODataEntitySetResource<T>;
-    transform<R>(opts: (builder: ApplyExpressionBuilder<T>, current?: ApplyExpression<T>) => ApplyExpression<T>, { type, fields, }?: {
-        type?: string;
-        fields?: {
-            [name: string]: ODataStructuredTypeFieldConfig;
-        };
-    }): ODataEntitySetResource<R>;
-    entity(key?: any): ODataEntityResource<T>;
-    action<P, R>(path: string): ODataActionResource<P, R>;
-    function<P, R>(path: string): ODataFunctionResource<P, R>;
-    count(): ODataCountResource<T>;
-    cast<C>(type: string): ODataEntitySetResource<C>;
-    protected post(attrs: Partial<T>, options?: ODataOptions): Observable<any>;
-    protected get(options?: ODataOptions & {
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<any>;
-    create(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
-    fetch(options?: ODataOptions & {
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<ODataEntities<T>>;
-    fetchAll(options?: ODataOptions & {
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<{
-        entities: any[];
-        annots: import("angular-odata").ODataEntitiesAnnotations<any>;
-    }>;
-    fetchMany(top: number, options?: ODataOptions & {
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<{
-        entities: T[];
-        annots: import("angular-odata").ODataEntitiesAnnotations<T>;
-    } | {
-        entities: T[];
-        annots: import("angular-odata").ODataEntitiesAnnotations<any>;
-    }>;
-    fetchOne(options?: ODataOptions & {
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<{
-        entity: T | null;
-        annots: import("angular-odata").ODataEntitiesAnnotations<T>;
-    }>;
-    fetchEntities(options?: ODataOptions & {
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<T[] | null>;
-    fetchCollection(options?: ODataOptions & {
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-        CollectionType?: typeof ODataCollection;
-    }): Observable<ODataCollection<T, ODataModel<T> & ModelInterface<T>> | null>;
-    fetchCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(options?: ODataOptions & {
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-        CollectionType?: typeof ODataCollection;
-    }): Observable<C | null>;
-}

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

@@ -1,54 +0,0 @@
-import { Observable } from 'rxjs';
-import { ODataApi } from '../../api';
-import { ModelInterface, ODataModel } from '../../models';
-import { QueryOption } from '../../types';
-import { ODataPathSegments } from '../path';
-import { ODataQueryOptions } from '../query';
-import { ODataResource } from '../resource';
-import { ODataEntity } from '../response';
-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';
-export declare class ODataEntityResource<T> extends ODataResource<T> {
-    static factory<E>(api: ODataApi, { segments, query, }: {
-        segments: ODataPathSegments;
-        query?: ODataQueryOptions<E>;
-    }): ODataEntityResource<E>;
-    clone(): ODataEntityResource<T>;
-    key(value: any): ODataEntityResource<T>;
-    keys(values: any[]): ODataEntityResource<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>;
-    protected post(attrs: Partial<T>, options?: ODataOptions): Observable<any>;
-    protected put(attrs: Partial<T>, options?: ODataOptions): Observable<any>;
-    protected patch(attrs: Partial<T>, options?: ODataOptions): Observable<any>;
-    protected delete(options?: ODataOptions): Observable<any>;
-    protected get(options?: ODataOptions & {
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<any>;
-    create(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
-    update(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
-    modify(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
-    destroy(options?: ODataOptions): Observable<any>;
-    fetch(options?: ODataOptions & {
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<ODataEntity<T>>;
-    fetchEntity(options?: ODataOptions & {
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<T | null>;
-    fetchModel(options?: ODataOptions & {
-        bodyQueryOptions?: QueryOption[];
-        ModelType?: typeof ODataModel;
-    }): Observable<(ODataModel<T> & ModelInterface<T>) | null>;
-    fetchModel<M extends ODataModel<T>>(options?: ODataOptions & {
-        bodyQueryOptions?: QueryOption[];
-        ModelType?: typeof ODataModel;
-    }): Observable<M | null>;
-}