angular-odata 0.128.0 → 0.131.0

package/lib/metadata/csdl/csdl-structured-type.d.ts

@@ -1,4 +1,4 @@
-import { StructuredTypeConfig } from '../../types';
+import { ODataStructuredTypeConfig } from '../../types';
 import { CsdlAnnotable } from './csdl-annotation';
 import { CsdlProperty, CsdlNavigationProperty } from './csdl-structural-property';
 import type { CsdlSchema } from './csdl-schema';
@@ -19,6 +19,11 @@ export declare class CsdlStructuredType extends CsdlAnnotable {
         Abstract?: boolean;
         Annotation?: any[];
     });
+    toJson(): {
+        [key: string]: any;
+    };
+    name(): string;
+    namespace(): string;
     fullName(): string;
 }
 export declare class CsdlComplexType extends CsdlStructuredType {
@@ -31,7 +36,10 @@ export declare class CsdlComplexType extends CsdlStructuredType {
         Abstract?: boolean;
         Annotation?: any[];
     });
-    toConfig(): StructuredTypeConfig<any>;
+    toJson(): {
+        [x: string]: any;
+    };
+    toConfig(base?: Partial<ODataStructuredTypeConfig>): ODataStructuredTypeConfig;
 }
 export declare class CsdlEntityType extends CsdlStructuredType {
     Key?: CsdlKey;
@@ -47,16 +55,25 @@ export declare class CsdlEntityType extends CsdlStructuredType {
         HasStream?: boolean;
         Annotation?: any[];
     });
