angular-odata 0.102.0 → 0.102.5

package/lib/api.d.ts

@@ -20,9 +20,7 @@ export declare class ODataApi {
     options: ODataApiOptions;
     cache: ODataCache;
     errorHandler?: (error: any, caught: Observable<any>) => Observable<never>;
-    parsers: {
-        [type: string]: Parser<any>;
-    };
+    parsers: Map<string, Parser<any>>;
     schemas: ODataSchema[];
     constructor(config: ApiConfig);
     configure(settings?: {
@@ -96,5 +94,5 @@ export declare class ODataApi {
     findCollectionByName(name: string): typeof ODataCollection | undefined;
     findServiceByName(name: string): typeof ODataEntityService | undefined;
     parserForType<T>(type: string, bindingType?: string): Parser<T>;
-    findOptionsForType<T>(type: string): ODataModelOptions<T> | undefined;
+    findOptionsForType<T>(type: string): ODataModelOptions<any> | ODataModelOptions<T> | undefined;
 }

package/lib/models/collection.d.ts

@@ -1,6 +1,7 @@
 import { EventEmitter } from '@angular/core';
 import { Observable } from 'rxjs';
 import { ODataActionOptions, ODataEntitiesAnnotations, ODataEntitySetResource, ODataFunctionOptions, ODataNavigationPropertyResource, ODataOptions, ODataPropertyResource, ODataQueryOptionsHandler, ODataResource } from '../resources';
+import { ODataStructuredType } from '../schema/structured-type';
 import { ODataModel } from './model';
 import { ODataModelEntry, ODataModelEvent, ODataModelField } from './options';
 export declare class ODataCollection<T, M extends ODataModel<T>> implements Iterable<M> {
@@ -103,7 +104,7 @@ export declare class ODataCollection<T, M extends ODataModel<T>> implements Iter
         reparent?: boolean;
         silent?: boolean;
     }): void;
-    query(func: (q: ODataQueryOptionsHandler<T>) => void): this;
+    query(func: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): this;
     callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataFunctionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
     callAction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none', { ...options }?: {} & ODataActionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null>;
     private _unlink;

package/lib/models/options.d.ts

@@ -174,9 +174,9 @@ export declare class ODataModelOptions<T> {
         findOptionsForType: (type: string) => ODataModelOptions<any> | undefined;
         options: ParserOptions;
     }): void;
-    fields({ include_navigation, include_parents, }?: {
-        include_parents?: boolean;
-        include_navigation?: boolean;
+    fields({ include_navigation, include_parents, }: {
+        include_parents: boolean;
+        include_navigation: boolean;
     }): ODataModelField<any>[];
     field<F>(name: keyof T | string): ODataModelField<F>;
     attach<R>(self: ODataModel<T>, resource: ODataEntityResource<R> | ODataNavigationPropertyResource<R> | ODataPropertyResource<R> | ODataSingletonResource<R>): void;
@@ -199,25 +199,28 @@ export declare class ODataModelOptions<T> {
     query(self: ODataModel<T>, resource: ODataEntityResource<T> | ODataPropertyResource<T> | ODataNavigationPropertyResource<T> | ODataSingletonResource<T>, func: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): ODataModel<T>;
     resolveKey(value: ODataModel<T> | T | {
         [name: string]: any;
-    }, { field_mapping, resolve, }?: {
+    }, { field_mapping, resolve, single, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
+        single?: boolean;
     }): EntityKey<T> | {
         [name: string]: any;
     } | undefined;
     resolveReferential(value: ODataModel<T> | T | {
         [name: string]: any;
-    } | null, field: ODataModelField<any>, { field_mapping, resolve, }?: {
+    } | null, field: ODataModelField<any>, { field_mapping, resolve, single, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
+        single?: boolean;
     }): {
         [name: string]: any;
     } | null | undefined;
     resolveReferenced(value: ODataModel<T> | T | {
         [name: string]: any;
-    } | null, field: ODataModelField<any>, { field_mapping, resolve, }?: {
+    } | null, field: ODataModelField<any>, { field_mapping, resolve, single, }?: {
         field_mapping?: boolean;
         resolve?: boolean;
+        single?: boolean;
     }): {
         [name: string]: any;
     } | null | undefined;

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

@@ -1,18 +1,19 @@
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
+export declare type ComputeExpressionBuilder<T> = {
+    t: T;
+    e: () => ComputeExpression<T>;
+};
 export declare class ComputeExpression<T> extends Expression<T> {
     names: string[];
     constructor({ children, names, }?: {
         children?: Renderable[];
         names?: string[];
     });
-    static e<T>(): ComputeExpression<T>;
-    static s<T extends object>(): T;
-    static compute<T extends object>(opts: (builder: {
-        s: T;
-        e: () => ComputeExpression<T>;
-    }, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
+    static expression<T>(): ComputeExpression<T>;
+    static type<T extends object>(): T;
+    static compute<T extends object>(opts: (builder: ComputeExpressionBuilder<T>, current?: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;

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

@@ -1,10 +1,10 @@
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
-import { FilterConnector, FilterExpression } from './filter';
-import { OrderByExpression } from './orderby';
-import { SearchConnector, SearchExpression } from './search';
-import { SelectExpression } from './select';
-import { ODataFunctions, ODataOperators, Renderable } from './syntax';
+import { FilterExpression, FilterExpressionBuilder } from './filter';
+import { OrderByExpression, OrderByExpressionBuilder } from './orderby';
+import { SearchExpression, SearchExpressionBuilder } from './search';
+import { SelectExpression, SelectExpressionBuilder } from './select';
+import { Renderable } from './syntax';
 export declare class ExpandField<T> implements Renderable {
     protected field: any;
     private values;
@@ -21,42 +21,27 @@ export declare class ExpandField<T> implements Renderable {
         prefix?: string;
     }): string;
     clone(): ExpandField<unknown>;
-    select<T extends object>(opts: (builder: {
-        s: T;
-        e: () => SelectExpression<T>;
-    }, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
-    expand<T extends object>(opts: (builder: {
-        s: T;
-        e: () => ExpandExpression<T>;
-    }, current?: ExpandExpression<T>) => ExpandExpression<T>): any;
-    filter<T extends object>(opts: (builder: {
-        s: T;
-        e: (connector?: FilterConnector) => FilterExpression<T>;
-        o: ODataOperators<T>;
-        f: ODataFunctions<T>;
-    }, current?: FilterExpression<T>) => FilterExpression<T>): any;
-    search<T extends object>(opts: (builder: {
-        e: (connector?: SearchConnector) => SearchExpression<T>;
-    }) => SearchExpression<T>): any;
-    orderBy<T extends object>(opts: (builder: {
-        s: T;
-        e: () => OrderByExpression<T>;
-    }, current?: OrderByExpression<T>) => OrderByExpression<T>): any;
+    select<T extends object>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
+    expand<T extends object>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>): any;
+    filter<T extends object>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): any;
+    search<T extends object>(opts: (builder: SearchExpressionBuilder<T>) => SearchExpression<T>): any;
+    orderBy<T extends object>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>): any;
     skip(n: number): any;
     top(n: number): any;
     levels(n: number | 'max'): any;
     private option;
 }
+export declare type ExpandExpressionBuilder<T> = {
+    t: T;
+    e: () => ExpandExpression<T>;
+};
 export declare class ExpandExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    static e<T>(): ExpandExpression<T>;
-    static s<T extends object>(): T;
-    static expand<T extends object>(opts: (builder: {
-        s: T;
-        e: () => ExpandExpression<T>;
-    }, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
+    static expression<T>(): ExpandExpression<T>;
+    static type<T extends object>(): T;
+    static expand<T extends object>(opts: (builder: ExpandExpressionBuilder<T>, current?: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;
         escape?: boolean | undefined;

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

@@ -2,6 +2,12 @@ import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { ODataFunctions, ODataOperators, Renderable } from './syntax';
 export declare type FilterConnector = 'and' | 'or';
+export declare type FilterExpressionBuilder<T> = {
+    t: T;
+    e: (connector?: FilterConnector) => FilterExpression<T>;
+    o: ODataOperators<T>;
+    f: ODataFunctions<T>;
+};
 export declare class FilterExpression<F> extends Expression<F> {
     private _connector;
     private _negated;
@@ -10,14 +16,9 @@ export declare class FilterExpression<F> extends Expression<F> {
         connector?: FilterConnector;
         negated?: boolean;
     });
-    static s<T extends object>(): T;
-    static e<T>(connector?: FilterConnector): FilterExpression<T>;
-    static filter<T extends object>(opts: (builder: {
-        s: T;
-        e: (connector?: FilterConnector) => FilterExpression<T>;
-        o: ODataOperators<T>;
-        f: ODataFunctions<T>;
-    }, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
+    static type<T extends object>(): T;
+    static expression<T>(connector?: FilterConnector): FilterExpression<T>;
+    static filter<T extends object>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
     toJSON(): {
         children: any[];
         connector: FilterConnector;
@@ -47,11 +48,11 @@ export declare class FilterExpression<F> extends Expression<F> {
     startsWith(left: any, right: any, normalize?: boolean): FilterExpression<F>;
     endsWith(left: any, right: any, normalize?: boolean): FilterExpression<F>;
     any<N extends object>(left: N[], opts: (e: {
-        s: N;
         e: (connector?: FilterConnector) => FilterExpression<N>;
+        t: N;
     }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
     all<N extends object>(left: N[], opts: (e: {
-        s: N;
+        t: N;
         e: (connector?: FilterConnector) => FilterExpression<N>;
     }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
     isof(type: string): FilterExpression<F>;

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

@@ -3,4 +3,6 @@ export * from './compute';
 export * from './filter';
 export * from './orderby';
 export * from './search';
+export * from './select';
 export * from './syntax';
+export * from './expand';

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

@@ -17,16 +17,17 @@ export declare class OrderByField implements Renderable {
     }): string;
     clone(): OrderByField;
 }
+export declare type OrderByExpressionBuilder<T> = {
+    t: T;
+    e: () => OrderByExpression<T>;
+};
 export declare class OrderByExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
-    static e<T>(): OrderByExpression<T>;
-    static s<T extends object>(): T;
-    static orderBy<T extends object>(opts: (builder: {
-        s: T;
-        e: () => OrderByExpression<T>;
-    }, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
+    static expression<T>(): OrderByExpression<T>;
+    static type<T extends object>(): T;
+    static orderBy<T extends object>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
     private _add;
     render({ aliases, escape, prefix, }?: {
         aliases?: QueryCustomType[] | undefined;

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,8 +1,6 @@
 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;
@@ -126,10 +124,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: (builder: {
-        s: T;
-        e: () => SelectExpression<T>;
-    }, current?: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
+    select(opts: SelectExpressionBuilder<T>): SelectExpression<T>;
     select(opts: Select<T>): ODataQueryOptionHandler<T>;
     select(): ODataQueryOptionHandler<T>;
     /**
@@ -137,10 +132,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: (builder: {
-        s: T;
-        e: () => ExpandExpression<T>;
-    }, current?: ExpandExpression<T>) => ExpandExpression<T>): ExpandExpression<T>;
+    expand(opts: ExpandExpressionBuilder<T>): ExpandExpression<T>;
     expand(opts: Expand<T>): ODataQueryOptionHandler<T>;
     expand(): ODataQueryOptionHandler<T>;
     /**
@@ -149,12 +141,7 @@ export declare class ODataQueryOptionsHandler<T> {
      * @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>;
     /**
@@ -177,9 +164,7 @@ export declare class ODataQueryOptionsHandler<T> {
      * 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: {
-        e: (connector: SearchConnector) => SearchExpression<T>;
-    }, current?: SearchExpression<T>) => SearchExpression<T>): SearchExpression<T>;
+    search(opts: (builder: SearchExpressionBuilder<T>, current?: SearchExpression<T>) => SearchExpression<T>): SearchExpression<T>;
     search(opts: string): ODataQueryOptionHandler<T>;
     search(): ODataQueryOptionHandler<T>;
     /**
@@ -187,12 +172,7 @@ export declare class ODataQueryOptionsHandler<T> {
      * 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: {
-        s: T;
-        e: (connector?: FilterConnector) => FilterExpression<T>;
-        o: ODataOperators<T>;
-        f: ODataFunctions<T>;
-    }, current?: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
+    filter(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
     filter(opts: Filter<T>): ODataQueryOptionHandler<T>;
     filter(): ODataQueryOptionHandler<T>;
     /**
@@ -200,10 +180,7 @@ export declare class ODataQueryOptionsHandler<T> {
      * 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: {
-        s: T;
-        e: () => OrderByExpression<T>;
-    }, current?: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
+    orderBy(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
     orderBy(opts: OrderBy<T>): ODataQueryOptionHandler<T>;
     orderBy(): ODataQueryOptionHandler<T>;
     /**

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