angular-odata 0.100.1 → 0.102.5

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

@@ -17,6 +17,9 @@ export declare class SearchTerm implements Renderable {
     }): string;
     clone(): SearchTerm;
 }
+export declare type SearchExpressionBuilder<T> = {
+    e: (connector?: SearchConnector) => SearchExpression<T>;
+};
 export declare class SearchExpression<T> extends Expression<T> {
     private _connector;
     private _negated;
@@ -25,10 +28,8 @@ export declare class SearchExpression<T> extends Expression<T> {
         connector?: SearchConnector;
         negated?: boolean;
     });
-    static e<T>(connector?: SearchConnector): SearchExpression<T>;
-    static search<T extends object>(opts: (builder: {
-        e: (connector?: SearchConnector) => SearchExpression<T>;
-    }, current?: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
+    static expression<T>(connector?: SearchConnector): SearchExpression<T>;
+    static search<T extends object>(opts: (builder: SearchExpressionBuilder<T>, current?: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
     private _add;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;

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

@@ -1,16 +1,17 @@
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
+export declare type SelectExpressionBuilder<T> = {
+    t: T;
+    e: () => SelectExpression<T>;
+};
 export declare class SelectExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    static e<T>(): SelectExpression<T>;
-    static s<T extends object>(): T;
-    static select<T extends object>(builder: (b: {
-        s: T;
-        e: () => SelectExpression<T>;
-    }, c?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
+    static expression<T>(): SelectExpression<T>;
+    static type<T extends object>(): T;
+    static select<T extends object>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;

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

@@ -1,34 +1,98 @@
 import { QueryOptionNames } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
-import { ComputeExpression, FilterConnector, FilterExpression, OrderByExpression, SearchConnector, SearchExpression, ODataFunctions, ODataOperators } from './expressions';
-import { ExpandExpression } from './expressions/expand';
-import { SelectExpression } from './expressions/select';
+import { ComputeExpression, ComputeExpressionBuilder, FilterExpression, FilterExpressionBuilder, OrderByExpression, OrderByExpressionBuilder, SearchExpression, SearchExpressionBuilder, ExpandExpression, ExpandExpressionBuilder, SelectExpression, SelectExpressionBuilder } from './expressions';
 import type { ODataQueryArguments, ODataQueryOptions } from './options';
 export declare class ODataQueryOptionHandler<T> {
     private o;
     private n;
     constructor(o: Map<QueryOptionNames, any>, n: QueryOptionNames);
+    /**
+     * The name of the managed odata query option.
+     */
     get name(): QueryOptionNames;
+    /**
+     * Converts the managed odata query option to a json object.
+     * @returns {any}
+     */
     toJSON(): any;
+    /**
+     * Returns a boolean indicating if the managed odata query option is empty.
+     * @returns True if the managed odata query option is empty.
+     */
     empty(): boolean;
+    /**
+     * Get or Set the value of the managed odata query option.
+     * @param v The value to set.
+     * @returns
+     */
     value(v?: any): any;
     private assertArray;
+    /**
+     * Push value to the managed odata query option.
+     * @param value Value to push
+     */
     push(value: any): void;
+    /**
+     * Remove value from the managed odata query option.
+     * @param value Value to remove
+     */
     remove(value: any): void;
+    /**
+     * Return value at index of the managed odata query option.
+     * @param index Index of the value
+     * @returns The value
+     */
     at(index: number): any;
+    some(predicate: (value: any) => boolean): boolean;
+    every(predicate: (value: any) => boolean): boolean;
+    find(predicate: (value: any) => boolean): any;
     private assertObject;
+    /**
+     * Set the value for path in the managed odata query option.
+     * @param path Path for set the value
+     * @param value Value to set
+     */
     set(path: string, value: any): void;
+    /**
+     * Get the value for path from the managed odata query option.
+     * @param path The path from get the value
+     * @param def Default if not found
+     * @returns
+     */
     get(path: string, def?: any): any;
+    /**
+     * Unset the value for path in the managed odata query option.
+     * @param path
+     */
     unset(path: string): void;
+    /**
+     * Test if the managed odata query option has the value.
+     * @param path The path fot test if the value is set
+     * @returns Boolean indicating if the value is set
+     */
     has(path: string): boolean;
+    /**
+     * Merge values from object into the managed odata query option.
+     * @param values Object to merge
+     * @returns
+     */
     assign(values: {
         [attr: string]: any;
     }): Object;
+    /**
+     * Clear the managed odata query option.
+     */
     clear(): void;
 }
 export declare class ODataQueryOptionsHandler<T> {
     protected options: ODataQueryOptions<T>;
     constructor(options: ODataQueryOptions<T>);
+    /**
+     * Create a raw odata value
+     * @param value The value to raw
+     * @returns The raw value
+     */
+    raw(value: any): import("./builder").QueryCustomType;
     /**
      * Create a new odata alias parameter
      * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_ParameterAliases
@@ -37,72 +101,133 @@ export declare class ODataQueryOptionsHandler<T> {
      * @returns The alias
      */
     alias(value: any, name?: string): import("./builder").QueryCustomType;
+    /**
+     * Create a duration odata value
+     * @param value The value to duration
+     * @returns The duration value
+     */
+    duration(value: any): import("./builder").QueryCustomType;
+    /**
+     * Create a binary odata value
+     * @param value The value to binary
+     * @returns The binary value
+     */
+    binary(value: any): import("./builder").QueryCustomType;
     /**
      * Normalize the given value to a valid odata value
      * @param value The value to normalize
      * @returns The normalized value
      */
     normalize(value: any): any;
-    select(opts: (builder: {
-        s: T;
-        e: () => SelectExpression<T>;
-    }, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
+    /**
+     * Build and return a handler for modifying the $select option.
+     * 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: Select<T>): ODataQueryOptionHandler<T>;
     select(): ODataQueryOptionHandler<T>;
-    expand(opts: (builder: {
-        s: T;
-        e: () => ExpandExpression<T>;
-    }, current?: ExpandExpression<T>) => ExpandExpression<T>): ExpandExpression<T>;
+    /**
+     * Build and return a handler for modifying the $expand option.
+     * 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: Expand<T>): ODataQueryOptionHandler<T>;
     expand(): ODataQueryOptionHandler<T>;
     /**
+     * Build and return a handler for modifying the $compute option.
+     * If opts is given then set te value as new value for $compute.
      * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptioncompute
+     * @param opts string value or builder function for ComputeExpression<T>
      */
-    compute(opts: (builder: {
-        s: T;
-        e: () => ComputeExpression<T>;
-        o: ODataOperators<T>;
-        f: ODataFunctions<T>;
-    }, current?: ComputeExpression<T>) => ComputeExpression<T>): ComputeExpression<T>;
+    compute(opts: (builder: ComputeExpressionBuilder<T>, current?: ComputeExpression<T>) => ComputeExpression<T>): ComputeExpression<T>;
     compute(opts: string): ODataQueryOptionHandler<T>;
     compute(): ODataQueryOptionHandler<T>;
     /**
+     * Build and return a handler for modifying the $format option.
+     * If opts is given then set te value as new value for $format.
      * @link https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html#sec_SystemQueryOptionformat
+     * @param opts string value for format
      */
     format(opts: string): ODataQueryOptionHandler<T>;
     format(): ODataQueryOptionHandler<T>;
+    /**
+     * Build and return a handler for modifying the $transform option.
+     * If opts is given then set te value as new value for $transform.
+     * @param opts string value for transform
+     */
     transform(opts: Transform<T>): ODataQueryOptionHandler<T>;
     transform(): ODataQueryOptionHandler<T>;
-    search(opts: (builder: {
-        e: (connector: SearchConnector) => SearchExpression<T>;
-    }, current?: SearchExpression<T>) => SearchExpression<T>): SearchExpression<T>;
+    /**
+     * Build and return a handler for modifying the $search option.
+     * If opts is given then set te value as new value for $search.
+     * @param opts string value or builder function for SearchExpression<T>
+     */
+    search(opts: (builder: SearchExpressionBuilder<T>, current?: SearchExpression<T>) => SearchExpression<T>): SearchExpression<T>;
     search(opts: string): ODataQueryOptionHandler<T>;
     search(): ODataQueryOptionHandler<T>;
-    filter(opts: (builder: {
-        s: T;
-        e: (connector?: FilterConnector) => FilterExpression<T>;
-        o: ODataOperators<T>;
-        f: ODataFunctions<T>;
-    }, current?: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
+    /**
+     * Build and return a handler for modifying the $filter option.
+     * If opts is given then set te value as new value for $filter.
+     * @param opts Filter<T> value or builder function for FilterExpression<T>
+     */
+    filter(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
     filter(opts: Filter<T>): ODataQueryOptionHandler<T>;
     filter(): ODataQueryOptionHandler<T>;
-    orderBy(opts: (builder: {
-        s: T;
-        e: () => OrderByExpression<T>;
-    }, current?: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
+    /**
+     * Build and return a handler for modifying the $orderby option.
+     * If opts is given then set te value as new value for $orderby.
+     * @param opts OrderBy<T> value or builder function for OrderByExpression<T>
+     */
+    orderBy(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
     orderBy(opts: OrderBy<T>): ODataQueryOptionHandler<T>;
     orderBy(): ODataQueryOptionHandler<T>;
+    /**
+     * Build and return a handler for modifying the $top option.
+     * If opts is given then set te value as new value for $top.
+     * @param opts number value
+     */
     top(opts: number): ODataQueryOptionHandler<T>;
     top(): ODataQueryOptionHandler<T>;
+    /**
+     * Build and return a handler for modifying the $skip option.
+     * If opts is given then set te value as new value for $skip.
+     * @param opts number value
+     */
     skip(opts: number): ODataQueryOptionHandler<T>;
     skip(): ODataQueryOptionHandler<T>;
+    /**
+     * Build and return a handler for modifying the $skiptoken option.
+     * If opts is given then set te value as new value for $skiptoken.
+     * @param opts string value
+     */
     skiptoken(opts: string): ODataQueryOptionHandler<T>;
     skiptoken(): ODataQueryOptionHandler<T>;
+    /**
+     * Shortcut for set $top, $skip, $skiptoken.
+     * @param param0 skip or top or skiptoken
+     */
     paging({ skip, skiptoken, top, }?: {
-        skip?: number;
-        skiptoken?: string;
-        top?: number;
+        skip?: number | null;
+        skiptoken?: string | null;
+        top?: number | null;
     }): void;
+    /**
+     * Shortcut for clear pagination by unset $top, $skip, $skiptoken.
+     */
     clearPaging(): void;
+    /**
+     * Shortcut for clear query.
+     */
+    clear(): void;
+    /**
+     * Retrun the query.
+     */
+    query(): ODataQueryArguments<T>;
+    /**
+     * Apply the given query options to the current query.
+     * @param query The query to be applied.
+     */
     apply(query: ODataQueryArguments<T>): void;
 }

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

@@ -1,21 +1,23 @@
 import { QueryOptionNames } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
-import { Expression, FilterExpression, OrderByExpression, SearchExpression } from './expressions';
+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> = {
-    [QueryOptionNames.select]?: Select<T> | SelectExpression<T>;
-    [QueryOptionNames.filter]?: Filter<T> | FilterExpression<T>;
-    [QueryOptionNames.search]?: string | SearchExpression<T>;
-    [QueryOptionNames.compute]?: string;
-    [QueryOptionNames.transform]?: Transform<T>;
-    [QueryOptionNames.orderBy]?: OrderBy<T> | OrderByExpression<T>;
-    [QueryOptionNames.top]?: number;
-    [QueryOptionNames.skip]?: number;
-    [QueryOptionNames.skiptoken]?: string;
-    [QueryOptionNames.expand]?: Expand<T> | ExpandExpression<T>;
-    [QueryOptionNames.format]?: string;
+    [QueryOptionNames.select]?: Select<T> | SelectExpression<T> | null;
+    [QueryOptionNames.expand]?: Expand<T> | ExpandExpression<T> | null;
+    [QueryOptionNames.compute]?: string | ComputeExpression<T> | null;
+    [QueryOptionNames.filter]?: Filter<T> | FilterExpression<T> | null;
+    [QueryOptionNames.search]?: string | SearchExpression<T> | null;
+    [QueryOptionNames.transform]?: Transform<T> | null;
+    [QueryOptionNames.orderBy]?: OrderBy<T> | OrderByExpression<T> | null;
+    [QueryOptionNames.top]?: number | null;
+    [QueryOptionNames.skip]?: number | null;
+    [QueryOptionNames.skiptoken]?: string | null;
+    [QueryOptionNames.format]?: string | null;
+    [QueryOptionNames.levels]?: number | 'max' | null;
+    [QueryOptionNames.count]?: boolean | null;
 };
 export declare class ODataQueryOptions<T> {
     values: Map<QueryOptionNames, any>;

package/lib/resources/request.d.ts

@@ -16,7 +16,6 @@ export declare class ODataRequest<T> {
     private readonly _headers;
     private readonly _params;
     private readonly _path;
-    private readonly _queryBody;
     constructor(init: {
         method: string;
         api: ODataApi;
@@ -45,6 +44,8 @@ export declare class ODataRequest<T> {
     get pathWithParams(): string;
     get url(): string;
     get urlWithParams(): string;
+    get cacheKey(): string;
+    isQueryBody(): boolean;
     isBatch(): boolean;
     isFetch(): boolean;
     isMutate(): boolean;

package/lib/resources/resource.d.ts

@@ -3,7 +3,7 @@ import { ODataApi } from '../api';
 import { ODataCollection, ODataModel } from '../models';
 import { ODataStructuredType } from '../schema';
 import { ODataSchemaElement } from '../schema/element';
-import { OptionsHelper, QueryOptionNames } from '../types';
+import { ParserOptions, QueryOptionNames } from '../types';
 import { ODataPathSegments, ODataPathSegmentsHandler } from './path';
 import { ODataQueryOptions, ODataQueryOptionsHandler, QueryCustomType } from './query';
 import { ODataEntitiesAnnotations, ODataEntityAnnotations } from './responses/index';
@@ -37,6 +37,7 @@ export declare class ODataResource<T> {
      * @returns boolean The resource has key ?
      */
     hasKey(): boolean;
+    hasEntityKey(): boolean;
     clearKey(): void | undefined;
     asModel<M extends ODataModel<T>>(entity?: Partial<T> | {
         [name: string]: any;
@@ -60,9 +61,9 @@ export declare class ODataResource<T> {
     toString(): string;
     clone(): ODataResource<T>;
     private __parser;
-    deserialize(value: any, options?: OptionsHelper): any;
-    serialize(value: any, options?: OptionsHelper): any;
-    encode(value: any, options?: OptionsHelper): any;
+    deserialize(value: any, options?: ParserOptions): any;
+    serialize(value: any, options?: ParserOptions): any;
+    encode(value: any, options?: ParserOptions): any;
     toJSON(): {
         segments: any[];
         options: {};
@@ -76,13 +77,13 @@ export declare class ODataResource<T> {
      * @param f Function context for handle the segments
      * @returns ODataActionResource
      */
-    segment(f: (q: ODataPathSegmentsHandler<T>) => void): this;
+    segment(f: (q: ODataPathSegmentsHandler<T>, s?: ODataStructuredType<T>) => void): this;
     /**
      * Handle the query options of the resource
      * Create an object handler for mutate the query options of the resource
      * @param f Function context for handle the query options
      */
-    query(f: (q: ODataQueryOptionsHandler<T>) => void): this;
+    query(f: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): this;
     static resolveKey<T>(value: any, schema?: ODataStructuredType<T>): EntityKey<T> | undefined;
     protected resolveKey(value: any): EntityKey<T> | undefined;
     protected request(method: string, options: ODataOptions & {

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

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

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

@@ -1,21 +1,16 @@
+import { HttpErrorResponse, HttpResponseBase } from '@angular/common/http';
 import { Observable, Subject } from 'rxjs';
 import { ODataApi } from '../../api';
 import { ODataRequest } from '../request';
 import { ODataResource } from '../resource';
 import { ODataResponse } from '../responses';
 import { ODataOptions } from './options';
-export declare class ODataBatchRequest<T> extends Subject<ODataResponse<T>> {
+export declare class ODataBatchRequest<T> extends Subject<HttpResponseBase> {
     request: ODataRequest<any>;
     constructor(request: ODataRequest<any>);
     toString(): string;
-    onLoad(content: string[], status: {
-        code: number;
-        message: string;
-    }): void;
-    onError(content: string[], status: {
-        code: number;
-        text: string;
-    }): void;
+    onLoad(response: HttpResponseBase): void;
+    onError(response: HttpErrorResponse): void;
 }
 /**
  * OData Batch Resource
@@ -24,6 +19,8 @@ export declare class ODataBatchRequest<T> extends Subject<ODataResponse<T>> {
 export declare class ODataBatchResource extends ODataResource<any> {
     private _requests;
     requests(): ODataRequest<any>[];
+    private _responses;
+    responses(): HttpResponseBase[] | null;
     static factory(api: ODataApi): ODataBatchResource;
     clone(): ODataBatchResource;
     private storeRequester;
@@ -34,7 +31,7 @@ export declare class ODataBatchResource extends ODataResource<any> {
      * @returns The result of execute the context
      */
     add<R>(ctx: (batch: this) => Observable<R>): Observable<R>;
-    send(options?: ODataOptions): void;
+    send(options?: ODataOptions): Observable<null | ODataResponse<string>>;
     /**
      * Execute the batch request
      * @param ctx The context for the request
@@ -44,5 +41,5 @@ export declare class ODataBatchResource extends ODataResource<any> {
     exec<R>(ctx: (batch: this) => Observable<R>, options?: ODataOptions): Observable<R>;
     body(): string;
     static buildBody(batchBoundary: string, requests: ODataBatchRequest<any>[]): string;
-    static handleResponse(requests: ODataBatchRequest<any>[], response: ODataResponse<any>): void;
+    static parseResponse(requests: ODataBatchRequest<any>[], response: ODataResponse<string>): HttpResponseBase[];
 }

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

@@ -25,6 +25,8 @@ export declare type ODataPropertyOptions = ODataOptions & {
 export declare type ODataNoneOptions = ODataOptions & {
     responseType?: 'none';
 };
-export declare type ODataQueryArgumentsOptions<T> = ODataQueryArguments<T> & {
+export declare type ODataQueryArgumentsOptions<T> = ODataOptions & ODataQueryArguments<T>;
+export declare type ODataActionOptions<T> = ODataQueryArgumentsOptions<T>;
+export declare type ODataFunctionOptions<T> = ODataQueryArgumentsOptions<T> & {
     alias?: boolean;
-} & ODataOptions;
+};

package/lib/schema/callable.d.ts

@@ -1,4 +1,4 @@
-import { CallableConfig, OptionsHelper, Parser } from '../types';
+import { CallableConfig, ParserOptions, Parser } from '../types';
 import { ODataSchemaElement } from './element';
 import { ODataCallableParser } from './parsers';
 import { ODataSchema } from './schema';
@@ -18,21 +18,21 @@ export declare class ODataCallable<R> extends ODataSchemaElement {
      * @param options Options for deserialization
      * @returns Deserialized value
      */
-    deserialize(value: any, options?: OptionsHelper): any;
+    deserialize(value: any, options?: ParserOptions): any;
     /**
      * Serialize the given value for the callable.
      * @param value Value to serialize
      * @param options Options for serialization
      * @returns Serialized value
      */
-    serialize(value: any, options?: OptionsHelper): any;
+    serialize(value: any, options?: ParserOptions): any;
     /**
      * Encode the given value for the callable.
      * @param value Value to encode
      * @param options Options for encoding
      * @returns Encoded value
      */
-    encode(value: any, options?: OptionsHelper): any;
+    encode(value: any, options?: ParserOptions): any;
     /**
      * Returns the binding parameter of the callable.
      * @returns The binding parameter of the callable.

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

@@ -1,11 +1,11 @@
-import { EnumTypeConfig, OptionsHelper } from '../types';
+import { EnumTypeConfig, ParserOptions } from '../types';
 import { ODataSchemaElement } from './element';
 import { ODataEnumTypeFieldParser, ODataEnumTypeParser } from './parsers';
 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,50 +15,38 @@ 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
      * @param options Options for deserialization
      * @returns Deserialized value
      */
-    deserialize(value: any, options?: OptionsHelper): E;
+    deserialize(value: any, options?: ParserOptions): E;
     /**
      * Serialize the given value for the enum type.
      * @param value Value to serialize
      * @param options Options for serialization
      * @returns Serialized value
      */
-    serialize(value: E, options?: OptionsHelper): any;
+    serialize(value: E, 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?: OptionsHelper): any;
+    encode(value: E, options?: ParserOptions): any;
 }

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

@@ -1,4 +1,4 @@
-import { CallableConfig, OptionsHelper, Parameter, Parser } from '../../types';
+import { CallableConfig, ParserOptions, Parameter, Parser } from '../../types';
 import { ODataEnumTypeParser } from './enum-type';
 import { ODataStructuredTypeParser } from './structured-type';
 export declare class ODataParameterParser<T> {
@@ -7,19 +7,20 @@ export declare class ODataParameterParser<T> {
     private parser;
     collection?: boolean;
     nullable?: boolean;
-    optionsHelper?: OptionsHelper;
+    parserOptions?: ParserOptions;
     constructor(name: string, parameter: Parameter);
-    serialize(value: T, options?: OptionsHelper): any;
-    encode(value: any, options?: OptionsHelper): string;
+    serialize(value: T, options?: ParserOptions): any;
+    encode(value: any, options?: ParserOptions): string;
     configure({ parserForType, options, }: {
         parserForType: (type: string) => Parser<any>;
-        options: OptionsHelper;
+        options: ParserOptions;
     }): void;
     isEdmType(): boolean;
     isEnumType(): boolean;
     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;
@@ -32,16 +33,16 @@ export declare class ODataCallableParser<R> implements Parser<R> {
     parser: Parser<any>;
     parameters: ODataParameterParser<any>[];
     nonParenthesisForEmptyParameterFunction?: boolean;
-    optionsHelper?: OptionsHelper;
+    parserOptions?: ParserOptions;
     constructor(config: CallableConfig, namespace: string, alias?: string);
     isTypeOf(type: string): boolean;
-    deserialize(value: any, options?: OptionsHelper): R;
-    serialize(params: any, options?: OptionsHelper): any;
-    encode(params: any, options?: OptionsHelper): any;
+    deserialize(value: any, options?: ParserOptions): R;
+    serialize(params: any, options?: ParserOptions): any;
+    encode(params: any, options?: ParserOptions): any;
     configure({ nonParenthesisForEmptyParameterFunction, parserForType, options, }: {
         nonParenthesisForEmptyParameterFunction: boolean;
         parserForType: (type: string) => Parser<any>;
-        options: OptionsHelper;
+        options: ParserOptions;
     }): void;
     binding(): ODataParameterParser<any> | undefined;
 }