angular-odata 0.130.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 type { ModelInterface, ODataCollection, ODataModel } from '../../models';
-import { QueryOption, StructuredTypeFieldConfig } from '../../types';
+import { QueryOption, ODataStructuredTypeFieldConfig } from '../../types';
 import { ApplyExpression, ApplyExpressionBuilder, ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
 import { ODataActionResource } from './action';
@@ -20,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?: {
-            [name: string]: StructuredTypeFieldConfig;
+            [name: string]: ODataStructuredTypeFieldConfig;
         };
     }): ODataEntitySetResource<R>;
     entity(key?: any): ODataEntityResource<T>;

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

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
 import type { ModelInterface, ODataCollection, ODataModel } from '../../models';
-import { QueryOption, StructuredTypeFieldConfig } from '../../types';
+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?: {
-            [name: string]: StructuredTypeFieldConfig;
+            [name: string]: ODataStructuredTypeFieldConfig;
         };
     }): ODataNavigationPropertyResource<R>;
     key(value: any): ODataNavigationPropertyResource<T>;

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

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
 import type { ModelInterface, ODataCollection, ODataModel } from '../../models';
-import { QueryOption, StructuredTypeFieldConfig } from '../../types';
+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?: {
-            [name: string]: StructuredTypeFieldConfig;
+            [name: string]: ODataStructuredTypeFieldConfig;
         };
     }): ODataPropertyResource<R>;
     key(value: any): ODataPropertyResource<T>;

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,4 +1,4 @@
-import { EnumTypeConfig, ParserOptions } from '../types';
+import { ODataEnumTypeConfig, ParserOptions } from '../types';
 import { ODataParserSchemaElement } from './element';
 import { ODataEnumTypeFieldParser, ODataEnumTypeParser } from './parsers';
 import { ODataSchema } from './schema';
@@ -8,7 +8,7 @@ export declare class ODataEnumType<E> extends ODataParserSchemaElement<E, ODataE
     } | {
         [value: number]: string;
     };
-    constructor(config: EnumTypeConfig, schema: ODataSchema);
+    constructor(config: ODataEnumTypeConfig, schema: ODataSchema);
     configure({ options }: {
         options: ParserOptions;
     }): void;

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 extends ODataAnnotatable {
     name: string;
     value: number;
-    constructor(name: string, field: EnumTypeFieldConfig);
+    constructor(name: string, field: ODataEnumTypeFieldConfig);
     titleize(term?: string | RegExp): string;
 }
 export declare class ODataEnumTypeParser<E> extends ODataAnnotatable implements FieldParser<E> {
@@ -18,7 +18,7 @@ export declare class ODataEnumTypeParser<E> extends ODataAnnotatable implements
     };
     private _fields;
     parserOptions?: ParserOptions;
-    constructor(config: EnumTypeConfig, namespace: string, alias?: string);
+    constructor(config: ODataEnumTypeConfig, namespace: string, alias?: string);
     configure({ options }: {
         options: ParserOptions;
     }): void;

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, 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.

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): 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, 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.

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;
 }

package/lib/settings.d.ts

@@ -3,10 +3,10 @@ import { ODataApi } from './api';
 import { ODataCollection, ODataModel } from './models';
 import { ODataRequest } from './resources';
 import { ODataCallable, ODataEntitySet, ODataEnumType, ODataStructuredType } from './schema';
