angular-odata 0.131.0 → 0.140.0

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

@@ -1,108 +0,0 @@
-import { Observable } from 'rxjs';
-import { ODataApi } from '../../api';
-import { ODataCollection } from '../../models/collection';
-import { ODataModel } from '../../models/model';
-import { ODataPathSegments } from '../path';
-import { ODataResource } from '../resource';
-import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions, ODataPropertyOptions } from './options';
-import { ODataEntities, ODataEntity, ODataProperty } from '../response';
-export declare class ODataFunctionResource<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;
-    }): ODataFunctionResource<P, R>;
-    static fromResource<P, R>(resource: ODataResource<any>, path: string): ODataFunctionResource<P, R>;
-    clone(): ODataFunctionResource<P, R>;
-    parameters(params: P | null, { alias }?: {
-        alias?: boolean;
-    }): ODataFunctionResource<P, R>;
-    protected get(options?: ODataEntityOptions & ODataEntitiesOptions & ODataPropertyOptions): Observable<any>;
-    /**
-     * 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
-     */
-    call(params: P | null, options?: {
-        alias?: boolean;
-    } & ODataEntityOptions): Observable<ODataEntity<R>>;
-    call(params: P | null, options?: {
-        alias?: boolean;
-    } & ODataEntitiesOptions): Observable<ODataEntities<R>>;
-    call(params: P | null, options?: {
-        alias?: boolean;
-    } & 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 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;
-    } & 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;
-    } & 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(params: P | null, { alias, ModelType, ...options }?: ODataOptions & {
-        alias?: boolean;
-        ModelType?: typeof ODataModel;
-    }): Observable<(ODataModel<R> & import("angular-odata").ModelInterface<R>) | 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;
-    } & 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(params: P | null, { alias, CollectionType, ...options }?: {
-        alias?: boolean;
-        CollectionType?: typeof ODataCollection;
-    } & ODataOptions): 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/index.d.ts

@@ -1,14 +0,0 @@
-export * from './options';
-export * from './action';
-export * from './batch';
-export * from './count';
-export * from './entity';
-export * from './entity-set';
-export * from './function';
-export * from './metadata';
-export * from './navigation-property';
-export * from './property';
-export * from './reference';
-export * from './singleton';
-export * from './media';
-export * from './value';

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

@@ -1,28 +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 ODataMediaResource extends ODataResource<any> {
-    static factory<V>(api: ODataApi, { segments, query, }: {
-        segments: ODataPathSegments;
-        query?: ODataQueryOptions<V>;
-    }): ODataMediaResource;
-    clone(): ODataMediaResource;
-    protected get(options: {
-        responseType: 'arraybuffer' | 'blob';
-    } & ODataOptions): Observable<any>;
-    protected put(data: ArrayBuffer | Blob, options?: ODataOptions): Observable<any>;
-    fetch(options: {
-        responseType: 'arraybuffer';
-    } & ODataOptions): Observable<ArrayBuffer>;
-    fetch(options: {
-        responseType: 'blob';
-    } & ODataOptions): Observable<Blob>;
-    fetchArraybuffer(options?: ODataOptions): Observable<ArrayBuffer>;
-    fetchBlob(options?: ODataOptions): Observable<Blob>;
-    upload(data: ArrayBuffer | Blob, options?: ODataOptions): Observable<any>;
-    uploadArrayBuffer(data: ArrayBuffer, contentType: string, options?: ODataOptions): Observable<any>;
-    uploadBlob(data: Blob, options?: ODataOptions): Observable<any>;
-}

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

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

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

