angular-odata 0.127.0 → 0.130.0

package/lib/models/options.d.ts

@@ -1,10 +1,12 @@
 import { Subscription } from 'rxjs';
-import { EntityKey, ODataEntitiesAnnotations, ODataEntityAnnotations, ODataEntityResource, ODataEntitySetResource, ODataNavigationPropertyResource, ODataPropertyResource, ODataQueryOptions, ODataQueryOptionsHandler, ODataResource, ODataSingletonResource } from '../resources';
-import { ODataEntitySet, ODataStructuredType, ODataStructuredTypeFieldParser } from '../schema';
-import { EdmType, Parser, ParserOptions } from '../types';
+import { EntityKey, ODataQueryOptions, ODataQueryOptionsHandler, ODataResource, ODataSingletonResource } from '../resources';
+import { ODataEntityResource, ODataEntitySetResource, ODataNavigationPropertyResource, ODataPropertyResource } from '../resources';
+import { ODataEntitySet, ODataEnumType, ODataStructuredType, ODataStructuredTypeFieldParser } from '../schema';
+import { EdmType, ParserOptions } from '../types';
 import { ODataCollection } from './collection';
 import { ODataModel } from './model';
 import { EventEmitter } from '@angular/core';
+import { ODataEntitiesAnnotations, ODataEntityAnnotations } from '../annotations';
 export declare enum ODataModelEventType {
     Change = "change",
     Reset = "reset",
@@ -40,7 +42,7 @@ export declare class ODataModelEvent<T> {
         ODataModel<any> | ODataCollection<any, ODataModel<any>>,
         ODataModelAttribute<any> | number | null
     ][];
-    push(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>, attr: ODataModelAttribute<any> | number): ODataModelEvent<T>;
+    push(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>, attr: ODataModelAttribute<any> | number): ODataModelEvent<any>;
     bubbles: boolean;
     stopPropagation(): void;
     visited(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
@@ -85,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>;
@@ -105,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;
@@ -119,7 +127,11 @@ export declare class ODataModelField<F> {
     field: string;
     parser: ODataStructuredTypeFieldParser<F>;
     options: ODataModelOptions<any>;
-    meta?: ODataModelOptions<any>;
+    optionsForType?: (type: string) => ODataModelOptions<any> | undefined;
+    modelForType?: (t: string) => typeof ODataModel<any> | undefined;
+    collectionForType?: (t: string) => typeof ODataCollection<any, ODataModel<any>> | undefined;
+    enumForType?: (t: string) => ODataEnumType<F> | undefined;
+    structuredForType?: (t: string) => ODataStructuredType<F> | undefined;
     default?: any;
     required: boolean;
     concurrency: boolean;
@@ -130,13 +142,16 @@ export declare class ODataModelField<F> {
     pattern?: RegExp;
     parserOptions?: ParserOptions;
     constructor(options: ODataModelOptions<any>, { name, field, parser, ...opts }: ODataModelFieldOptions<F>);
-    get api(): import("angular-odata").ODataApi;
     get type(): string;
     get navigation(): boolean;
     get collection(): boolean;
     annotatedValue<T>(term: string | RegExp): T | undefined;
-    configure({ findOptionsForType, concurrency, options, }: {
-        findOptionsForType: (type: string) => ODataModelOptions<any> | undefined;
+    configure({ optionsForType, modelForType, collectionForType, enumForType, structuredForType, concurrency, options, }: {
+        optionsForType: (type: string) => ODataModelOptions<any> | undefined;
+        modelForType: (t: string) => typeof ODataModel<any> | undefined;
+        collectionForType: (t: string) => typeof ODataCollection<any, any> | undefined;
+        enumForType: (t: string) => ODataEnumType<any> | undefined;
+        structuredForType: (t: string) => ODataStructuredType<any> | undefined;
         concurrency: boolean;
         options: ParserOptions;
     }): void;
@@ -144,9 +159,9 @@ export declare class ODataModelField<F> {
     hasReferentials(): boolean;
     get referentials(): import("../schema").ODataReferential[];
     isStructuredType(): boolean;
-    structured(): ODataStructuredType<F>;
+    structuredType(): ODataStructuredType<F>;
     isEnumType(): boolean;
-    enum(): import("../schema").ODataEnumType<F>;
+    enumType(): ODataEnumType<F>;
     validate(value: any, { method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
@@ -157,7 +172,6 @@ export declare class ODataModelField<F> {
     encode(value: F, options?: ParserOptions): any;
     resourceFactory<T, F>(base: ODataResource<T>): ODataNavigationPropertyResource<F> | ODataPropertyResource<F>;
     annotationsFactory<T, F>(base: ODataEntityAnnotations<T>): ODataEntityAnnotations<F> | ODataEntitiesAnnotations<F>;
-    schemaFactory<T, F>(base: ODataStructuredType<T>): ODataStructuredType<F> | undefined;
     modelFactory<F>({ parent, value, reset, }: {
         parent: ODataModel<any>;
         value?: Partial<F> | {
@@ -176,17 +190,18 @@ export declare class ODataModelField<F> {
 export declare class ODataModelAttribute<T> {
     private _model;
     private _field;
+    private state;
     private value?;
     private change?;
     private subscription?;
     events$: ODataModelEventEmitter<T>;
     constructor(_model: ODataModel<any>, _field: ODataModelField<T>);
+    get type(): string;
     get navigation(): boolean;
     get computed(): boolean | undefined;
     get concurrency(): boolean;
     get referentials(): import("../schema").ODataReferential[];
     get options(): ODataModelOptions<any>;
-    get meta(): ODataModelOptions<any> | undefined;
     get name(): string;
     get fieldName(): string;
     get(): T | ODataModel<T> | ODataCollection<T, ODataModel<T>> | null | undefined;
@@ -211,14 +226,14 @@ export declare class ODataModelOptions<T> {
     cid: string;
     base?: string;
     private _fields;
-    schema: ODataStructuredType<T>;
+    structuredType: ODataStructuredType<T>;
     entitySet?: ODataEntitySet;
     parent?: ODataModelOptions<any>;
     children: ODataModelOptions<any>[];
     events$: ODataModelEventEmitter<T>;
-    constructor({ options, schema, }: {
-        options: ModelOptions;
-        schema: ODataStructuredType<T>;
+    constructor({ config, structuredType, }: {
+        config: ModelOptions;
+        structuredType: ODataStructuredType<T>;
     });
     get api(): import("angular-odata").ODataApi;
     type({ alias }?: {
@@ -232,17 +247,17 @@ export declare class ODataModelOptions<T> {
         [name: string]: any;
     }): boolean;
     findChildOptions(predicate: (options: ODataModelOptions<any>) => boolean): ODataModelOptions<any> | undefined;
-    configure({ options, parserForType, findOptionsForType, }: {
+    configure({ options }: {
         options: ParserOptions;
-        parserForType: (type: string) => Parser<any>;
-        findOptionsForType: (type: string) => ODataModelOptions<any> | undefined;
     }): void;
     fields({ include_navigation, include_parents, }: {
         include_parents: boolean;
         include_navigation: boolean;
     }): ODataModelField<any>[];
     field<F>(name: keyof T | string): ODataModelField<F>;
-    findField<F>(name: keyof T | string): ODataModelField<F> | undefined;
+    findField<F>(name: keyof T | string, { reset }?: {
+        reset?: boolean;
+    }): ODataModelField<F> | undefined;
     addField<F>(name: string, options: ModelFieldOptions): ODataModelField<F>;
     tsToEdm: Record<string, EdmType>;
     private modelFieldFactory;
@@ -332,7 +347,7 @@ export declare class ODataModelOptions<T> {
         reset?: boolean;
         reparent?: boolean;
         silent?: boolean;
-    }): void;
+    }): ODataModel<T>;
     static isModel(obj: any): boolean;
     static isCollection(obj: any): boolean;
     get<F>(self: ODataModel<T>, field: ODataModelField<F> | string): F | ODataModel<F> | ODataCollection<F, ODataModel<F>> | null | undefined;
@@ -340,8 +355,14 @@ export declare class ODataModelOptions<T> {
         [name: string]: any;
     } | {
         [name: string]: any;
-    }[] | ODataModel<F> | ODataCollection<F, ODataModel<F>> | null, { type }?: {
-        type?: string;
+    }[] | ODataModel<F> | ODataCollection<F, ODataModel<F>> | null, { add, merge, remove, reset, reparent, silent, type, }?: {
+        add?: boolean;
+        merge?: boolean;
+        remove?: boolean;
+        reset?: boolean;
+        reparent?: boolean;
+        silent?: boolean;
+        type?: EdmType | string;
     }): boolean;
     private _link;
 }

package/lib/resources/index.d.ts

@@ -3,4 +3,4 @@ export * from './path';
 export * from './request';
 export * from './resource';
 export * from './types';
-export * from './responses';
+export * from './response';

package/lib/resources/{responses/options.d.ts → options.d.ts}

@@ -1,4 +1,4 @@
-import { ODataMetadataType, ODataVersion, ParserOptions, ResponseOptions } from '../../types';
+import { ODataMetadataType, ODataVersion, ParserOptions, ResponseOptions } from '../types';
 export declare class ODataResponseOptions implements ResponseOptions {
     version: ODataVersion;
     streaming?: boolean;
@@ -8,7 +8,7 @@ export declare class ODataResponseOptions implements ResponseOptions {
     cacheability?: 'public' | 'private' | 'no-cache' | 'no-store';
     maxAge?: number;
     constructor(config: ParserOptions);
-    get helper(): import("../../helper").ODataVersionHelper;
+    get helper(): import("../helper").ODataVersionHelper;
     clone(): ODataResponseOptions;
     setFeatures(features: string): void;
     setVersion(version: string): void;

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

@@ -1,11 +1,13 @@
 import { PathSegment } from '../../types';
 import { EntityKey } from '../resource';
-import type { ODataPathSegments, ODataSegment } from './segments';
+import { ODataPathSegments, ODataSegment } from './segments';
 export declare class SegmentHandler {
     private segment;
     constructor(segment: ODataSegment);
     get name(): PathSegment;
-    type(value?: string): string | undefined;
+    outgoingType(value?: string): string | undefined;
+    incomingType(value?: string): string | undefined;
+    bindingType(value?: string): string | undefined;
     path(value?: string): string;
     key<T>(value?: EntityKey<T>): EntityKey<T>;
     hasKey(): boolean;

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

@@ -4,14 +4,16 @@ import { SegmentHandler } from './handlers';
 export type ODataSegment = {
     name: PathSegment;
     path: string;
-    type?: string;
+    outgoingType?: string;
+    incomingType?: string;
+    bindingType?: string;
     key?: any;
     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

@@ -1,21 +1,44 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { FilterConnector, FilterExpression } from './filter';
 import { SearchConnector, SearchExpression } from './search';
 import { ODataFunctions, ODataOperators, Renderable, AggregateMethod } from './syntax';
-declare class GroupByTransformations<T> implements Renderable {
-    render({ aliases, escape, prefix, parser, options, }: {
-        aliases?: QueryCustomType[] | undefined;
-        escape?: boolean | undefined;
-        prefix?: string | undefined;
-        parser?: Parser<any> | undefined;
-        options?: ParserOptions | undefined;
+export declare class GroupByTransformations<T> extends Expression<T> {
+    protected methods: (AggregateMethod | string)[];
+    protected aliases: string[];
+    constructor({ children, methods, aliases, }?: {
+        children?: Renderable[];
+        methods?: (AggregateMethod | string)[];
+        aliases?: string[];
+    });
+    get [Symbol.toStringTag](): string;
+    toJson(): {
+        $type: string;
+        children: any[];
+    } & {
+        methods: string[];
+        aliases: string[];
+    };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): GroupByTransformations<T>;
+    render({ aliases, escape, prefix, parser, options, }?: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+        parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
-    toString(): string;
-    toJson(): void;
-    clone(): void;
-    resolve(parser: any): void;
+    clone(): GroupByTransformations<T>;
+    private _add;
+    aggregate(value: any, method: AggregateMethod | string, alias: string): GroupByTransformations<T>;
+    sum(value: any, alias: string): GroupByTransformations<T>;
+    min(value: any, alias: string): GroupByTransformations<T>;
+    max(value: any, alias: string): GroupByTransformations<T>;
+    average(value: any, alias: string): GroupByTransformations<T>;
+    countdistinct(value: any, alias: string): GroupByTransformations<T>;
+    count(alias: string): GroupByTransformations<T>;
 }
 export type ApplyExpressionBuilder<T> = {
     t: Required<T>;
@@ -84,7 +107,7 @@ export declare class ApplyExpression<T> extends Expression<T> {
         e: (connector?: FilterConnector) => FilterExpression<T>;
         o: ODataOperators<T>;
         f: ODataFunctions<T>;
-    }) => FilterExpression<T>): ApplyExpression<any>;
+    }) => FilterExpression<T>): ApplyExpression<T>;
     expand(opts: (e: {
         o: ODataOperators<T>;
         f: ODataFunctions<T>;
@@ -94,10 +117,9 @@ export declare class ApplyExpression<T> extends Expression<T> {
         e: (connector?: SearchConnector) => SearchExpression<T>;
         o: ODataOperators<T>;
         f: ODataFunctions<T>;
-    }) => SearchExpression<T>): ApplyExpression<any>;
+    }) => SearchExpression<T>): ApplyExpression<T>;
     compute(opts: (e: {
         o: ODataOperators<T>;
         f: ODataFunctions<T>;
     }) => Renderable): ApplyExpression<T>;
 }
-export {};

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

@@ -1,5 +1,5 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { QueryCustomType } from '../builder';
 import { Renderable } from './syntax';
 export declare abstract class Expression<T> implements Renderable {
     protected _children: Renderable[];

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

@@ -1,5 +1,5 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
 export type ComputeExpressionBuilder<T> = {
@@ -7,7 +7,7 @@ export type ComputeExpressionBuilder<T> = {
     e: () => ComputeExpression<T>;
 };
 export declare class ComputeExpression<T> extends Expression<T> {
-    names: string[];
+    protected names: string[];
     constructor({ children, names, }?: {
         children?: Renderable[];
         names?: string[];

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

@@ -1,5 +1,5 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { FilterExpression, FilterExpressionBuilder } from './filter';
 import { Renderable } from './syntax';

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

@@ -1,6 +1,7 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType, Unpacked } from '../builder';
+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';
@@ -30,6 +31,7 @@ export declare class ExpandField<T> implements Renderable {
     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>;
+    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";

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

@@ -1,5 +1,5 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { CountExpression, CountField } from './count';
 import { Normalize, ODataFunctions, ODataOperators, Renderable } from './syntax';

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

@@ -1,16 +1,17 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
+export type OrderAttribute = 'asc' | 'desc';
 export declare class OrderByField implements Renderable {
     protected field: Renderable;
-    protected order: 'asc' | 'desc';
-    constructor(field: Renderable, order: 'asc' | 'desc');
+    protected order: OrderAttribute;
+    constructor(field: Renderable, order: OrderAttribute);
     get [Symbol.toStringTag](): string;
     toJson(): {
         $type: string;
         field: any;
-        order: "asc" | "desc";
+        order: OrderAttribute;
     };
     render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];

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

@@ -1,5 +1,5 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
 export type SearchConnector = 'AND' | 'OR';

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

@@ -1,5 +1,5 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
 export type SelectExpressionBuilder<T> = {
@@ -29,4 +29,5 @@ export declare class SelectExpression<T> extends Expression<T> {
     clone(): SelectExpression<T>;
     private _add;
     field(field: any): SelectExpression<T>;
+    fields(...fields: any[]): SelectExpression<T>;
 }

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

@@ -1,5 +1,5 @@
 import { Parser, ParserOptions } from '../../../types';
-import type { QueryCustomType } from '../builder';
+import { QueryCustomType } from '../builder';
 export type Normalize = 'all' | 'right' | 'left' | 'none';
 export interface Renderable {
     render({ aliases, escape, prefix, parser, options, }: {
@@ -231,14 +231,17 @@ export declare class Transformations<T> {
     bottomSum(value: number, field: Renderable, normalize?: Normalize): Function<T>;
     bottomPercent(value: number, field: Renderable, normalize?: Normalize): Function<T>;
     identity(): Function<T>;
-    search(left: any, normalize?: Normalize): Function<T>;
-    filter(left: any, normalize?: Normalize): Function<T>;
+    search(value: any, normalize?: Normalize): Function<T>;
+    filter(value: any, normalize?: Normalize): Function<T>;
+    skip(value: number, normalize?: Normalize): Function<T>;
+    top(value: number, normalize?: Normalize): Function<T>;
+    orderby(value: any, normalize?: Normalize): Function<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/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,53 +1,88 @@
 import { Observable } from 'rxjs';
 import { ODataApi } from '../api';
-import { ODataCollection, ODataModel } from '../models';
+import { ModelInterface, ODataCollection, ODataModel } from '../models';
 import { ODataStructuredType } from '../schema';
-import { ODataSchemaElement } from '../schema/element';
-import { ParserOptions, QueryOption } from '../types';
+import { ParserOptions, QueryOption, StructuredTypeFieldConfig } from '../types';
 import { ODataPathSegments, ODataPathSegmentsHandler } from './path';
-import { ODataQueryOptions, ODataQueryOptionsHandler, QueryCustomType } from './query';
-import { ODataEntitiesAnnotations, ODataEntityAnnotations } from './responses/index';
+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;
-    schema?: ODataSchemaElement;
     protected pathSegments: ODataPathSegments;
     protected queryOptions: ODataQueryOptions<T>;
-    constructor(api: ODataApi, { segments, query, schema, }?: {
+    constructor(api: ODataApi, { segments, query, }?: {
         segments?: ODataPathSegments;
         query?: ODataQueryOptions<T>;
-        schema?: ODataSchemaElement;
     });
     /**
-     * @returns string The type of the resource
+     * @returns string The outgoing type of the resource
      */
-    type(): string | undefined;
+    outgoingType(): string | undefined;
     /**
-     * @returns string The type of the return
+     * @returns string The incoming type of the resource
      */
-    returnType(): string | undefined;
+    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("../schema").ODataCallable<T> | undefined;
+    enumType(): import("../schema").ODataEnumType<T> | undefined;
+    structuredType(): 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 }?: {
+    }): 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 }?: {
+    }[]): 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;
@@ -66,8 +101,7 @@ export declare class ODataResource<T> {
         escape?: boolean;
     }): string;
     clone(): ODataResource<T>;
-    private __serializeParser;
-    private __deserializeParser;
+    private __parser;
     deserialize(value: any, options?: ParserOptions): any;
     serialize(value: any, options?: ParserOptions): any;
     encode(value: any, options?: ParserOptions): any;
@@ -91,6 +125,12 @@ export declare class ODataResource<T> {
      * @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]: StructuredTypeFieldConfig;
+        };
+    }): ODataResource<R>;
     static resolveKey<T>(value: any, schema?: ODataStructuredType<T>): EntityKey<T> | undefined;
     protected resolveKey(value: any): EntityKey<T> | undefined;
     protected get(options?: ODataOptions & {

package/lib/resources/{responses/response.d.ts → response.d.ts}

@@ -1,10 +1,22 @@
 import { HttpHeaders, HttpResponse } from '@angular/common/http';
-import { ODataResource } from '../resource';
-import { ODataEntities, ODataEntity, ODataProperty } from './types';
-import { ODataApi } from '../../api';
-import { ODataRequest } from '../request';
+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';
-import { ODataContext } from '../../helper';
+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
  */