angular-odata 0.122.0 → 0.124.0

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

@@ -1,136 +1,138 @@
+import { Parser } from '../../../types';
 import type { QueryCustomType } from '../builder';
+export type Normalize = 'all' | 'right' | 'left' | 'none';
 export interface Renderable {
-    render({ aliases, escape, prefix, }: {
+    render({ aliases, escape, prefix, parser, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
+        parser?: Parser<any>;
     }): string;
     toString(): string;
     toJSON(): any;
     clone(): any;
 }
-export declare class Field<T extends object> implements ProxyHandler<T> {
-    name: string;
-    constructor(name?: string);
-    static factory<T extends object>(name?: string): T;
-    get(target: T, key: string | symbol): any;
-    has(target: T, key: string): any;
-}
-export declare function render(value: any, { aliases, normalize, escape, prefix, }?: {
+export declare const FieldFactory: <T extends object>(names?: string[]) => any;
+export declare function render(value: any, { aliases, normalize, escape, prefix, parser, }?: {
     aliases?: QueryCustomType[];
     normalize?: boolean;
     escape?: boolean;
     prefix?: string;
+    parser?: Parser<any>;
 }): string | number | boolean | null;
+export declare function resolve(values: any, parser?: Parser<any>): any;
+export declare function encode(values: any, parser?: Parser<any>): any;
 export declare class Function<T> implements Renderable {
     protected name: string;
     protected values: any[];
-    protected normalize: boolean;
+    protected normalize: Normalize;
     protected escape: boolean;
-    constructor(name: string, values: any[], normalize?: boolean, escape?: boolean);
+    constructor(name: string, values: any[], normalize: Normalize, escape?: boolean);
     get [Symbol.toStringTag](): string;
     toJSON(): {
         $type: string;
         name: string;
         values: any[];
-        normalize: boolean;
+        normalize: Normalize;
     };
-    render({ aliases, escape, prefix, }: {
+    render({ aliases, escape, prefix, parser, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
+        parser?: Parser<T>;
     }): string;
     clone(): Function<T>;
 }
 export declare class StringAndCollectionFunctions<T> {
-    concat(field: any, value: any, normalize?: boolean): Function<T>;
-    contains(field: any, value: any, normalize?: boolean): Function<T>;
-    endsWith(field: any, value: any, normalize?: boolean): Function<T>;
-    indexOf(field: any, value: any, normalize?: boolean): Function<T>;
-    length(value: any, normalize?: boolean): Function<T>;
-    startsWith(field: any, value: any, normalize?: boolean): Function<T>;
-    subString(field: any, start: number, length?: number): Function<T>;
+    concat(left: any, right: any, normalize?: Normalize): Function<T>;
+    contains(left: any, right: any, normalize?: Normalize): Function<T>;
+    endsWith(left: any, right: any, normalize?: Normalize): Function<T>;
+    indexOf(left: any, right: any, normalize?: Normalize): Function<T>;
+    length(left: any, normalize?: Normalize): Function<T>;
+    startsWith(left: any, right: any, normalize?: Normalize): Function<T>;
+    subString(left: any, right: number, length?: number, normalize?: Normalize): Function<T>;
 }
 export declare class CollectionFunctions<T> {
-    hasSubset(s1: T, s2: any): Function<T>;
-    hasSubsequence(s1: T, s2: any): Function<T>;
+    hasSubset(left: T, right: any, normalize?: Normalize): Function<T>;
+    hasSubsequence(left: T, right: any, normalize?: Normalize): Function<T>;
 }
 export declare class StringFunctions<T> {
-    matchesPattern(value: T | string, pattern: string): Function<T>;
-    toLower(value: T): Function<T>;
-    toUpper(value: T): Function<T>;
-    trim(value: T): Function<T>;
+    matchesPattern(left: any | string, pattern: string, normalize?: Normalize): Function<T>;
+    toLower(left: any, normalize?: Normalize): Function<T>;
+    toUpper(left: any, normalize?: Normalize): Function<T>;
+    trim(left: any, normalize?: Normalize): Function<T>;
 }
 export declare class DateAndTimeFunctions<T> {
-    date(value: any): Function<T>;
-    day(value: any): Function<T>;
-    fractionalseconds(value: any): Function<T>;
-    hour(value: any): Function<T>;
-    maxdatetime(value: any): Function<T>;
-    mindatetime(value: any): Function<T>;
-    minute(value: any): Function<T>;
-    month(value: any): Function<T>;
+    date(left: any, normalize?: Normalize): Function<T>;
+    day(left: any, normalize?: Normalize): Function<T>;
+    fractionalseconds(left: any, normalize?: Normalize): Function<T>;
+    hour(left: any, normalize?: Normalize): Function<T>;
+    maxdatetime(left: any, normalize?: Normalize): Function<T>;
+    mindatetime(left: any, normalize?: Normalize): Function<T>;
+    minute(left: any, normalize?: Normalize): Function<T>;
+    month(left: any, normalize?: Normalize): Function<T>;
     now(): Function<T>;
-    second(value: any): Function<T>;
-    time(value: any): Function<T>;
-    totaloffsetminutes(value: any): Function<T>;
-    totalseconds(value: any): Function<T>;
-    year(value: any): Function<T>;
+    second(left: any, normalize?: Normalize): Function<T>;
+    time(left: any, normalize?: Normalize): Function<T>;
+    totaloffsetminutes(left: any, normalize?: Normalize): Function<T>;
+    totalseconds(left: any, normalize?: Normalize): Function<T>;
+    year(left: any, normalize?: Normalize): Function<T>;
 }
 export declare class ArithmeticFunctions<T> {
-    ceiling(value: T | string): Function<T>;
-    floor(value: T | string): Function<T>;
-    round(value: T | string): Function<T>;
+    ceiling(left: T | string, normalize?: Normalize): Function<T>;
+    floor(left: T | string, normalize?: Normalize): Function<T>;
+    round(left: T | string, normalize?: Normalize): Function<T>;
 }
 export declare class TypeFunctions<T> {
-    cast(value: T | string, type?: string): Function<T>;
-    isof(value: T | string, type?: string): Function<T>;
+    cast(left: T | string, right?: string, normalize?: Normalize): Function<T>;
+    isof(left: T | string, right?: string, normalize?: Normalize): Function<T>;
 }
 export declare class GeoFunctions<T> {
-    geoDistance(value: T, point: string, normalize?: boolean): Function<T>;
-    geoIntersects(value: T, polygon: string, normalize?: boolean): Function<T>;
-    geoLength(line: T, normalize?: boolean): Function<T>;
+    geoDistance(left: T, right: string, normalize?: Normalize): Function<T>;
+    geoIntersects(left: T, right: string, normalize?: Normalize): Function<T>;
+    geoLength(left: T, normalize?: Normalize): Function<T>;
 }
 export declare class ConditionalFunctions<T> {
-    case(condition: T | string, value: any): Function<T>;
+    case(left: T | string, right: any, normalize?: Normalize): Function<T>;
 }
 export declare class Operator<T> implements Renderable {
     protected op: string;
     protected values: any[];
-    protected normalize: boolean;
-    constructor(op: string, values: any[], normalize?: boolean);
+    protected normalize: Normalize;
+    constructor(op: string, values: any[], normalize: Normalize);
     get [Symbol.toStringTag](): string;
     toJSON(): {
         $type: string;
         op: string;
         values: any[];
-        normalize: boolean;
+        normalize: Normalize;
     };
-    render({ aliases, escape, prefix, }: {
+    render({ aliases, escape, prefix, parser, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
+        parser?: Parser<T>;
     }): string;
     clone(): Operator<unknown>;
 }
 export declare class LogicalOperators<T> {
-    eq(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    ne(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    gt(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    ge(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    lt(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    le(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    not(value: any, normalize?: boolean): Operator<T>;
-    has(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    in(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    eq(left: any, right: any, normalize?: Normalize): Operator<unknown>;
+    ne(left: any, right: any, normalize?: Normalize): Operator<unknown>;
+    gt(left: any, right: any, normalize?: Normalize): Operator<unknown>;
+    ge(left: any, right: any, normalize?: Normalize): Operator<unknown>;
+    lt(left: any, right: any, normalize?: Normalize): Operator<unknown>;
+    le(left: any, right: any, normalize?: Normalize): Operator<unknown>;
+    not(left: any, normalize?: Normalize): Operator<T>;
+    has(left: any, right: any, normalize?: Normalize): Operator<unknown>;
+    in(left: any, right: any, normalize?: Normalize): Operator<unknown>;
 }
 export declare class ArithmeticOperators<T> {
-    add(left: any, right: any, normalize?: boolean): Operator<T>;
-    sub(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    mul(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    div(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    mod(left: any, right: any, normalize?: boolean): Operator<unknown>;
-    neg(value: any, normalize?: boolean): Operator<unknown>;
+    add(left: any, right: any, normalize?: Normalize): Operator<T>;
+    sub(left: any, right: any, normalize?: Normalize): Operator<unknown>;
+    mul(left: any, right: any, normalize?: Normalize): Operator<unknown>;
+    div(left: any, right: any, normalize?: Normalize): Operator<unknown>;
+    mod(left: any, right: any, normalize?: Normalize): Operator<unknown>;
+    neg(value: any, normalize?: Normalize): Operator<unknown>;
 }
 export declare class Grouping<T> implements Renderable {
     protected group: Renderable;
@@ -140,10 +142,11 @@ export declare class Grouping<T> implements Renderable {
         $type: string;
         group: any;
     };
-    render({ aliases, escape, prefix, }: {
+    render({ aliases, escape, prefix, parser, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
+        parser?: Parser<T>;
     }): string;
     clone(): Grouping<unknown>;
 }
@@ -159,16 +162,17 @@ export declare class Lambda<T> implements Renderable {
         values: any[];
         alias: string | undefined;
     };
-    render({ aliases, escape, prefix, }: {
+    render({ aliases, escape, prefix, parser, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
+        parser?: Parser<T>;
     }): string;
     clone(): Lambda<unknown>;
 }
 export declare class LambdaOperators<T> {
-    any(field: T, value: any, alias?: string): Lambda<unknown>;
-    all(field: T, value: any, alias?: string): Lambda<unknown>;
+    any(left: T, right: any, alias?: string): Lambda<unknown>;
+    all(left: T, right: any, alias?: string): Lambda<unknown>;
 }
 export declare class ODataOperators<T> {
 }

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

@@ -126,7 +126,7 @@ export declare class ODataQueryOptionsHandler<T> {
      * If opts is given then set te value as new value for $select.
      * @param opts Select<T> value or builder function for SelectExpression<T>
      */
-    select(opts: SelectExpressionBuilder<T>): SelectExpression<T>;
+    select(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
     select(opts: Select<T>): ODataQueryOptionHandler<T>;
     select(): ODataQueryOptionHandler<T>;
     /**
@@ -134,7 +134,7 @@ export declare class ODataQueryOptionsHandler<T> {
      * If opts is given then set te value as new value for $expand.
      * @param opts Expand<T> value or builder function for ExpandExpression<T>
      */
-    expand(opts: ExpandExpressionBuilder<T>): ExpandExpression<T>;
+    expand(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>): ExpandExpression<T>;
     expand(opts: Expand<T>): ODataQueryOptionHandler<T>;
     expand(): ODataQueryOptionHandler<T>;
     /**

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

@@ -1,10 +1,10 @@
-import { QueryOption } from '../../types';
+import { Parser, QueryOption } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
 import { ComputeExpression, Expression, FilterExpression, OrderByExpression, SearchExpression } from './expressions';
 import { ExpandExpression } from './expressions/expand';
 import { SelectExpression } from './expressions/select';
 import { ODataQueryOptionHandler } from './handlers';
-export declare type ODataQueryArguments<T> = {
+export type ODataQueryArguments<T> = {
     [QueryOption.select]?: Select<T> | SelectExpression<T> | null;
     [QueryOption.expand]?: Expand<T> | ExpandExpression<T> | null;
     [QueryOption.compute]?: string | ComputeExpression<T> | null;
@@ -24,10 +24,19 @@ export declare class ODataQueryOptions<T> {
     constructor(values?: Map<QueryOption, any> | {
         [name: string]: any;
     });
-    pathAndParams(escape?: boolean): [string, {
-        [name: string]: any;
-    }];
-    toString(): string;
+    pathAndParams({ escape, parser, }?: {
+        escape?: boolean;
+        parser?: Parser<T>;
+    }): [
+        string,
+        {
+            [name: string]: any;
+        }
+    ];
+    toString({ escape, parser, }?: {
+        escape?: boolean;
+        parser?: Parser<T>;
+    }): string;
     toJSON(): {};
     toQueryArguments(): ODataQueryArguments<T>;
     clone<O>(): ODataQueryOptions<O>;

package/lib/resources/resource.d.ts

@@ -8,7 +8,7 @@ import { ODataPathSegments, ODataPathSegmentsHandler } from './path';
 import { ODataQueryOptions, ODataQueryOptionsHandler, QueryCustomType } from './query';
 import { ODataEntitiesAnnotations, ODataEntityAnnotations } from './responses/index';
 import { ODataOptions } from './types';
-export declare type EntityKey<T> = {
+export type EntityKey<T> = {
     readonly [P in keyof T]?: T[P];
 } | QueryCustomType | string | number;
 export declare class ODataResource<T> {
@@ -56,7 +56,7 @@ export declare class ODataResource<T> {
         [name: string]: any;
     }];
     endpointUrl(params?: boolean): string;
-    toString(): string;
+    toString(escape?: boolean): string;
     clone(): ODataResource<T>;
     private __parser;
     deserialize(value: any, options?: ParserOptions): any;

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

@@ -1,13 +1,13 @@
 import { ODataEntitiesAnnotations, ODataEntityAnnotations, ODataPropertyAnnotations } from './annotations';
-export declare type ODataEntity<T> = {
+export type ODataEntity<T> = {
     entity: T | null;
     annots: ODataEntityAnnotations<T>;
 };
-export declare type ODataEntities<T> = {
+export type ODataEntities<T> = {
     entities: T[] | null;
     annots: ODataEntitiesAnnotations<T>;
 };
-export declare type ODataProperty<T> = {
+export type ODataProperty<T> = {
     property: T | null;
     annots: ODataPropertyAnnotations<T>;
 };

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

@@ -1,7 +1,7 @@
 import { HttpContext, HttpHeaders, HttpParams } from '@angular/common/http';
 import { FetchPolicy } from '../../types';
 import { ODataQueryArguments } from '../query';
-export declare type ODataOptions = {
+export type ODataOptions = {
     etag?: string;
     context?: HttpContext;
     headers?: HttpHeaders | {
@@ -14,18 +14,18 @@ export declare type ODataOptions = {
     withCredentials?: boolean;
     fetchPolicy?: FetchPolicy;
 };
-export declare type ODataEntityOptions = ODataOptions & {
+export type ODataEntityOptions = ODataOptions & {
     responseType?: 'entity';
 };
-export declare type ODataEntitiesOptions = ODataOptions & {
+export type ODataEntitiesOptions = ODataOptions & {
     responseType?: 'entities';
     withCount?: boolean;
 };
-export declare type ODataPropertyOptions = ODataOptions & {
+export type ODataPropertyOptions = ODataOptions & {
     responseType?: 'property';
 };
-export declare type ODataQueryArgumentsOptions<T> = ODataOptions & ODataQueryArguments<T>;
-export declare type ODataActionOptions<T> = ODataQueryArgumentsOptions<T>;
-export declare type ODataFunctionOptions<T> = ODataQueryArgumentsOptions<T> & {
+export type ODataQueryArgumentsOptions<T> = ODataOptions & ODataQueryArguments<T>;
+export type ODataActionOptions<T> = ODataQueryArgumentsOptions<T>;
+export type ODataFunctionOptions<T> = ODataQueryArgumentsOptions<T> & {
     alias?: boolean;
 };

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

@@ -1,17 +1,17 @@
 import { ParserOptions, Parser, StructuredTypeConfig, StructuredTypeFieldConfig, FieldParser, EdmType } from '../../types';
 import { ODataAnnotatable } from '../annotation';
 import { ODataEnumTypeParser } from './enum-type';
-declare type JsonSchemaSelect<T> = Array<keyof T>;
-declare type JsonSchemaCustom<T> = {
+type JsonSchemaSelect<T> = Array<keyof T>;
+type JsonSchemaCustom<T> = {
     [P in keyof T]?: (schema: any, field: ODataStructuredTypeFieldParser<T[P]>) => any;
 };
-declare type JsonSchemaExpand<T> = {
+type JsonSchemaExpand<T> = {
     [P in keyof T]?: JsonSchemaOptions<T[P]>;
 };
-declare type JsonSchemaRequired<T> = {
+type JsonSchemaRequired<T> = {
     [P in keyof T]?: boolean;
 };
-export declare type JsonSchemaOptions<T> = {
+export type JsonSchemaOptions<T> = {
     select?: JsonSchemaSelect<T>;
     custom?: JsonSchemaCustom<T>;
     expand?: JsonSchemaExpand<T>;
@@ -98,6 +98,7 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
     titleize(term?: string | RegExp): string;
     isTypeOf(type: string): boolean;
     isSubtypeOf(type: string): boolean;
+    isOpenType(): boolean;
     findChildParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): ODataStructuredTypeParser<any> | undefined;
     childParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): Parser<any>;
     deserialize(value: any, options?: ParserOptions): T;
@@ -126,6 +127,8 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
     keys({ include_parents, }: {
         include_parents: boolean;
     }): ODataEntityTypeKey[];
+    isEntityType(): boolean;
+    isComplexType(): boolean;
     /**
      * Find the field parser for the given field name.
      * @param name Name of the field

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

@@ -6,7 +6,6 @@ import { JsonSchemaOptions, ODataEntityTypeKey, ODataStructuredTypeFieldParser,
 import { ODataSchema } from './schema';
 export declare class ODataStructuredType<T> extends ODataSchemaElement {
     base?: string;
-    open: boolean;
     parent?: ODataStructuredType<any>;
     children: ODataStructuredType<any>[];
     model?: typeof ODataModel;
@@ -41,6 +40,8 @@ export declare class ODataStructuredType<T> extends ODataSchemaElement {
      */
     isCompoundKey(): boolean;
     isOpenType(): boolean;
+    isEntityType(): boolean;
+    isComplexType(): boolean;
     /**
      * Find the field parser for the given field name.
      * @param name Name of the field

package/lib/types.d.ts

@@ -1,8 +1,8 @@
 import { Observable } from 'rxjs';
-export declare type ODataVersion = '2.0' | '3.0' | '4.0';
-export declare type FetchPolicy = 'cache-first' | 'cache-and-network' | 'network-only' | 'no-cache' | 'cache-only';
-export declare type ODataMetadataType = 'minimal' | 'full' | 'none';
-export declare type CacheCacheability = 'public' | 'private' | 'no-cache' | 'no-store';
+export type ODataVersion = '2.0' | '3.0' | '4.0';
+export type FetchPolicy = 'cache-first' | 'cache-and-network' | 'network-only' | 'no-cache' | 'cache-only';
+export type ODataMetadataType = 'minimal' | 'full' | 'none';
+export type CacheCacheability = 'public' | 'private' | 'no-cache' | 'no-store';
 export declare enum PathSegment {
     batch = "batch",
     metadata = "metadata",
@@ -134,7 +134,7 @@ export interface Cache {
     put<T>(key: string, payload: T, ...opts: any[]): void;
     get<T>(key: string, ...opts: any[]): T | undefined;
 }
-export declare type ApiConfig = {
+export type ApiConfig = {
     serviceRootUrl: string;
     name?: string;
     version?: ODataVersion;
@@ -148,7 +148,7 @@ export declare type ApiConfig = {
     };
     schemas?: SchemaConfig[];
 };
-export declare type AnnotationConfig = {
+export type AnnotationConfig = {
     term: string;
     string?: string;
     bool?: boolean;
@@ -156,7 +156,7 @@ export declare type AnnotationConfig = {
     permissions?: string[];
     properties?: string[];
 };
-export declare type SchemaConfig = {
+export type SchemaConfig = {
     namespace: string;
     alias?: string;
     annotations?: AnnotationConfig[];
@@ -165,16 +165,16 @@ export declare type SchemaConfig = {
     callables?: CallableConfig[];
     containers?: EntityContainerConfig[];
 };
-export declare type EntityContainerConfig = {
+export type EntityContainerConfig = {
     name: string;
     annotations?: AnnotationConfig[];
     entitySets?: EntitySetConfig[];
 };
-export declare type EnumTypeFieldConfig<E> = {
+export type EnumTypeFieldConfig<E> = {
     value: E;
     annotations?: AnnotationConfig[];
 };
-export declare type EnumTypeConfig<E> = {
+export type EnumTypeConfig<E> = {
     name: string;
     flags?: boolean;
     annotations?: AnnotationConfig[];
@@ -187,7 +187,7 @@ export declare type EnumTypeConfig<E> = {
         [member: string]: EnumTypeFieldConfig<E>;
     };
 };
-export declare type StructuredTypeFieldConfig = {
+export type StructuredTypeFieldConfig = {
     type: string;
     default?: any;
     maxLength?: number;
@@ -205,7 +205,7 @@ export declare type StructuredTypeFieldConfig = {
     referential?: string;
     referenced?: string;
 };
-export declare type StructuredTypeConfig<T> = {
+export type StructuredTypeConfig<T> = {
     name: string;
     base?: string;
     open?: boolean;
@@ -224,12 +224,12 @@ export declare type StructuredTypeConfig<T> = {
         [P in keyof T]?: StructuredTypeFieldConfig;
     };
 };
-export declare type Parameter = {
+export type Parameter = {
     type: string;
     nullable?: boolean;
     collection?: boolean;
 };
-export declare type CallableConfig = {
+export type CallableConfig = {
     name: string;
     entitySetPath?: string;
     bound?: boolean;
@@ -242,7 +242,7 @@ export declare type CallableConfig = {
         collection?: boolean;
     };
 };
-export declare type EntitySetConfig = {
+export type EntitySetConfig = {
     name: string;
     entityType: string;
     service: {

package/lib/utils/durations.d.ts

@@ -1,4 +1,4 @@
-export declare type Duration = {
+export type Duration = {
     sign?: 1 | -1;
     years?: number;
     months?: number;

package/lib/utils/enums.d.ts

@@ -17,4 +17,7 @@ export declare const Enums: {
     toNames<E_5 extends {
         [key: string]: any;
     }>(enums: E_5, value: any): string[];
+    toFlags<E_6 extends {
+        [key: string]: any;
+    }>(enums: E_6, value: any): string[];
 };

package/lib/utils/types.d.ts

@@ -1,5 +1,6 @@
 export declare const Types: {
     rawType(value: any): string;
+    isObject(value: any): boolean;
     isPlainObject(value: any): boolean;
     isFunction(value: any): boolean;
     isArray(value: any): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-odata",
-  "version": "0.122.0",
+  "version": "0.124.0",
   "license": "MIT",
   "description": "Client side OData typescript library for Angular",
   "repository": {
@@ -25,17 +25,14 @@
   "homepage": "https://github.com/diegomvh/angular-odata",
   "private": false,
   "peerDependencies": {
-    "@angular/common": ">=13.0.0",
-    "@angular/core": ">=13.0.0"
+    "@angular/common": ">=14.0.0",
+    "@angular/core": ">=14.0.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"
   },
-  "module": "fesm2015/angular-odata.mjs",
-  "es2020": "fesm2020/angular-odata.mjs",
-  "esm2020": "esm2020/angular-odata.mjs",
-  "fesm2020": "fesm2020/angular-odata.mjs",
-  "fesm2015": "fesm2015/angular-odata.mjs",
+  "sideEffects": false,
+  "module": "fesm2022/angular-odata.mjs",
   "typings": "index.d.ts",
   "exports": {
     "./package.json": {
@@ -43,12 +40,9 @@
     },
     ".": {
       "types": "./index.d.ts",
-      "esm2020": "./esm2020/angular-odata.mjs",
-      "es2020": "./fesm2020/angular-odata.mjs",
-      "es2015": "./fesm2015/angular-odata.mjs",
-      "node": "./fesm2015/angular-odata.mjs",
-      "default": "./fesm2020/angular-odata.mjs"
+      "esm2022": "./esm2022/angular-odata.mjs",
+      "esm": "./esm2022/angular-odata.mjs",
+      "default": "./fesm2022/angular-odata.mjs"
     }
-  },
-  "sideEffects": false
+  }
 }