@@ -1,157 +0,0 @@
-import { Observable } from 'rxjs';
-import { ODataApi } from '../../api';
-import type { ModelInterface, ODataCollection, ODataModel } from '../../models';
-import { QueryOption, ODataStructuredTypeFieldConfig } from '../../types';
-import { ODataPathSegments } from '../path';
-import { ApplyExpression, ApplyExpressionBuilder } from '../query';
-import { ODataResource } from '../resource';
-import { ODataEntities, ODataEntity } from '../response';
-import { ODataCountResource } from './count';
-import { ODataMediaResource } from './media';
-import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions } from './options';
-import { ODataPropertyResource } from './property';
-import { ODataReferenceResource } from './reference';
-import { ODataEntitiesAnnotations } from '../../annotations';
-/**
- * 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<N>(api: ODataApi, { path, type, segments, }: {
-        path: string;
-        type?: string;
-        segments: ODataPathSegments;
-    }): ODataNavigationPropertyResource<N>;
-    static fromResource<N>(resource: ODataResource<any>, path: string): ODataNavigationPropertyResource<N>;
-    clone(): ODataNavigationPropertyResource<T>;
-    transform<R>(opts: (builder: ApplyExpressionBuilder<T>, current?: ApplyExpression<T>) => ApplyExpression<T>, { type, fields, }?: {
-        type?: string;
-        fields?: {
-            [name: string]: ODataStructuredTypeFieldConfig;
-        };
-    }): ODataNavigationPropertyResource<R>;
-    key(value: any): ODataNavigationPropertyResource<T>;
-    keys(values: any[]): ODataNavigationPropertyResource<T>;
-    media(): ODataMediaResource;
-    reference(): ODataReferenceResource<T>;
-    navigationProperty<N>(path: string): ODataNavigationPropertyResource<N>;
-    property<P>(path: string): ODataPropertyResource<P>;
-    count(): ODataCountResource<T>;
-    cast<C>(type: string): ODataNavigationPropertyResource<C>;
-    protected post(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
-    protected put(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
-    protected patch(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
-    protected delete(options?: ODataOptions): Observable<any>;
-    protected get(options?: ODataEntityOptions & ODataEntitiesOptions & {
-        bodyQueryOptions?: QueryOption[];
-    }): 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
-     * @returns The updated entity with the annotations
-     */
-    update(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
-    /**
-     * Modify an existing entity
-     * @param attrs The entity attributes
-     * @param options Options for the request
-     * @returns The modified entity with the annotations
-     */
-    modify(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
-    /**
-     * Delete an existing entity
-     * @param options Options for the request
-     * @returns An observable of the destroy
-     */
-    destroy(options?: ODataOptions): Observable<any>;
-    /**
-     * Fetch entity / entities
-     * @param options Options for the request
-     * @return An observable of the entity or entities with annotations
-     */
-    fetch(options?: ODataEntityOptions & {
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<ODataEntity<T>>;
-    fetch(options?: ODataEntitiesOptions & {
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<ODataEntities<T>>;
-    /**
-     * Fetch the entity
-     * @param options Options for the request
-     * @returns The entity
-     */
-    fetchEntity(options?: ODataOptions & {
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<T | null>;
-    /**
-     * Fetch the entity and return as model
-     * @param options Options for the request
-     * @returns The model
-     */
-    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>;
-    /**
-     * Fetch entities
-     * @param options Options for the request
-     * @returns The entities
-     */
-    fetchEntities(options?: ODataOptions & {
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<T[] | null>;
-    /**
-     * Fetch entities and return as collection
-     * @param options Options for the request
-     * @returns The collection
-     */
-    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>;
-    /**
-     * Fetch all entities
-     * @param options Options for the request
-     * @returns All entities
-     */
-    fetchAll(options?: ODataOptions & {
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<{
-        entities: T[];
-        annots: ODataEntitiesAnnotations<T>;
-    }>;
-    fetchMany(top: number, options?: ODataOptions & {
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<{
-        entities: T[];
-        annots: ODataEntitiesAnnotations<T>;
-    }>;
-    fetchOne(options?: ODataOptions & {
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<{
-        entity: T | null;
-        annots: ODataEntitiesAnnotations<T>;
-    }>;
-}

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

@@ -1,32 +0,0 @@
-import { HttpContext, HttpHeaders, HttpParams } from '@angular/common/http';
-import { FetchPolicy, ParserOptions } from '../../types';
-import { ODataQueryArguments } from '../query';
-export type ODataOptions = {
-    etag?: string;
-    context?: HttpContext;
-    headers?: HttpHeaders | {
-        [header: string]: string | string[];
-    };
-    params?: HttpParams | {
-        [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
-    };
-    reportProgress?: boolean;
-    withCredentials?: boolean;
-    fetchPolicy?: FetchPolicy;
-    parserOptions?: ParserOptions;
-};
-export type ODataEntityOptions = ODataOptions & {
-    responseType?: 'entity';
-};
-export type ODataEntitiesOptions = ODataOptions & {
-    responseType?: 'entities';
-    withCount?: boolean;
-};
-export type ODataPropertyOptions = ODataOptions & {
-    responseType?: 'property';
-};
-export type ODataQueryArgumentsOptions<T> = ODataOptions & ODataQueryArguments<T>;
-export type ODataActionOptions<T> = ODataQueryArgumentsOptions<T>;
-export type ODataFunctionOptions<T> = ODataQueryArgumentsOptions<T> & {
-    alias?: boolean;
-};

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

@@ -1,115 +0,0 @@
-import { Observable } from 'rxjs';
-import { ODataApi } from '../../api';
-import type { ModelInterface, ODataCollection, ODataModel } from '../../models';
-import { QueryOption, ODataStructuredTypeFieldConfig } from '../../types';
-import { ODataPathSegments } from '../path';
-import { ApplyExpression, ApplyExpressionBuilder } from '../query';
-import { ODataResource } from '../resource';
-import { ODataEntities, ODataEntity, ODataProperty } from '../response';
-import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions, ODataPropertyOptions } from './options';
-import { ODataValueResource } from './value';
-import { ODataCountResource } from './count';
-import { ODataEntitiesAnnotations } from '../../annotations';
-export declare class ODataPropertyResource<T> extends ODataResource<T> {
-    static factory<P>(api: ODataApi, { path, type, segments, }: {
-        path: string;
-        type?: string;
-        segments: ODataPathSegments;
-    }): ODataPropertyResource<P>;
-    static fromResource<N>(resource: ODataResource<any>, path: string): ODataPropertyResource<N>;
-    clone(): ODataPropertyResource<T>;
-    transform<R>(opts: (builder: ApplyExpressionBuilder<T>, current?: ApplyExpression<T>) => ApplyExpression<T>, { type, fields, }?: {
-        type?: string;
-        fields?: {
-            [name: string]: ODataStructuredTypeFieldConfig;
-        };
-    }): ODataPropertyResource<R>;
-    key(value: any): ODataPropertyResource<T>;
-    keys(values: any[]): ODataPropertyResource<T>;
-    value(): ODataValueResource<T>;
-    count(): ODataCountResource<T>;
-    property<P>(path: string): ODataPropertyResource<P>;
-    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): Observable<ODataEntity<T>>;
-    fetch(options?: ODataEntitiesOptions): Observable<ODataEntities<T>>;
-    fetch(options?: ODataPropertyOptions): Observable<ODataProperty<T>>;
-    /**
-     * Fetch the property value
-     * @param options Options for the request
-     * @returns The property value
-     */
-    fetchProperty(options?: ODataOptions): Observable<T | null>;
-    /**
-     * Fetch the entity
-     * @param options Options for the request
-     * @returns The entity
-     */
-    fetchEntity(options?: ODataOptions): Observable<T | null>;
-    /**
-     * Fetch the entity and return as model
-     * @param options Options for the request
-     * @returns The model
-     */
-    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>;
-    /**
-     * Fetch the entities
-     * @param options Options for the request
-     * @returns The entities
-     */
-    fetchEntities(options?: ODataOptions & {
-        withCount?: boolean;
-    }): Observable<T[] | null>;
-    /**
-     * Fetch the entities and return as collection
-     * @param options Options for the request
-     * @returns The collection
-     */
-    fetchCollection(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>;
-    fetchOne(options?: ODataOptions & {
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<{
-        entity: T | null;
-        annots: ODataEntitiesAnnotations<T>;
-    }>;
-    fetchMany(top: number, options?: ODataOptions & {
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<{
-        entities: T[];
-        annots: ODataEntitiesAnnotations<T>;
-    }>;
-    /**
-     * Fetch all entities
-     * @param options Options for the request
-     * @returns All entities
-     */
-    fetchAll(options?: ODataOptions & {
-        withCount?: boolean;
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<{
-        entities: T[];
-        annots: ODataEntitiesAnnotations<T>;
-    }>;
-}

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

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

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

@@ -1,87 +0,0 @@
-import { Observable } from 'rxjs';
-import { ODataApi } from '../../api';
-import { ModelInterface, ODataModel } from '../../models';
-import { QueryOption } from '../../types';
-import { ODataResource } from '../resource';
-import { ODataEntity } from '../response';
-import { ODataActionResource } from './action';
-import { ODataFunctionResource } from './function';
-import { ODataNavigationPropertyResource } from './navigation-property';
-import { ODataOptions } from './options';
-import { ODataPropertyResource } from './property';
-export declare class ODataSingletonResource<T> extends ODataResource<T> {
-    static factory<S>(api: ODataApi, { path, type, }: {
-        path: string;
-        type?: string;
-    }): ODataSingletonResource<S>;
-    clone(): ODataSingletonResource<T>;
-    key(value: any): ODataSingletonResource<T>;
-    keys(values: any[]): ODataSingletonResource<T>;
-    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>;
-    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>;
-    /**
-     * Creates a new entity.
-     * @param attrs The entity attributes to create.
-     * @param options The options for the request.
-     * @returns The created entity with the annotations.
-     */
-    create(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
-    /**
-     * Updates an existing entity.
-     * @param attrs The entity attributes to update.
-     * @param options The options for the request.
-     * @returns The updated entity with the annotations.
-     */
-    update(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
-    /**
-     * Modifies an existing entity.
-     * @param attrs The entity attributes to modify.
-     * @param options The options for the request.
-     * @returns The modified entity with the annotations.
-     */
-    modify(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
-    /**
-     * Delete an existing entity.
-     * @param options The options for the request.
-     * @returns Observable of the deleted entity.
-     */
-    destroy(options?: ODataOptions): Observable<any>;
-    /**
-     * Fetch an existing entity.
-     * @param options The options for the request.
-     * @returns Observable of the entity with the annotations.
-     */
-    fetch(options?: ODataOptions & {
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<ODataEntity<T>>;
-    /**
-     * Fetch an existing entity.
-     * @param options The options for the request.
-     * @returns Observable of the entity.
-     */
-    fetchEntity(options?: ODataOptions & {
-        bodyQueryOptions?: QueryOption[];
-    }): Observable<T | null>;
-    /**
-     * Fetch an existing entity and return a model.
-     * @param options The options for the request.
-     * @returns Observable of the entity.
-     */
-    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>;
-}

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

@@ -1,19 +0,0 @@
-import { Observable } from 'rxjs';
-import { ODataApi } from '../../api';
-import { ODataPathSegments } from '../path';
-import { ODataResource } from '../resource';
-import { ODataOptions } from './options';
-export declare class ODataValueResource<T> extends ODataResource<T> {
-    static factory<V>(api: ODataApi, { segments, }: {
-        segments: ODataPathSegments;
-    }): ODataValueResource<V>;
-    static fromResource<V>(resource: ODataResource<any>): ODataValueResource<V>;
-    clone(): ODataValueResource<T>;
-    protected get(options?: ODataOptions): Observable<T>;
-    /**
-     * Fetch the value of the resource.
-     * @param options OData options.
-     * @returns Observable of the value.
-     */
-    fetch(options?: ODataOptions): Observable<T>;
-}