-    toConfig(): StructuredTypeConfig<any>;
+    toJson(): {
+        [key: string]: any;
+    };
+    toConfig(base?: Partial<ODataStructuredTypeConfig>): ODataStructuredTypeConfig;
 }
 export declare class CsdlKey {
-    PropertyRefs: CsdlPropertyRef[];
-    constructor({ PropertyRefs }: {
-        PropertyRefs: any[];
+    PropertyRef: CsdlPropertyRef[];
+    constructor({ PropertyRef }: {
+        PropertyRef: any[];
     });
+    toJson(): {
+        PropertyRef: {
+            Name: string;
+            Alias: string | undefined;
+        }[];
+    };
     toConfig(): {
         name: string;
-        alias?: string | undefined;
+        alias?: string;
     }[];
 }
 export declare class CsdlPropertyRef {
@@ -66,6 +83,10 @@ export declare class CsdlPropertyRef {
         Name: string;
         Alias?: string;
     });
+    toJson(): {
+        Name: string;
+        Alias: string | undefined;
+    };
     toConfig(): {
         name: string;
         alias?: string;

package/lib/metadata/csdl/csdl-type-definition.d.ts

@@ -19,4 +19,7 @@ export declare class CsdlTypeDefinition extends CsdlAnnotable {
         SRID?: string;
         Annotation?: CsdlAnnotation[];
     });
+    toJson(): {
+        [key: string]: any;
+    };
 }

package/lib/metadata/metadata.d.ts

@@ -1,10 +1,23 @@
+import { CsdlAction, CsdlFunction } from './csdl/csdl-function-action';
 import { CsdlReference } from './csdl/csdl-reference';
 import { CsdlSchema } from './csdl/csdl-schema';
-import { ApiConfig } from '../types';
+import { ODataApiConfig } from '../types';
 export declare class ODataMetadata {
     Version: string;
     References: CsdlReference[];
     Schemas: CsdlSchema[];
-    constructor(Version: string, References: CsdlReference[], Schemas: CsdlSchema[]);
-    toConfig(base?: ApiConfig): ApiConfig;
+    constructor(Version: string, References: any[], Schemas: any[]);
+    toConfig(base?: Partial<ODataApiConfig>): ODataApiConfig;
+    toJson(): {
+        Version: string;
+        References: {
+            [key: string]: any;
+        }[];
+        Schemas: {
+            [key: string]: any;
+        }[];
+    };
+    functions(): CsdlFunction[];
+    actions(): CsdlAction[];
+    static fromJson(json: any): ODataMetadata;
 }

package/lib/models/collection.d.ts

@@ -152,7 +152,7 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     private _findEntry;
     equals(other: ODataCollection<T, ODataModel<T>>): boolean;
     get [Symbol.toStringTag](): string;
-    [Symbol.iterator](): Iterator<M, any, undefined>;
+    [Symbol.iterator](): Iterator<M>;
     filter(predicate: (value: M, index: number, array: M[]) => unknown, thisArg?: any): M[];
     map<U>(callbackfn: (value: M, index: number, array: M[]) => U, thisArg?: any): U[];
     find(predicate: (value: M, index: number, obj: M[]) => unknown): M | undefined;
@@ -176,6 +176,7 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
     sort(by: {
         field: string | keyof T;
         order?: 1 | -1;
+        comparator?: (a: any, b: any) => number;
     }[], { silent }?: {
         silent?: boolean;
     }): void;

package/lib/models/model.d.ts

@@ -2,7 +2,7 @@ import { Observable } from 'rxjs';
 import { EntityKey, ODataActionOptions, ODataEntityResource, ODataFunctionOptions, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryArgumentsOptions, ODataQueryOptionsHandler, ODataResource, ODataSingletonResource } from '../resources';
 import { ODataStructuredType } from '../schema';
 import { ODataCollection } from './collection';
-import { ModelOptions, ODataModelField, ODataModelOptions, ODataModelAttribute, ODataModelEventEmitter } from './options';
+import { ModelOptions, ODataModelField, ODataModelOptions, ODataModelAttribute, ODataModelEventEmitter, ModelInterface } from './options';
 import { EdmType, ParserOptions } from '../types';
 import { ODataEntityAnnotations } from '../annotations';
 export declare class ODataModel<T> {
@@ -161,11 +161,12 @@ export declare class ODataModel<T> {
     asEntity<R>(ctx: (model: this) => R): R;
     callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none' | 'blob' | 'arraybuffer', options?: ODataFunctionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null | Blob | ArrayBuffer>;
     callAction<P, R>(name: string, params: P | null, responseType?: 'property' | 'model' | 'collection' | 'none' | 'blob' | 'arraybuffer', { ...options }?: {} & ODataActionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null | Blob | ArrayBuffer>;
-    cast<S>(type: string, ModelType?: typeof ODataModel): ODataModel<S>;
+    cast<S>(type: string, ModelType?: typeof ODataModel): ODataModel<T> & ModelInterface<T>;
+    cast<S, M extends ODataModel<S>>(type: string, ModelType?: typeof ODataModel): M;
     fetchNavigationProperty<S>(name: keyof T | string, responseType: 'model' | 'collection', options?: ODataQueryArgumentsOptions<S>): Observable<ODataModel<S> | ODataCollection<S, ODataModel<S>> | null>;
-    fetchAttribute<P>(name: keyof T | string, options?: ODataQueryArgumentsOptions<P>): Observable<P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null>;
-    getAttribute<P>(name: keyof T | string): P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null | undefined;
-    setAttribute<N>(name: keyof T | string, model: ODataModel<N> | ODataCollection<N, ODataModel<N>> | null, options?: ODataOptions): Observable<this>;
+    fetchAttribute<P>(name: keyof T, options?: ODataQueryArgumentsOptions<P>): Observable<P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null>;
+    getAttribute<P>(name: keyof T | string): P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null;
+    setAttribute<N>(name: keyof T, model: ODataModel<N> | ODataCollection<N, ODataModel<N>> | null, options?: ODataOptions): Observable<this>;
     setReference<N>(name: keyof T | string, model: ODataModel<N> | ODataCollection<N, ODataModel<N>> | null, options?: ODataOptions): Observable<this>;
     get [Symbol.toStringTag](): string;
     equals(other: ODataModel<T>): boolean;

package/lib/models/options.d.ts

@@ -87,8 +87,12 @@ export declare const INCLUDE_DEEP: {
 export declare enum ODataModelState {
     Added = 0,
     Removed = 1,
-    Unchanged = 2
+    Changed = 2,
+    Unchanged = 3
 }
+export type ModelInterface<T> = {
+    [P in keyof T]: T[P] extends (infer U)[] ? ODataCollection<U, ODataModel<U> & ModelInterface<U>> : T[P] extends object ? ODataModel<T[P]> & ModelInterface<T[P]> : T[P];
+};
 export type ModelOptions = {
     cid?: string;
     fields: Map<string, ModelFieldOptions>;
@@ -107,7 +111,9 @@ export type ModelFieldOptions = {
 };
 export declare function Model({ cid }?: {
     cid?: string;
-}): <T extends new (...args: any[]) => {}>(constructor: T) => T;
+}): <T extends {
+    new (...args: any[]): {};
+}>(constructor: T) => T;
 export declare function ModelField({ name, ...options }?: {
     name?: string;
 } & ModelFieldOptions): (target: any, key: string) => void;
@@ -151,7 +157,7 @@ export declare class ODataModelField<F> {
     }): void;
     isKey(): boolean;
     hasReferentials(): boolean;
-    get referentials(): import("../schema").ODataReferential[];
+    get referentials(): import("angular-odata").ODataReferential[];
     isStructuredType(): boolean;
     structuredType(): ODataStructuredType<F>;
     isEnumType(): boolean;
@@ -184,6 +190,7 @@ export declare class ODataModelField<F> {
 export declare class ODataModelAttribute<T> {
     private _model;
     private _field;
+    private state;
     private value?;
     private change?;
     private subscription?;
@@ -193,7 +200,7 @@ export declare class ODataModelAttribute<T> {
     get navigation(): boolean;
     get computed(): boolean | undefined;
     get concurrency(): boolean;
-    get referentials(): import("../schema").ODataReferential[];
+    get referentials(): import("angular-odata").ODataReferential[];
     get options(): ODataModelOptions<any>;
     get name(): string;
     get fieldName(): string;

package/lib/module.d.ts

@@ -1,14 +1,14 @@
 import { EnvironmentProviders, InjectionToken, ModuleWithProviders, Provider } from '@angular/core';
 import { ODataConfigSyncLoader } from './loaders';
-import { ApiConfig } from './types';
+import { ODataApiConfig } from './types';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
 import * as i2 from "@angular/common/http";
 export interface PassedInitialConfig {
-    config?: ApiConfig | ApiConfig[];
+    config?: ODataApiConfig | ODataApiConfig[];
     loader?: Provider;
 }
-export declare const ODATA_CONFIG: InjectionToken<ApiConfig>;
+export declare const ODATA_CONFIG: InjectionToken<ODataApiConfig>;
 export declare function createSyncLoader(passedConfig: PassedInitialConfig): ODataConfigSyncLoader;
 export declare function provideODataClient(passedConfig: PassedInitialConfig): EnvironmentProviders;
 export declare class ODataModule {

package/lib/options.d.ts

@@ -1,5 +1,5 @@
-import { ApiOptions, FetchPolicy, ODataMetadataType, ODataVersion, ParserOptions, QueryOption } from './types';
-export declare class ODataApiOptions implements ApiOptions {
+import { ODataApiConfigOptions, FetchPolicy, ODataMetadataType, ODataVersion, ParserOptions, QueryOption } from './types';
+export declare class ODataApiOptions implements ODataApiConfigOptions {
     /**
      * Default OData version
      */
@@ -95,7 +95,7 @@ export declare class ODataApiOptions implements ApiOptions {
          */
         omitNullValues?: boolean;
     };
-    constructor(config: ApiOptions);
+    constructor(config: ODataApiConfigOptions);
     get parserOptions(): ParserOptions;
     get helper(): import("./helper").ODataVersionHelper;
 }

package/lib/resources/path/segments.d.ts

@@ -11,9 +11,9 @@ export type ODataSegment = {
     parameters?: any;
 };
 export declare const pathAndParamsFromSegments: (segments: ODataSegment[], { escape, parser, options, }?: {
-    escape?: boolean | undefined;
-    parser?: Parser<any> | undefined;
-    options?: ParserOptions | undefined;
+    escape?: boolean;
+    parser?: Parser<any>;
+    options?: ParserOptions;
 }) => [string, {
     [name: string]: any;
 }];

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

@@ -75,6 +75,7 @@ export type QueryOptions<T> = ExpandOptions<T> & {
     } | {
         [name: string]: any;
     }[];
+    compute: string;
     skip: number;
     skiptoken: string;
     key: string | number | {
@@ -92,8 +93,8 @@ export type QueryOptions<T> = ExpandOptions<T> & {
     escape: boolean;
 };
 export declare const ITEM_ROOT = "";
-export default function <T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): string;
-export declare function buildPathAndQuery<T>({ select, search, skiptoken, format, top, skip, filter, apply, transform, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): [string, {
+export default function <T>({ select, search, skiptoken, format, top, skip, filter, transform, compute, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): string;
+export declare function buildPathAndQuery<T>({ select, search, skiptoken, format, top, skip, filter, apply, transform, compute, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): [string, {
     [name: string]: any;
 }];
 export declare function normalizeValue(value: Value, { aliases, escape, }?: {

package/lib/resources/query/expressions/apply.d.ts

@@ -49,7 +49,7 @@ export declare class ApplyExpression<T> extends Expression<T> {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: ApplyExpressionBuilder<T>, current?: ApplyExpression<T>) => ApplyExpression<T>, current?: ApplyExpression<T>): ApplyExpression<T>;
+    static factory<T>(opts: (builder: ApplyExpressionBuilder<T>, current: ApplyExpression<T>) => ApplyExpression<T>, current?: ApplyExpression<T>): ApplyExpression<T>;
     toJson(): {
         $type: string;
         children: any[];

package/lib/resources/query/expressions/compute.d.ts

@@ -13,7 +13,7 @@ export declare class ComputeExpression<T> extends Expression<T> {
         names?: string[];
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: ComputeExpressionBuilder<T>, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
+    static factory<T>(opts: (builder: ComputeExpressionBuilder<T>, current: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
     toJson(): {
         $type: string;
         children: any[];

package/lib/resources/query/expressions/count.d.ts

@@ -34,7 +34,7 @@ export declare class CountExpression<T> extends Expression<T> {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: CountExpressionBuilder<T>, current?: CountExpression<T>) => CountExpression<T>, current?: CountExpression<T>): CountExpression<T>;
+    static factory<T>(opts: (builder: CountExpressionBuilder<T>, current: CountExpression<T>) => CountExpression<T>, current?: CountExpression<T>): CountExpression<T>;
     private _add;
     toJson(): {
         $type: string;

package/lib/resources/query/expressions/expand.d.ts

@@ -1,6 +1,7 @@
 import { Parser, ParserOptions } from '../../../types';
 import { QueryCustomType, Unpacked } from '../builder';
 import { Expression } from './base';
+import { ComputeExpression, ComputeExpressionBuilder } from './compute';
 import { FilterExpression, FilterExpressionBuilder } from './filter';
 import { OrderByExpression, OrderByExpressionBuilder } from './orderby';
 import { SearchExpression, SearchExpressionBuilder } from './search';
@@ -29,7 +30,8 @@ export declare class ExpandField<T> implements Renderable {
     expand(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>): ExpandExpression<T>;
     filter(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
     search(opts: (builder: SearchExpressionBuilder<T>) => SearchExpression<T>): SearchExpression<T>;
-    orderBy(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
+    orderBy(opts: (builder: OrderByExpressionBuilder<T>, current: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
+    compute(opts: (builder: ComputeExpressionBuilder<T>, current: ComputeExpression<T>) => ComputeExpression<T>): ComputeExpression<T>;
     skip(n: number): number;
     top(n: number): number;
     levels(n: number | 'max'): number | "max";
@@ -45,7 +47,7 @@ export declare class ExpandExpression<T> extends Expression<T> {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
+    static factory<T>(opts: (builder: ExpandExpressionBuilder<T>, current: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
     toJson(): {
         $type: string;
         children: any[];
@@ -63,4 +65,5 @@ export declare class ExpandExpression<T> extends Expression<T> {
     clone(): ExpandExpression<T>;
     private _add;
     field<F>(field: F, opts?: (e: ExpandField<Unpacked<F>>) => void): ExpandExpression<T>;
+    combine(expression: ExpandExpression<T>): ExpandExpression<T>;
 }

package/lib/resources/query/expressions/filter.d.ts

@@ -19,7 +19,7 @@ export declare class FilterExpression<F> extends Expression<F> {
         negated?: boolean;
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
+    static factory<T>(opts: (builder: FilterExpressionBuilder<T>, current: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
     toJson(): {
         $type: string;
         children: any[];
@@ -73,4 +73,5 @@ export declare class FilterExpression<F> extends Expression<F> {
     }) => CountExpression<N>): FilterExpression<F>;
     isof(type: string): FilterExpression<F>;
     isof(left: F, type: string): FilterExpression<F>;
+    combine(exp: FilterExpression<F>, connector?: FilterConnector): FilterExpression<F>;
 }

package/lib/resources/query/expressions/orderby.d.ts

@@ -32,7 +32,7 @@ export declare class OrderByExpression<T> extends Expression<T> {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
+    static factory<T>(opts: (builder: OrderByExpressionBuilder<T>, current: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
     private _add;
     toJson(): {
         $type: string;
@@ -51,4 +51,5 @@ export declare class OrderByExpression<T> extends Expression<T> {
     clone(): OrderByExpression<T>;
     ascending(field: any): OrderByExpression<T>;
     descending(field: any): OrderByExpression<T>;
+    combine(expression: OrderByExpression<T>): OrderByExpression<T>;
 }

package/lib/resources/query/expressions/search.d.ts

@@ -33,7 +33,7 @@ export declare class SearchExpression<T> extends Expression<T> {
         negated?: boolean;
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: SearchExpressionBuilder<T>, current?: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
+    static factory<T>(opts: (builder: SearchExpressionBuilder<T>, current: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
     private _add;
     render({ aliases, escape, prefix, parser, options, }?: {
         aliases?: QueryCustomType[];
@@ -59,4 +59,5 @@ export declare class SearchExpression<T> extends Expression<T> {
     and(exp: SearchExpression<T>): SearchExpression<T>;
     not(exp: SearchExpression<T>): SearchExpression<T>;
     term(value: any): SearchExpression<T>;
+    combine(expression: SearchExpression<T>, connector?: SearchConnector): SearchExpression<T>;
 }

package/lib/resources/query/expressions/select.d.ts

@@ -11,7 +11,7 @@ export declare class SelectExpression<T> extends Expression<T> {
         children?: Renderable[];
     });
     get [Symbol.toStringTag](): string;
-    static factory<T>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
+    static factory<T>(opts: (builder: SelectExpressionBuilder<T>, current: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
     toJson(): {
         $type: string;
         children: any[];
@@ -30,4 +30,5 @@ export declare class SelectExpression<T> extends Expression<T> {
     private _add;
     field(field: any): SelectExpression<T>;
     fields(...fields: any[]): SelectExpression<T>;
+    combine(expression: SelectExpression<T>): SelectExpression<T>;
 }

package/lib/resources/query/expressions/syntax.d.ts

@@ -240,8 +240,8 @@ export declare class Transformations<T> {
 export declare class Type<T> implements Renderable {
     protected name: string;
     protected type: string;
-    protected value?: any;
-    constructor(name: string, type: string, value?: any);
+    protected value?: any | undefined;
+    constructor(name: string, type: string, value?: any | undefined);
     get [Symbol.toStringTag](): string;
     toJson(): {
         $type: string;

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

@@ -1,4 +1,4 @@
-import { Parser, QueryOption } from '../../types';
+import { Parser, ParserOptions, QueryOption } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
 import { ComputeExpression, ComputeExpressionBuilder, FilterExpression, FilterExpressionBuilder, OrderByExpression, OrderByExpressionBuilder, SearchExpression, SearchExpressionBuilder, ExpandExpression, ExpandExpressionBuilder, SelectExpression, SelectExpressionBuilder, ApplyExpression, ApplyExpressionBuilder } from './expressions';
 import { ODataQueryArguments, ODataQueryOptions } from './options';
@@ -98,7 +98,7 @@ export declare class ODataQueryOptionsHandler<T> {
      * @param value The value to raw
      * @returns The raw value
      */
-    raw(value: any): import("./builder").QueryCustomType;
+    raw(value: any): import("angular-odata").QueryCustomType;
     /**
      * 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
@@ -106,19 +106,19 @@ export declare class ODataQueryOptionsHandler<T> {
      * @param name The name of the alias
      * @returns The alias
      */
-    alias(value: any, name?: string): import("./builder").QueryCustomType;
+    alias(value: any, name?: string): import("angular-odata").QueryCustomType;
     /**
      * Create a duration odata value
      * @param value The value to duration
      * @returns The duration value
      */
-    duration(value: any): import("./builder").QueryCustomType;
+    duration(value: any): import("angular-odata").QueryCustomType;
     /**
      * Create a binary odata value
      * @param value The value to binary
      * @returns The binary value
      */
-    binary(value: any): import("./builder").QueryCustomType;
+    binary(value: any): import("angular-odata").QueryCustomType;
     /**
      * Normalize the given value to a valid odata value
      * @param value The value to normalize
@@ -247,6 +247,11 @@ export declare class ODataQueryOptionsHandler<T> {
      * @param options The query to be applied.
      */
     restore(options: ODataQueryArguments<T>): void;
+    /**
+     * Combine the given query options with the current query.
+     * @param options The query to be combined.
+     */
+    combine(options: ODataQueryArguments<T>): void;
     toJson(): {};
     fromJson(json: {
         [name: string]: any;
@@ -255,4 +260,11 @@ export declare class ODataQueryOptionsHandler<T> {
         escape?: boolean;
         parser?: Parser<T>;
     }): string;
+    pathAndParams({ escape, parser, options, }?: {
+        escape?: boolean;
+        parser?: Parser<T>;
+        options?: ParserOptions;
+    }): [string, {
+        [name: string]: any;
+    }];
 }

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

@@ -22,9 +22,9 @@ export type ODataQueryArguments<T> = {
     [QueryOption.count]?: boolean | null;
 };
 export declare const pathAndParamsFromQueryOptions: <T>(values: Map<QueryOption, any>, { escape, parser, options, }?: {
-    escape?: boolean | undefined;
-    parser?: Parser<T> | undefined;
-    options?: ParserOptions | undefined;
+    escape?: boolean;
+    parser?: Parser<T>;
+    options?: ParserOptions;
 }) => [string, {
     [name: string]: any;
 }];

package/lib/resources/resource.d.ts

@@ -1,8 +1,8 @@
 import { Observable } from 'rxjs';
 import { ODataApi } from '../api';
-import { ODataCollection, ODataModel } from '../models';
+import { ModelInterface, ODataCollection, ODataModel } from '../models';
 import { ODataStructuredType } from '../schema';
-import { ParserOptions, QueryOption, StructuredTypeFieldConfig } from '../types';
+import { ParserOptions, QueryOption, ODataStructuredTypeFieldConfig } from '../types';
 import { ODataPathSegments, ODataPathSegmentsHandler } from './path';
 import { ODataQueryOptions, ODataQueryOptionsHandler } from './query';
 import { ApplyExpression, ApplyExpressionBuilder, QueryCustomType } from './query';
@@ -35,24 +35,52 @@ export declare class ODataResource<T> {
      * @returns string All covered types of the resource
      */
     types(): string[];
-    callable(): import("../schema").ODataCallable<T> | undefined;
-    enumType(): import("../schema").ODataEnumType<T> | undefined;
-    structuredType(): ODataStructuredType<T> | undefined;
+    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;
-    }, { annots, ModelType, }?: {
+    }): 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;
-    }[], { annots, CollectionType, }?: {
+    }[]): 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;
@@ -100,7 +128,7 @@ export declare class ODataResource<T> {
     transform<R>(opts: (builder: ApplyExpressionBuilder<T>, current?: ApplyExpression<T>) => ApplyExpression<T>, { type, fields, }?: {
         type?: string;
         fields?: {
-            [P in keyof R]?: StructuredTypeFieldConfig;
+            [name: string]: ODataStructuredTypeFieldConfig;
         };
     }): ODataResource<R>;
     static resolveKey<T>(value: any, schema?: ODataStructuredType<T>): EntityKey<T> | undefined;

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

@@ -56,9 +56,9 @@ export declare class ODataActionResource<P, R> extends ODataResource<R> {
      * @param options Options for the request
      * @returns Observable of the result of the action
      */
-    callModel<M extends ODataModel<R>>(params: P | null, options?: ODataOptions & {
+    callModel(params: P | null, options?: ODataOptions & {
         ModelType?: typeof ODataModel;
-    }): Observable<M | null>;
+    }): 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
@@ -72,9 +72,9 @@ export declare class ODataActionResource<P, R> extends ODataResource<R> {
      * @param options Options for the request
      * @returns Observable of the result of the action
      */
-    callCollection<M extends ODataModel<R>, C extends ODataCollection<R, M>>(params: P | null, options?: ODataOptions & {
+    callCollection(params: P | null, options?: ODataOptions & {
         CollectionType?: typeof ODataCollection;
-    }): Observable<C | null>;
+    }): Observable<ODataCollection<R, ODataModel<R> & import("angular-odata").ModelInterface<R>> | null>;
     callArraybuffer(params: P | null, { alias, ...options }?: {
         alias?: boolean;
     } & ODataOptions): Observable<ArrayBuffer>;