angular-odata 0.101.0 → 0.102.6

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

@@ -5,7 +5,7 @@ import { ODataSchema } from './schema';
 export declare class ODataEnumType<E> extends ODataSchemaElement {
     parser: ODataEnumTypeParser<E>;
     members: {
-        [name: string]: number;
+        [name: string]: E;
     } | {
         [value: number]: string;
     };
@@ -15,31 +15,19 @@ export declare class ODataEnumType<E> extends ODataSchemaElement {
      * Returns the fields of the enum type.
      * @returns The fields of the enum type.
      */
-    fields(): ODataEnumTypeFieldParser[];
+    fields(value?: E): ODataEnumTypeFieldParser<E>[];
     /**
-     * Find a field by name.
-     * @param name The name of the field
-     * @returns The field with the given name
+     * 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
      */
-    findFieldByName(name: string): ODataEnumTypeFieldParser | undefined;
-    /**
-     * Find a field by value.
-     * @param value The value of the field
-     * @returns The field with the given value
-     */
-    findFieldByValue(value: number): ODataEnumTypeFieldParser | undefined;
-    /**
-     * Find a fields by flag.
-     * @param value The value of the field
-     * @returns The fields with the given flag
-     */
-    findFieldsByValue(value: number): ODataEnumTypeFieldParser[];
+    field(enu: string | E): ODataEnumTypeFieldParser<E>;
     /**
      * 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) => T): T[];
+    mapFields<T>(mapper: (field: ODataEnumTypeFieldParser<E>) => T): T[];
     /**
      * Deseialize the given value from the enum type.
      * @param value Value to deserialize

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

@@ -20,6 +20,7 @@ export declare class ODataParameterParser<T> {
     enum(): ODataEnumTypeParser<T>;
     isStructuredType(): boolean;
     structured(): ODataStructuredTypeParser<T>;
+    field<F>(name: string): import("./structured-type").ODataStructuredTypeFieldParser<F>;
 }
 export declare class ODataCallableParser<R> implements Parser<R> {
     name: string;

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

@@ -1,25 +1,25 @@
 import { EnumTypeConfig, EnumTypeFieldConfig, ParserOptions, Parser } from '../../types';
 import { ODataAnnotatable } from '../annotation';
-export declare class ODataEnumTypeFieldParser extends ODataAnnotatable {
+export declare class ODataEnumTypeFieldParser<E> extends ODataAnnotatable {
     name: string;
-    value: number;
-    constructor(name: string, field: EnumTypeFieldConfig);
+    value: E;
+    constructor(name: string, field: EnumTypeFieldConfig<E>);
     titleize(term?: string | RegExp): string;
 }
-export declare class ODataEnumTypeParser<T> extends ODataAnnotatable implements Parser<T> {
+export declare class ODataEnumTypeParser<E> extends ODataAnnotatable implements Parser<E> {
     name: string;
     namespace: string;
     alias?: string;
     flags?: boolean;
     members: {
-        [name: string]: number;
+        [name: string]: E;
     } | {
         [value: number]: string;
     };
-    fields: ODataEnumTypeFieldParser[];
+    private _fields;
     stringAsEnum?: boolean;
     parserOptions?: ParserOptions;
-    constructor(config: EnumTypeConfig<T>, namespace: string, alias?: string);
+    constructor(config: EnumTypeConfig<E>, namespace: string, alias?: string);
     /**
      * Create a nicer looking title.
      * Titleize is meant for creating pretty output.
@@ -32,9 +32,17 @@ export declare class ODataEnumTypeParser<T> extends ODataAnnotatable implements
         options: ParserOptions;
     }): void;
     isTypeOf(type: string): boolean;
-    deserialize(value: string, options?: ParserOptions): T;
-    serialize(value: T, options?: ParserOptions): string | undefined;
-    encode(value: T, options?: ParserOptions): any;
+    fields(value?: E): ODataEnumTypeFieldParser<E>[];
+    field(nameValue: string | E): ODataEnumTypeFieldParser<E>;
+    /**
+     * 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[];
+    deserialize(value: string, options?: ParserOptions): E;
+    serialize(value: E, options?: ParserOptions): string | undefined;
+    encode(value: E, options?: ParserOptions): any;
     toJsonSchema(): any;
     validate(member: string | number, { method, navigation, }?: {
         method?: 'create' | 'update' | 'modify';

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

@@ -73,6 +73,7 @@ export declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable
     enum(): ODataEnumTypeParser<T>;
     isStructuredType(): boolean;
     structured(): ODataStructuredTypeParser<T>;
+    field<F>(name: string): ODataStructuredTypeFieldParser<F>;
 }
 export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable implements Parser<T> {
     name: string;
@@ -82,8 +83,8 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
     alias?: string;
     base?: string;
     parent?: ODataStructuredTypeParser<any>;
-    keys?: ODataEntityTypeKey[];
-    fields: ODataStructuredTypeFieldParser<any>[];
+    private _keys?;
+    private _fields;
     parserOptions?: ParserOptions;
     constructor(config: StructuredTypeConfig<T>, namespace: string, alias?: string);
     /**
@@ -104,7 +105,50 @@ export declare class ODataStructuredTypeParser<T> extends ODataAnnotatable imple
         parserForType: (type: string) => Parser<any>;
         options: ParserOptions;
     }): void;
-    resolveKey(value: any): any;
+    /**
+     * Returns all fields of the structured type.
+     * @param include_navigation Include navigation properties in the result.
+     * @param include_parents Include the parent types in the result.
+     * @returns All fields of the structured type.
+     */
+    fields({ include_navigation, include_parents, }: {
+        include_parents: boolean;
+        include_navigation: boolean;
+    }): ODataStructuredTypeFieldParser<any>[];
+    /**
+     * Returns the keys of the structured type.
+     * @param include_parents Include the parent fields
+     * @returns The keys of the structured type
+     */
+    keys({ include_parents, }: {
+        include_parents: boolean;
+    }): ODataEntityTypeKey[];
+    /**
+     * Find the field parser for the given field name.
+     * @param name Name of the field
+     * @returns The field parser
+     */
+    field<F>(name: keyof T): ODataStructuredTypeFieldParser<F>;
+    /**
+     * Picks the fields from attributes.
+     * @param attrs
+     * @param include_parents Include the parent fields
+     * @param include_navigation Include the navigation fields
+     * @param include_etag Include the etag field
+     * @returns The picked fields
+     */
+    pick(attrs: {
+        [name: string]: any;
+    }, { include_parents, include_navigation, include_etag, options, }?: {
+        include_parents?: boolean;
+        include_navigation?: boolean;
+        include_etag?: boolean;
+        options?: ParserOptions;
+    }): Partial<T>;
+    resolveKey(value: any, { resolve, single, }?: {
+        resolve?: boolean;
+        single?: boolean;
+    }): any;
     defaults(): {
         [name: string]: any;
     };

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

@@ -44,7 +44,7 @@ export declare class ODataStructuredType<T> extends ODataSchemaElement {
      * @param name Name of the field
      * @returns The field parser
      */
-    findFieldByName<F>(name: keyof T): ODataStructuredTypeFieldParser<F> | undefined;
+    field<F>(name: keyof T): ODataStructuredTypeFieldParser<F>;
     /**
      * Find a parent schema of the structured type.
      * @param predicate Function for evaluate the schemas in the hierarchy.
@@ -57,24 +57,6 @@ export declare class ODataStructuredType<T> extends ODataSchemaElement {
      * @returns The schema of the field
      */
     findSchemaForField<E>(field: ODataStructuredTypeFieldParser<any>): ODataStructuredType<E>;
-    /**
-     * Returns all fields of the structured type.
-     * @param include_navigation Include navigation properties in the result.
-     * @param include_parents Include the parent types in the result.
-     * @returns All fields of the structured type.
-     */
-    fields({ include_navigation, include_parents, }: {
-        include_parents: boolean;
-        include_navigation: boolean;
-    }): ODataStructuredTypeFieldParser<any>[];
-    /**
-     * Returns the keys of the structured type.
-     * @param include_parents Include the parent fields
-     * @returns The keys of the structured type
-     */
-    keys({ include_parents, }?: {
-        include_parents?: boolean;
-    }): ODataEntityTypeKey[];
     /**
      * Picks the fields from attributes.
      * @param attrs
@@ -111,6 +93,24 @@ export declare class ODataStructuredType<T> extends ODataSchemaElement {
      * @returns Encoded value
      */
     encode(value: T, options?: ParserOptions): any;
+    /**
+     * Returns all fields of the structured type.
+     * @param include_navigation Include navigation properties in the result.
+     * @param include_parents Include the parent types in the result.
+     * @returns All fields of the structured type.
+     */
+    fields({ include_navigation, include_parents, }: {
+        include_parents: boolean;
+        include_navigation: boolean;
+    }): ODataStructuredTypeFieldParser<any>[];
+    /**
+     * Returns the keys of the structured type.
+     * @param include_parents Include the parent fields
+     * @returns The keys of the structured type
+     */
+    keys({ include_parents, }?: {
+        include_parents?: boolean;
+    }): ODataEntityTypeKey[];
     /**
      * Resolve the key of the structured type for the given value.
      * @param attrs Attributes of the value

package/lib/services/base.d.ts

@@ -1,20 +1,20 @@
 import { Observable } from 'rxjs';
 import { ODataClient } from '../client';
-import { ODataActionResource, ODataEntities, ODataEntity, ODataFunctionResource, ODataNavigationPropertyResource, ODataProperty, ODataQueryArgumentsOptions } from '../resources';
+import { ODataActionOptions, ODataActionResource, ODataEntities, ODataEntity, ODataFunctionOptions, ODataFunctionResource, ODataNavigationPropertyResource, ODataProperty, ODataQueryArgumentsOptions } from '../resources';
 export declare abstract class ODataBaseService {
     protected client: ODataClient;
     protected name: string;
     protected apiNameOrEntityType?: string | undefined;
     constructor(client: ODataClient, name: string, apiNameOrEntityType?: string | undefined);
     get api(): import("angular-odata").ODataApi;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entity', options?: ODataQueryArgumentsOptions<R>): Observable<ODataEntity<R>>;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entities', options?: ODataQueryArgumentsOptions<R>): Observable<ODataEntities<R>>;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'property', options?: ODataQueryArgumentsOptions<R>): Observable<ODataProperty<R>>;
-    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'none', options?: ODataQueryArgumentsOptions<R>): Observable<null>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entity', options?: ODataQueryArgumentsOptions<R>): Observable<ODataEntity<R>>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entities', options?: ODataQueryArgumentsOptions<R>): Observable<ODataEntities<R>>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'property', options?: ODataQueryArgumentsOptions<R>): Observable<ODataProperty<R>>;
-    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'none', options?: ODataQueryArgumentsOptions<R>): Observable<null>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entity', options?: ODataFunctionOptions<R>): Observable<ODataEntity<R>>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entities', options?: ODataFunctionOptions<R>): Observable<ODataEntities<R>>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'property', options?: ODataFunctionOptions<R>): Observable<ODataProperty<R>>;
+    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'none', options?: ODataFunctionOptions<R>): Observable<null>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entity', options?: ODataActionOptions<R>): Observable<ODataEntity<R>>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entities', options?: ODataActionOptions<R>): Observable<ODataEntities<R>>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'property', options?: ODataActionOptions<R>): Observable<ODataProperty<R>>;
+    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'none', options?: ODataActionOptions<R>): Observable<null>;
     protected fetchNavigationProperty<S>(resource: ODataNavigationPropertyResource<S>, responseType: 'entity', options?: ODataQueryArgumentsOptions<S>): Observable<ODataEntity<S>>;
     protected fetchNavigationProperty<S>(resource: ODataNavigationPropertyResource<S>, responseType: 'entities', options?: ODataQueryArgumentsOptions<S>): Observable<ODataEntities<S>>;
 }

package/lib/types.d.ts

@@ -124,21 +124,21 @@ export declare type EntityContainerConfig = {
     annotations?: AnnotationConfig[];
     entitySets?: EntitySetConfig[];
 };
-export declare type EnumTypeFieldConfig = {
-    value: number;
+export declare type EnumTypeFieldConfig<E> = {
+    value: E;
     annotations?: AnnotationConfig[];
 };
-export declare type EnumTypeConfig<T> = {
+export declare type EnumTypeConfig<E> = {
     name: string;
     flags?: boolean;
     annotations?: AnnotationConfig[];
     members: {
-        [name: string]: number;
+        [name: string]: E;
     } | {
         [value: number]: string;
     };
     fields: {
-        [member: string]: EnumTypeFieldConfig;
+        [member: string]: EnumTypeFieldConfig<E>;
     };
 };
 export declare type StructuredTypeFieldConfig = {

package/lib/utils/objects.d.ts

@@ -19,5 +19,5 @@ export declare const Objects: {
     resolveKey(key: any, { single }?: {
         single?: boolean | undefined;
     }): any;
-    clone(target: any, map?: WeakMap<object, any> | undefined): any;
+    clone(target: any, map?: WeakMap<object, any>): any;
 };

package/lib/utils/strings.d.ts

@@ -1,4 +1,4 @@
 export declare const Strings: {
-    uniqueId(prefix?: string | undefined, suffix?: string | undefined): string;
+    uniqueId(prefix?: string, suffix?: string): string;
     titleCase(text: string): string;
 };

package/lib/utils/types.d.ts

@@ -1,6 +1,5 @@
 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.101.0",
+  "version": "0.102.6",
   "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": "^13.3.0",
-    "@angular/core": "^13.3.0"
+    "@angular/common": ">=13.0.0",
+    "@angular/core": ">=13.0.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"
@@ -36,13 +36,13 @@
   "esm2020": "esm2020/angular-odata.mjs",
   "fesm2020": "fesm2020/angular-odata.mjs",
   "fesm2015": "fesm2015/angular-odata.mjs",
-  "typings": "angular-odata.d.ts",
+  "typings": "index.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./angular-odata.d.ts",
+      "types": "./index.d.ts",
       "esm2020": "./esm2020/angular-odata.mjs",
       "es2020": "./fesm2020/angular-odata.mjs",
       "es2015": "./fesm2015/angular-odata.mjs",