angular-odata 0.128.0 → 0.131.0

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

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataCollection, ODataModel } from '../../models';
-import { QueryOption, StructuredTypeFieldConfig } from '../../types';
+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';
@@ -10,7 +10,6 @@ import { ODataEntityResource } from './entity';
 import { ODataFunctionResource } from './function';
 import { ODataOptions } from './options';
 import { ODataEntities, ODataEntity } from '../response';
-import { ODataEntitiesAnnotations } from '../../annotations';
 export declare class ODataEntitySetResource<T> extends ODataResource<T> {
     static factory<E>(api: ODataApi, { path, type, query, }: {
         path: string;
@@ -21,7 +20,7 @@ export declare class ODataEntitySetResource<T> extends 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;
         };
     }): ODataEntitySetResource<R>;
     entity(key?: any): ODataEntityResource<T>;
@@ -43,27 +42,35 @@ export declare class ODataEntitySetResource<T> extends ODataResource<T> {
         withCount?: boolean;
         bodyQueryOptions?: QueryOption[];
     }): Observable<{
-        entities: T[];
-        annots: ODataEntitiesAnnotations<T>;
+        entities: any[];
+        annots: import("angular-odata").ODataEntitiesAnnotations<any>;
     }>;
     fetchMany(top: number, options?: ODataOptions & {
         withCount?: boolean;
         bodyQueryOptions?: QueryOption[];
     }): Observable<{
         entities: T[];
-        annots: ODataEntitiesAnnotations<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: ODataEntitiesAnnotations<T>;
+        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[];

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

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataModel } from '../../models';
+import { ModelInterface, ODataModel } from '../../models';
 import { QueryOption } from '../../types';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
@@ -43,6 +43,10 @@ export declare class ODataEntityResource<T> extends ODataResource<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;

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

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

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

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataCollection, ODataModel } from '../../models';
-import { QueryOption, StructuredTypeFieldConfig } from '../../types';
+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';
@@ -28,7 +28,7 @@ export declare class ODataNavigationPropertyResource<T> extends 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;
         };
     }): ODataNavigationPropertyResource<R>;
     key(value: any): ODataNavigationPropertyResource<T>;
@@ -97,6 +97,10 @@ export declare class ODataNavigationPropertyResource<T> extends ODataResource<T>
      * @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;
@@ -114,6 +118,11 @@ export declare class ODataNavigationPropertyResource<T> extends ODataResource<T>
      * @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[];

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

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataCollection, ODataModel } from '../../models';
-import { QueryOption, StructuredTypeFieldConfig } from '../../types';
+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';
@@ -21,7 +21,7 @@ export declare class ODataPropertyResource<T> extends 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;
         };
     }): ODataPropertyResource<R>;
     key(value: any): ODataPropertyResource<T>;