-import { ApiConfig, EdmType, Parser } from './types';
+import { ODataApiConfig, EdmType, Parser } from './types';
 export declare class ODataSettings {
     apis: ODataApi[];
-    constructor(configs: ApiConfig[]);
+    constructor(configs: ODataApiConfig[]);
     configure(settings: {
         requester?: (request: ODataRequest<any>) => Observable<any>;
     }): void;

package/lib/types.d.ts

@@ -77,7 +77,43 @@ export declare enum JsonType {
     boolean = "boolean",
     null = "null"
 }
-export interface ApiOptions {
+export interface ParserOptions {
+    version?: ODataVersion;
+    exponentialDecimals?: boolean;
+    metadata?: ODataMetadataType;
+    ieee754Compatible?: boolean;
+    streaming?: boolean;
+    stringAsEnum?: boolean;
+    deleteRefBy?: 'path' | 'id';
+    nonParenthesisForEmptyParameterFunction?: boolean;
+}
+export interface ResponseOptions extends ParserOptions {
+    cacheability?: CacheCacheability;
+    maxAge?: number;
+}
+export interface StructuredTypeFieldOptions extends ParserOptions {
+    field: ODataStructuredTypeFieldConfig;
+}
+export interface Parser<T> {
+    deserialize(value: any, options?: ParserOptions | StructuredTypeFieldOptions): T;
+    serialize(value: any, options?: ParserOptions | StructuredTypeFieldOptions): any;
+    encode(value: any, options?: ParserOptions | StructuredTypeFieldOptions): any;
+}
+export interface FieldParser<T> extends Parser<T> {
+    nullable?: boolean;
+    default?: any;
+    maxLength?: number;
+    precision?: number;
+    scale?: number | 'variable';
+}
+export declare const NONE_PARSER: Parser<any>;
+export interface ODataCache {
+    put<T>(key: string, payload: T, ...opts: any[]): void;
+    get<T>(key: string, ...opts: any[]): T | undefined;
+    handleRequest(req: any, res$: Observable<any>): Observable<any>;
+    flush(): void;
+}
+export interface ODataApiConfigOptions {
     version?: ODataVersion;
     params?: {
         [param: string]: string | string[];
@@ -111,57 +147,23 @@ export interface ApiOptions {
     jsonBatchFormat?: boolean;
     relativeUrls?: boolean;
 }
-export interface ParserOptions {
-    version?: ODataVersion;
-    exponentialDecimals?: boolean;
-    metadata?: ODataMetadataType;
-    ieee754Compatible?: boolean;
-    streaming?: boolean;
-    stringAsEnum?: boolean;
-    deleteRefBy?: 'path' | 'id';
-    nonParenthesisForEmptyParameterFunction?: boolean;
-}
-export interface ResponseOptions extends ParserOptions {
-    cacheability?: CacheCacheability;
-    maxAge?: number;
-}
-export interface StructuredTypeFieldOptions extends ParserOptions {
-    field: StructuredTypeFieldConfig;
-}
-export interface Parser<T> {
-    deserialize(value: any, options?: ParserOptions | StructuredTypeFieldOptions): T;
-    serialize(value: any, options?: ParserOptions | StructuredTypeFieldOptions): any;
-    encode(value: any, options?: ParserOptions | StructuredTypeFieldOptions): any;
-}
-export interface FieldParser<T> extends Parser<T> {
-    nullable?: boolean;
-    default?: any;
-    maxLength?: number;
-    precision?: number;
-    scale?: number | 'variable';
-}
-export declare const NONE_PARSER: Parser<any>;
-export interface Cache {
-    put<T>(key: string, payload: T, ...opts: any[]): void;
-    get<T>(key: string, ...opts: any[]): T | undefined;
-}
-export type ApiConfig = {
+export type ODataApiConfig = {
     serviceRootUrl: string;
     metadataUrl?: string;
     name?: string;
     version?: ODataVersion;
     default?: boolean;
     creation?: Date;
-    cache?: Cache;
+    cache?: ODataCache;
     errorHandler?: (error: any, caught: Observable<any>) => Observable<never>;
-    options?: ApiOptions;
+    options?: ODataApiConfigOptions;
     parsers?: {
         [type: string]: Parser<any>;
     };
-    schemas?: SchemaConfig[];
-    references?: ReferenceConfig[];
+    schemas?: ODataSchemaConfig[];
+    references?: ODataReferenceConfig[];
 };
-export type AnnotationConfig = {
+export type ODataAnnotationConfig = {
     term: string;
     string?: string;
     bool?: boolean;
@@ -169,48 +171,48 @@ export type AnnotationConfig = {
     permissions?: string[];
     properties?: string[];
 };
-export type ReferenceConfig = {
+export type ODataReferenceConfig = {
     uri: string;
     includes?: string;
-    annotations?: AnnotationConfig[];
-    enums?: EnumTypeConfig[];
-    entities?: StructuredTypeConfig[];
-    callables?: CallableConfig[];
-    containers?: EntityContainerConfig[];
+    annotations?: ODataAnnotationConfig[];
+    enums?: ODataEnumTypeConfig[];
+    entities?: ODataStructuredTypeConfig[];
+    callables?: ODataCallableConfig[];
+    containers?: ODataEntityContainerConfig[];
 };
-export type SchemaConfig = {
+export type ODataSchemaConfig = {
     namespace: string;
     alias?: string;
-    annotations?: AnnotationConfig[];
-    enums?: EnumTypeConfig[];
-    entities?: StructuredTypeConfig[];
-    callables?: CallableConfig[];
-    containers?: EntityContainerConfig[];
+    annotations?: ODataAnnotationConfig[];
+    enums?: ODataEnumTypeConfig[];
+    entities?: ODataStructuredTypeConfig[];
+    callables?: ODataCallableConfig[];
+    containers?: ODataEntityContainerConfig[];
 };
-export type EntityContainerConfig = {
+export type ODataEntityContainerConfig = {
     name: string;
-    annotations?: AnnotationConfig[];
-    entitySets?: EntitySetConfig[];
-    singletons?: SingletonConfig[];
+    annotations?: ODataAnnotationConfig[];
+    entitySets?: ODataEntitySetConfig[];
+    singletons?: ODataSingletonConfig[];
 };
-export type EnumTypeFieldConfig = {
+export type ODataEnumTypeFieldConfig = {
     value: number;
-    annotations?: AnnotationConfig[];
+    annotations?: ODataAnnotationConfig[];
 };
-export type EnumTypeConfig = {
+export type ODataEnumTypeConfig = {
     name: string;
     flags?: boolean;
-    annotations?: AnnotationConfig[];
+    annotations?: ODataAnnotationConfig[];
     members: {
         [name: string]: number;
     } | {
         [value: number]: string;
     };
     fields: {
-        [member: string]: EnumTypeFieldConfig;
+        [member: string]: ODataEnumTypeFieldConfig;
     };
 };
-export type StructuredTypeFieldConfig = {
+export type ODataStructuredTypeFieldConfig = {
     type: string;
     default?: any;
     maxLength?: number;
@@ -219,7 +221,7 @@ export type StructuredTypeFieldConfig = {
     nullable?: boolean;
     navigation?: boolean;
     precision?: number;
-    annotations?: AnnotationConfig[];
+    annotations?: ODataAnnotationConfig[];
     scale?: number | 'variable';
     referentials?: {
         property: string;
@@ -228,7 +230,7 @@ export type StructuredTypeFieldConfig = {
     referential?: string;
     referenced?: string;
 };
-export type StructuredTypeConfig = {
+export type ODataStructuredTypeConfig = {
     name: string;
     base?: string;
     open?: boolean;
@@ -238,46 +240,46 @@ export type StructuredTypeConfig = {
     collection?: {
         new (...params: any[]): any;
     };
-    annotations?: AnnotationConfig[];
+    annotations?: ODataAnnotationConfig[];
     keys?: {
         name: string;
         alias?: string;
     }[];
     fields?: {
-        [name: string]: StructuredTypeFieldConfig;
+        [name: string]: ODataStructuredTypeFieldConfig;
     };
 };
-export type ParameterConfig = {
+export type ODataParameterConfig = {
     type: string;
     nullable?: boolean;
     collection?: boolean;
 };
-export type CallableConfig = {
+export type ODataCallableConfig = {
     name: string;
     entitySetPath?: string;
     bound?: boolean;
     composable?: boolean;
     parameters?: {
-        [name: string]: ParameterConfig;
+        [name: string]: ODataParameterConfig;
     };
     return?: {
         type: string;
         collection?: boolean;
     };
 };
-export type EntitySetConfig = {
+export type ODataEntitySetConfig = {
     name: string;
     entityType: string;
     service: {
         new (...params: any[]): any;
     };
-    annotations?: AnnotationConfig[];
+    annotations?: ODataAnnotationConfig[];
 };
-export type SingletonConfig = {
+export type ODataSingletonConfig = {
     name: string;
     type: string;
     service: {
         new (...params: any[]): any;
     };
-    annotations?: AnnotationConfig[];
+    annotations?: ODataAnnotationConfig[];
 };

package/lib/utils/odata.d.ts

@@ -1,4 +1,4 @@
-import { CallableConfig } from '../types';
+import { ODataCallableConfig } from '../types';
 export declare const OData: {
-    mergeCallableParameters(callables: CallableConfig[]): CallableConfig[];
+    mergeCallableParameters(callables: ODataCallableConfig[]): ODataCallableConfig[];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-odata",
-  "version": "0.130.0",
+  "version": "0.131.0",
   "license": "MIT",
   "description": "Client side OData typescript library for Angular",
   "repository": {
@@ -25,8 +25,8 @@
   "homepage": "https://github.com/diegomvh/angular-odata",
   "private": false,
   "peerDependencies": {
-    "@angular/common": ">=14.0.0",
-    "@angular/core": ">=14.0.0"
+    "@angular/common": ">=16.0.0",
+    "@angular/core": ">=16.0.0"
   },
   "schematics": "./schematics/collection.json",
   "ng-add": {
@@ -44,8 +44,6 @@
     },
     ".": {
       "types": "./index.d.ts",
-      "esm2022": "./esm2022/angular-odata.mjs",
-      "esm": "./esm2022/angular-odata.mjs",
       "default": "./fesm2022/angular-odata.mjs"
     }
   }

package/schematics/apigen/files/api-config/__fileName__.ts

@@ -1,11 +1,11 @@
-import { ApiConfig, EDM_PARSERS, ODataMetadata, ODataVersion } from 'angular-odata';
+import { ODataApiConfig, EDM_PARSERS, ODataMetadata, ODataVersion } from 'angular-odata';
 import * as json from './metadata.json';
 
 export const <%= classify(name) %> = ODataMetadata.fromJson(json).toConfig({
-  serviceRootUrl: '<%= serviceRootUrl %>', 
-  metadataUrl: '<%= metadataUrl %>', 
+  serviceRootUrl: '<%= serviceRootUrl %>',
+  metadataUrl: '<%= metadataUrl %>',
   name: '<%= apiConfigName %>',
   version: '<%= version %>' as ODataVersion,
   creation: new Date('<%= creation.toISOString() %>'),
   parsers: EDM_PARSERS
-}) as ApiConfig;
+}) as ODataApiConfig;

package/esm2022/angular-odata.mjs

@@ -1,5 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './public-api';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci1vZGF0YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItb2RhdGEvc3JjL2FuZ3VsYXItb2RhdGEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==