@@ -55,7 +55,12 @@ export declare class ODataPropertyResource<T> extends ODataResource<T> {
      * @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>;
     /**
@@ -71,8 +76,14 @@ export declare class ODataPropertyResource<T> extends ODataResource<T> {
      * @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 & {

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

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
-import { ODataModel } from '../../models';
+import { ModelInterface, ODataModel } from '../../models';
 import { QueryOption } from '../../types';
 import { ODataResource } from '../resource';
 import { ODataEntity } from '../response';
@@ -76,6 +76,10 @@ export declare class ODataSingletonResource<T> extends ODataResource<T> {
      * @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;

package/lib/schema/annotation.d.ts

@@ -1,4 +1,4 @@
-import { AnnotationConfig } from '../types';
+import { ODataAnnotationConfig } from '../types';
 export declare class ODataAnnotation {
     term: string;
     string?: string;
@@ -6,12 +6,12 @@ export declare class ODataAnnotation {
     int?: number;
     permissions?: string[];
     properties?: string[];
-    constructor(annot: AnnotationConfig);
+    constructor(annot: ODataAnnotationConfig);
 }
 export declare class ODataAnnotatable {
     annotations: ODataAnnotation[];
     constructor(config: {
-        annotations?: AnnotationConfig[];
+        annotations?: ODataAnnotationConfig[];
     });
     /**
      * Find an annotation inside the annotatable.

package/lib/schema/callable.d.ts

@@ -1,4 +1,4 @@
-import { CallableConfig, ParserOptions } from '../types';
+import { ODataCallableConfig, ParserOptions } from '../types';
 import { ODataParserSchemaElement } from './element';
 import { ODataCallableParser } from './parsers';
 import { ODataSchema } from './schema';
@@ -6,7 +6,7 @@ export declare class ODataCallable<R> extends ODataParserSchemaElement<R, ODataC
     entitySetPath?: string;
     bound?: boolean;
     composable?: boolean;
-    constructor(config: CallableConfig, schema: ODataSchema);
+    constructor(config: ODataCallableConfig, schema: ODataSchema);
     path(): string;
     configure({ options }: {
         options: ParserOptions;
@@ -36,6 +36,6 @@ export declare class ODataCallable<R> extends ODataParserSchemaElement<R, ODataC
      * Returns the binding parameter of the callable.
      * @returns The binding parameter of the callable.
      */
-    binding(): import("./parsers").ODataParameterParser<any> | undefined;
+    binding(): import("angular-odata").ODataParameterParser<any> | undefined;
     returnType(): string | undefined;
 }

package/lib/schema/element.d.ts

@@ -1,11 +1,11 @@
-import { AnnotationConfig, Parser } from '../types';
+import { ODataAnnotationConfig, Parser } from '../types';
 import { ODataAnnotatable } from './annotation';
 import { ODataSchema } from './schema';
 export declare class ODataSchemaElement extends ODataAnnotatable {
     name: string;
     schema: ODataSchema;
     constructor(config: {
-        annotations?: AnnotationConfig[];
+        annotations?: ODataAnnotationConfig[];
         name: string;
     }, schema: ODataSchema);
     get api(): import("angular-odata").ODataApi;
@@ -46,7 +46,7 @@ export declare class ODataSchemaElement extends ODataAnnotatable {
 export declare class ODataParserSchemaElement<E, P extends Parser<E>> extends ODataSchemaElement {
     parser: P;
     constructor(config: {
-        annotations?: AnnotationConfig[];
+        annotations?: ODataAnnotationConfig[];
         name: string;
     }, schema: ODataSchema, parser: P);
 }

package/lib/schema/entity-container.d.ts

@@ -1,4 +1,4 @@
-import { EntityContainerConfig } from '../types';
+import { ODataEntityContainerConfig } from '../types';
 import { ODataSchemaElement } from './element';
 import { ODataEntitySet } from './entity-set';
 import { ODataSchema } from './schema';
@@ -6,5 +6,5 @@ import { ODataSingleton } from './singleton';
 export declare class ODataEntityContainer extends ODataSchemaElement {
     entitySets: ODataEntitySet[];
     singletons: ODataSingleton[];
-    constructor(config: EntityContainerConfig, schema: ODataSchema);
+    constructor(config: ODataEntityContainerConfig, schema: ODataSchema);
 }

package/lib/schema/entity-set.d.ts

@@ -1,4 +1,4 @@
-import { EntitySetConfig } from '../types';
+import { ODataEntitySetConfig } from '../types';
 import { ODataSchemaElement } from './element';
 import { ODataSchema } from './schema';
 export declare class ODataEntitySet extends ODataSchemaElement {
@@ -6,5 +6,5 @@ export declare class ODataEntitySet extends ODataSchemaElement {
     service: {
         new (...params: any[]): any;
     };
-    constructor(config: EntitySetConfig, schema: ODataSchema);
+    constructor(config: ODataEntitySetConfig, schema: ODataSchema);
 }

package/lib/schema/enum-type.d.ts

@@ -1,14 +1,14 @@
-import { EnumTypeConfig, ParserOptions } from '../types';
+import { ODataEnumTypeConfig, ParserOptions } from '../types';
 import { ODataParserSchemaElement } from './element';
 import { ODataEnumTypeFieldParser, ODataEnumTypeParser } from './parsers';
 import { ODataSchema } from './schema';
 export declare class ODataEnumType<E> extends ODataParserSchemaElement<E, ODataEnumTypeParser<E>> {
     members: {
-        [name: string]: E;
+        [name: string]: number;
     } | {
         [value: number]: string;
     };
-    constructor(config: EnumTypeConfig<E>, schema: ODataSchema);
+    constructor(config: ODataEnumTypeConfig, schema: ODataSchema);
     configure({ options }: {
         options: ParserOptions;
     }): void;
@@ -16,19 +16,19 @@ export declare class ODataEnumType<E> extends ODataParserSchemaElement<E, ODataE
      * Returns the fields of the enum type.
      * @returns The fields of the enum type.
      */
-    fields(value?: E): ODataEnumTypeFieldParser<E>[];
+    fields(namesValue?: string | number): ODataEnumTypeFieldParser[];
     /**
      * Find a field by name or value.
      * @param enu The name or value of the field
      * @returns The field with the given name or value
      */
-    field(enu: string | E): ODataEnumTypeFieldParser<E>;
+    field(nameValue: string | number): ODataEnumTypeFieldParser | undefined;
     /**
      * Map the fields of the enum type.
      * @param mapper Function that maps the value to the new value
      * @returns The fields mapped by the mapper
      */
-    mapFields<T>(mapper: (field: ODataEnumTypeFieldParser<E>) => T): T[];
+    mapFields<T>(mapper: (field: ODataEnumTypeFieldParser) => T): T[];
     /**
      * Deseialize the given value from the enum type.
      * @param value Value to deserialize
@@ -42,14 +42,14 @@ export declare class ODataEnumType<E> extends ODataParserSchemaElement<E, ODataE
      * @param options Options for serialization
      * @returns Serialized value
      */
-    serialize(value: E, options?: ParserOptions): any;
+    serialize(value: number, options?: ParserOptions): any;
     /**
      * Encode the given value for the enum type.
      * @param value Value to encode
      * @param options Options for encoding
      * @returns Encoded value
      */
-    encode(value: E, options?: ParserOptions): any;
-    unpack(value: E): number[];
-    pack(value: number[]): E;
+    encode(value: number, options?: ParserOptions): any;
+    unpack(value: string | number): number[];
+    pack(value: string | number | number[]): number;
 }

package/lib/schema/parsers/callable.d.ts

@@ -1,4 +1,4 @@
-import { CallableConfig, ParserOptions, ParameterConfig, Parser } from '../../types';
+import { ODataCallableConfig, ParserOptions, ODataParameterConfig, Parser } from '../../types';
 import { ODataEnumTypeParser } from './enum-type';
 import { ODataStructuredTypeParser } from './structured-type';
 export declare class ODataParameterParser<T> {
@@ -8,7 +8,7 @@ export declare class ODataParameterParser<T> {
     collection?: boolean;
     nullable?: boolean;
     parserOptions?: ParserOptions;
-    constructor(name: string, parameter: ParameterConfig);
+    constructor(name: string, parameter: ODataParameterConfig);
     serialize(value: T, options?: ParserOptions): any;
     encode(value: any, options?: ParserOptions): string;
     configure({ options, parserForType, }: {
@@ -20,7 +20,7 @@ export declare class ODataParameterParser<T> {
     enumType(): ODataEnumTypeParser<T>;
     isStructuredType(): boolean;
     structuredType(): ODataStructuredTypeParser<T>;
-    field<F>(name: string): import("./structured-type").ODataStructuredTypeFieldParser<F>;
+    field<F>(name: string): import("angular-odata").ODataStructuredTypeFieldParser<F>;
 }
 export declare class ODataCallableParser<R> implements Parser<R> {
     name: string;
@@ -33,7 +33,7 @@ export declare class ODataCallableParser<R> implements Parser<R> {
     parser: Parser<any>;
     parameters: ODataParameterParser<any>[];
     parserOptions?: ParserOptions;
-    constructor(config: CallableConfig, namespace: string, alias?: string);
+    constructor(config: ODataCallableConfig, namespace: string, alias?: string);
     isTypeOf(type: string): boolean;
     deserialize(value: any, options?: ParserOptions): R;
     serialize(params: any, options?: ParserOptions): any;

package/lib/schema/parsers/enum-type.d.ts

@@ -1,9 +1,9 @@
-import { EnumTypeConfig, EnumTypeFieldConfig, ParserOptions, FieldParser, JsonType } from '../../types';
+import { ODataEnumTypeConfig, ODataEnumTypeFieldConfig, ParserOptions, FieldParser, JsonType } from '../../types';
 import { ODataAnnotatable } from '../annotation';
-export declare class ODataEnumTypeFieldParser<E> extends ODataAnnotatable {
+export declare class ODataEnumTypeFieldParser extends ODataAnnotatable {
     name: string;
-    value: E;
-    constructor(name: string, field: EnumTypeFieldConfig<E>);
+    value: number;
+    constructor(name: string, field: ODataEnumTypeFieldConfig);
     titleize(term?: string | RegExp): string;
 }
 export declare class ODataEnumTypeParser<E> extends ODataAnnotatable implements FieldParser<E> {
@@ -12,28 +12,28 @@ export declare class ODataEnumTypeParser<E> extends ODataAnnotatable implements
     alias?: string;
     flags?: boolean;
     members: {
-        [name: string]: E;
+        [name: string]: number;
     } | {
         [value: number]: string;
     };
     private _fields;
     parserOptions?: ParserOptions;
-    constructor(config: EnumTypeConfig<E>, namespace: string, alias?: string);
+    constructor(config: ODataEnumTypeConfig, namespace: string, alias?: string);
     configure({ options }: {
         options: ParserOptions;
     }): void;
     isTypeOf(type: string): boolean;
-    fields(value?: E): ODataEnumTypeFieldParser<E>[];
-    field(nameValue: string | E): ODataEnumTypeFieldParser<E>;
+    fields(namesValue?: string | number | number[]): ODataEnumTypeFieldParser[];
+    field(nameValue: string | number): ODataEnumTypeFieldParser | undefined;
     /**
      * Map the fields of the enum type.
      * @param mapper Function that maps the value to the new value
      * @returns The fields mapped by the mapper
      */
-    mapFields<R>(mapper: (field: ODataEnumTypeFieldParser<E>) => R): R[];
+    mapFields<R>(mapper: (field: ODataEnumTypeFieldParser) => R): R[];
     deserialize(value: string, options?: ParserOptions): E;
-    serialize(value: E, options?: ParserOptions): string | undefined;
-    encode(value: E, options?: ParserOptions): any;
+    serialize(value: number, options?: ParserOptions): string | undefined;
+    encode(value: number, options?: ParserOptions): any;
     toJsonSchema(): {
         title: string;
         type: JsonType;
@@ -43,14 +43,14 @@ export declare class ODataEnumTypeParser<E> extends ODataAnnotatable implements
         enum?: undefined;
     } | {
         type: JsonType;
-        enum: E[];
+        enum: number[];
         title?: undefined;
         items?: undefined;
     };
-    validate(member: string | number, { method, navigation, }?: {
+    validate(value: string | number, { method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
     }): string[] | undefined;
-    unpack(value: E): number[];
-    pack(value: number[]): E;
+    unpack(value: string | number): number[];
+    pack(value: string | number | number[]): number;
 }

package/lib/schema/parsers/structured-type.d.ts

@@ -1,4 +1,4 @@
-import { ParserOptions, Parser, StructuredTypeConfig, StructuredTypeFieldConfig, FieldParser, EdmType } from '../../types';
+import { ParserOptions, Parser, ODataStructuredTypeConfig, ODataStructuredTypeFieldConfig, FieldParser, EdmType } from '../../types';
 import { ODataAnnotatable } from '../annotation';
 import { ODataEnumTypeParser } from './enum-type';
 type JsonSchemaSelect<T> = Array<keyof T>;
@@ -47,7 +47,7 @@ export declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable
     scale?: number | 'variable';
     referentials: ODataReferential[];
     parserOptions?: ParserOptions;
-    constructor(name: string, structured: ODataStructuredTypeParser<any>, field: StructuredTypeFieldConfig);
+    constructor(name: string, structured: ODataStructuredTypeParser<any>, field: ODataStructuredTypeFieldConfig);
     validate(value: any, { method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';
         navigation?: boolean;
@@ -86,8 +86,8 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
     private _keys?;
     private _fields;
     parserOptions?: ParserOptions;
-    constructor(config: StructuredTypeConfig<T>, namespace: string, alias?: string);
-    addField<F>(name: string, config: StructuredTypeFieldConfig): ODataStructuredTypeFieldParser<F>;
+    constructor(config: ODataStructuredTypeConfig, namespace: string, alias?: string);
+    addField<F>(name: string, config: ODataStructuredTypeFieldConfig): ODataStructuredTypeFieldParser<F>;
     /**
      * Create a nicer looking title.
      * Titleize is meant for creating pretty output.
@@ -144,9 +144,12 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
      */
     pick(attrs: {
         [name: string]: any;
-    }, { include_parents, include_navigation, include_etag, options, }?: {
+    }, { include_id, include_key, include_parents, include_navigation, include_computed, include_etag, options, }?: {
+        include_id?: boolean;
+        include_key?: boolean;
         include_parents?: boolean;
         include_navigation?: boolean;
+        include_computed?: boolean;
         include_etag?: boolean;
         options?: ParserOptions;
     }): Partial<T>;

package/lib/schema/schema.d.ts

@@ -1,5 +1,5 @@
 import { ODataApi } from '../api';
-import { ParserOptions, SchemaConfig, StructuredTypeConfig } from '../types';
+import { ParserOptions, ODataSchemaConfig, ODataStructuredTypeConfig } from '../types';
 import { ODataAnnotatable } from './annotation';
 import { ODataCallable } from './callable';
 import { ODataEntityContainer } from './entity-container';
@@ -15,11 +15,11 @@ export declare class ODataSchema extends ODataAnnotatable {
     entities: ODataStructuredType<any>[];
     callables: ODataCallable<any>[];
     containers: ODataEntityContainer[];
-    constructor(config: SchemaConfig, api: ODataApi);
+    constructor(config: ODataSchemaConfig, api: ODataApi);
     isNamespaceOf(type: string): boolean;
     get entitySets(): ODataEntitySet[];
     get singletons(): ODataSingleton[];
-    createStructuredType<T>(config: StructuredTypeConfig<T>): ODataStructuredType<T>;
+    createStructuredType<T>(config: ODataStructuredTypeConfig): ODataStructuredType<T>;
     configure({ options }: {
         options: ParserOptions;
     }): void;

package/lib/schema/singleton.d.ts

@@ -1,4 +1,4 @@
-import { SingletonConfig } from '../types';
+import { ODataSingletonConfig } from '../types';
 import { ODataSchemaElement } from './element';
 import { ODataSchema } from './schema';
 export declare class ODataSingleton extends ODataSchemaElement {
@@ -6,5 +6,5 @@ export declare class ODataSingleton extends ODataSchemaElement {
     service: {
         new (...params: any[]): any;
     };
-    constructor(config: SingletonConfig, schema: ODataSchema);
+    constructor(config: ODataSingletonConfig, schema: ODataSchema);
 }

package/lib/schema/structured-type.d.ts

@@ -1,6 +1,6 @@
 import { ODataCollection } from '../models/collection';
 import { ODataModel } from '../models/model';
-import { ParserOptions, StructuredTypeConfig, StructuredTypeFieldConfig } from '../types';
+import { ParserOptions, ODataStructuredTypeConfig, ODataStructuredTypeFieldConfig } from '../types';
 import { ODataParserSchemaElement } from './element';
 import { JsonSchemaOptions, ODataEntityTypeKey, ODataStructuredTypeFieldParser, ODataStructuredTypeParser } from './parsers';
 import { ODataSchema } from './schema';
@@ -10,7 +10,7 @@ export declare class ODataStructuredType<T> extends ODataParserSchemaElement<T,
     children: ODataStructuredType<any>[];
     model?: typeof ODataModel;
     collection?: typeof ODataCollection;
-    constructor(config: StructuredTypeConfig<T>, schema: ODataSchema);
+    constructor(config: ODataStructuredTypeConfig, schema: ODataSchema);
     configure({ options }: {
         options: ParserOptions;
     }): void;
@@ -45,7 +45,7 @@ export declare class ODataStructuredType<T> extends ODataParserSchemaElement<T,
      * @returns The field parser
      */
     field<F>(name: keyof T): ODataStructuredTypeFieldParser<F>;
-    addField<F>(name: string, config: StructuredTypeFieldConfig): ODataStructuredTypeFieldParser<F>;
+    addField<F>(name: string, config: ODataStructuredTypeFieldConfig): ODataStructuredTypeFieldParser<F>;
     /**
      * Find a parent schema of the structured type.
      * @param predicate Function for evaluate the schemas in the hierarchy.
@@ -69,9 +69,12 @@ export declare class ODataStructuredType<T> extends ODataParserSchemaElement<T,
      */
     pick(attrs: {
         [name: string]: any;
-    }, { include_parents, include_navigation, include_etag, }?: {
+    }, { include_id, include_key, include_parents, include_navigation, include_computed, include_etag, }?: {
+        include_id?: boolean;
+        include_key?: boolean;
         include_parents?: boolean;
         include_navigation?: boolean;
+        include_computed?: boolean;
         include_etag?: boolean;
     }): Partial<T>;
     /**

package/lib/services/entity-set.d.ts

@@ -6,8 +6,8 @@ import { ODataEntityService } from './entity';
 export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
     static Model?: typeof ODataModel;
     static Collection?: typeof ODataCollection;
-    model(entity?: Partial<T>): ODataModel<T>;
-    collection(entities?: Partial<T>[]): ODataCollection<T, ODataModel<T>>;
+    model(entity?: Partial<T>, reset?: boolean): ODataModel<T> & import("angular-odata").ModelInterface<T>;
+    collection(entities?: Partial<T>[], reset?: boolean): ODataCollection<T, ODataModel<T> & import("angular-odata").ModelInterface<T>>;
     /**
      * Get the entity set resource for this service.
      */
@@ -32,8 +32,8 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
      * @param options The options for the request.
      */
     fetchAll(options?: ODataOptions): Observable<{
-        entities: T[];
-        annots: import("../annotations").ODataEntitiesAnnotations<T>;
+        entities: any[];
+        annots: import("angular-odata").ODataEntitiesAnnotations<any>;
     }>;
     /**
      * Get entities from the entity set.
@@ -44,7 +44,10 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
         withCount?: boolean;
     }): Observable<{
         entities: T[];
-        annots: import("../annotations").ODataEntitiesAnnotations<T>;
+        annots: import("angular-odata").ODataEntitiesAnnotations<T>;
+    } | {
+        entities: T[];
+        annots: import("angular-odata").ODataEntitiesAnnotations<any>;
     }>;
     /**
      * Get an entity from the entity set.
@@ -56,7 +59,7 @@ export declare class ODataEntitySetService<T> extends ODataEntityService<T> {
         etag?: string;
     }): Observable<{
         entity: T | null;
-        annots: import("../annotations").ODataEntitiesAnnotations<T>;
+        annots: import("angular-odata").ODataEntitiesAnnotations<T>;
     }>;
     /**
      * Create an entity in the entity set.

package/lib/services/entity.d.ts

@@ -7,5 +7,5 @@ export declare abstract class ODataEntityService<T> extends ODataBaseService {
     /**
      * The schema for the structured type.
      */
-    get structuredTypeSchema(): import("angular-odata").ODataStructuredType<T> | undefined;
+    get structuredTypeSchema(): import("angular-odata").ODataStructuredType<any> | import("angular-odata").ODataStructuredType<T> | undefined;
 }