angular-odata 0.124.0 → 0.126.0

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

@@ -1,4 +1,4 @@
-import { Parser } from '../../../types';
+import { Parser, ParserOptions } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { CountExpression, CountField } from './count';
@@ -18,19 +18,26 @@ export declare class FilterExpression<F> extends Expression<F> {
         connector?: FilterConnector;
         negated?: boolean;
     });
+    get [Symbol.toStringTag](): string;
     static filter<T>(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
-    toJSON(): {
+    toJson(): {
+        $type: string;
         children: any[];
+    } & {
         connector: FilterConnector;
         negated: boolean;
     };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): FilterExpression<T>;
     connector(): FilterConnector;
     negated(): boolean;
-    render({ aliases, escape, prefix, parser, }?: {
+    render({ aliases, escape, prefix, parser, options, }?: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<any>;
+        options?: ParserOptions;
     }): string;
     clone(): FilterExpression<F>;
     private _add;
@@ -51,10 +58,14 @@ export declare class FilterExpression<F> extends Expression<F> {
     any<N>(left: N[], opts?: (e: {
         e: (connector?: FilterConnector) => FilterExpression<N>;
         t: N;
+        o: ODataOperators<N>;
+        f: ODataFunctions<N>;
     }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
-    all<N>(left: N[], opts: (e: {
+    all<N>(left: N[], opts?: (e: {
         t: N;
         e: (connector?: FilterConnector) => FilterExpression<N>;
+        o: ODataOperators<N>;
+        f: ODataFunctions<N>;
     }) => FilterExpression<N>, alias?: string): FilterExpression<F>;
     count<N>(left: N[], opts?: (e: {
         t: N;

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

@@ -1,4 +1,4 @@
-import { Parser } from '../../../types';
+import { Parser, ParserOptions } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
@@ -7,17 +7,20 @@ export declare class OrderByField implements Renderable {
     protected order: 'asc' | 'desc';
     constructor(field: Renderable, order: 'asc' | 'desc');
     get [Symbol.toStringTag](): string;
-    toJSON(): {
+    toJson(): {
+        $type: string;
         field: any;
         order: "asc" | "desc";
     };
-    render({ aliases, escape, prefix, parser, }: {
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<any>;
+        options?: ParserOptions;
     }): string;
     clone(): OrderByField;
+    resolve(parser: any): any;
 }
 export type OrderByExpressionBuilder<T> = {
     t: Readonly<Required<T>>;
@@ -27,13 +30,22 @@ export declare class OrderByExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
+    get [Symbol.toStringTag](): string;
     static orderBy<T>(opts: (builder: OrderByExpressionBuilder<T>, current?: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
     private _add;
-    render({ aliases, escape, prefix, parser, }?: {
+    toJson(): {
+        $type: string;
+        children: any[];
+    };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): OrderByExpression<T>;
+    render({ aliases, escape, prefix, parser, options, }?: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): OrderByExpression<T>;
     ascending(field: any): OrderByExpression<T>;

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

@@ -1,4 +1,4 @@
-import { Parser } from '../../../types';
+import { Parser, ParserOptions } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
@@ -7,17 +7,19 @@ export declare class SearchTerm implements Renderable {
     protected value: string;
     constructor(value: string);
     get [Symbol.toStringTag](): string;
-    toJSON(): {
+    toJson(): {
         $type: string;
         value: string;
     };
-    render({ aliases, escape, prefix, parser, }: {
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<any>;
+        options?: ParserOptions;
     }): string;
     clone(): SearchTerm;
+    resolve(parser: any): any;
 }
 export type SearchExpressionBuilder<T> = {
     e: (connector?: SearchConnector) => SearchExpression<T>;
@@ -30,20 +32,27 @@ export declare class SearchExpression<T> extends Expression<T> {
         connector?: SearchConnector;
         negated?: boolean;
     });
+    get [Symbol.toStringTag](): string;
     static search<T>(opts: (builder: SearchExpressionBuilder<T>, current?: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
     private _add;
-    render({ aliases, escape, prefix, parser, }?: {
+    render({ aliases, escape, prefix, parser, options, }?: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): SearchExpression<T>;
-    toJSON(): {
+    toJson(): {
+        $type: string;
         children: any[];
+    } & {
         connector: SearchConnector;
         negated: boolean;
     };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): SearchExpression<T>;
     connector(): SearchConnector;
     negated(): boolean;
     or(exp: SearchExpression<T>): SearchExpression<T>;

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

@@ -1,4 +1,4 @@
-import { Parser } from '../../../types';
+import { Parser, ParserOptions } from '../../../types';
 import type { QueryCustomType } from '../builder';
 import { Expression } from './base';
 import { Renderable } from './syntax';
@@ -10,12 +10,21 @@ export declare class SelectExpression<T> extends Expression<T> {
     constructor({ children, }?: {
         children?: Renderable[];
     });
+    get [Symbol.toStringTag](): string;
     static select<T>(opts: (builder: SelectExpressionBuilder<T>, current?: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
-    render({ aliases, escape, prefix, parser, }?: {
+    toJson(): {
+        $type: string;
+        children: any[];
+    };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): SelectExpression<T>;
+    render({ aliases, escape, prefix, parser, options, }?: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): SelectExpression<T>;
     private _add;

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

@@ -1,27 +1,31 @@
-import { Parser } from '../../../types';
+import { Parser, ParserOptions } from '../../../types';
 import type { QueryCustomType } from '../builder';
 export type Normalize = 'all' | 'right' | 'left' | 'none';
 export interface Renderable {
-    render({ aliases, escape, prefix, parser, }: {
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<any>;
+        options?: ParserOptions;
     }): string;
     toString(): string;
-    toJSON(): any;
+    toJson(): any;
     clone(): any;
+    resolve(parser: any): any;
 }
-export declare const FieldFactory: <T extends object>(names?: string[]) => any;
-export declare function render(value: any, { aliases, normalize, escape, prefix, parser, }?: {
+export declare const FieldFactory: <T extends object>(names?: (string | Renderable)[]) => any;
+export declare const RenderableFactory: (value: any) => Renderable;
+export declare function render(value: any, { aliases, normalize, escape, prefix, parser, options, }?: {
     aliases?: QueryCustomType[];
     normalize?: boolean;
     escape?: boolean;
     prefix?: string;
     parser?: Parser<any>;
+    options?: ParserOptions;
 }): 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 function encode(values: any, parser?: Parser<any>, options?: ParserOptions): any;
 export declare class Function<T> implements Renderable {
     protected name: string;
     protected values: any[];
@@ -29,19 +33,24 @@ export declare class Function<T> implements Renderable {
     protected escape: boolean;
     constructor(name: string, values: any[], normalize: Normalize, escape?: boolean);
     get [Symbol.toStringTag](): string;
-    toJSON(): {
+    toJson(): {
         $type: string;
         name: string;
         values: any[];
         normalize: Normalize;
     };
-    render({ aliases, escape, prefix, parser, }: {
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): Function<T>;
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): Function<T>;
+    resolve(parser: any): any;
 }
 export declare class StringAndCollectionFunctions<T> {
     concat(left: any, right: any, normalize?: Normalize): Function<T>;
@@ -84,8 +93,8 @@ export declare class ArithmeticFunctions<T> {
     round(left: T | string, normalize?: Normalize): Function<T>;
 }
 export declare class TypeFunctions<T> {
-    cast(left: T | string, right?: string, normalize?: Normalize): Function<T>;
-    isof(left: T | string, right?: string, normalize?: Normalize): Function<T>;
+    cast<N>(left: T | string, type?: string): N;
+    isof(left: T | string, type?: string): Type<T>;
 }
 export declare class GeoFunctions<T> {
     geoDistance(left: T, right: string, normalize?: Normalize): Function<T>;
@@ -101,19 +110,24 @@ export declare class Operator<T> implements Renderable {
     protected normalize: Normalize;
     constructor(op: string, values: any[], normalize: Normalize);
     get [Symbol.toStringTag](): string;
-    toJSON(): {
+    toJson(): {
         $type: string;
         op: string;
         values: any[];
         normalize: Normalize;
     };
-    render({ aliases, escape, prefix, parser, }: {
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): Operator<T>;
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): Operator<unknown>;
+    resolve(parser: any): any;
 }
 export declare class LogicalOperators<T> {
     eq(left: any, right: any, normalize?: Normalize): Operator<unknown>;
@@ -138,17 +152,47 @@ export declare class Grouping<T> implements Renderable {
     protected group: Renderable;
     constructor(group: Renderable);
     get [Symbol.toStringTag](): string;
-    toJSON(): {
+    toJson(): {
         $type: string;
         group: any;
     };
-    render({ aliases, escape, prefix, parser, }: {
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): Grouping<T>;
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): Grouping<unknown>;
+    resolve(parser: any): any;
+}
+export declare class Type<T> implements Renderable {
+    protected name: string;
+    protected type: string;
+    protected value?: any;
+    constructor(name: string, type: string, value?: any);
+    get [Symbol.toStringTag](): string;
+    toJson(): {
+        $type: string;
+        name: string;
+        type: string;
+        value: any;
+    };
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): Type<T>;
+    render({ aliases, escape, prefix, parser, options, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+        parser?: Parser<T>;
+        options?: ParserOptions;
+    }): string;
+    clone(): Type<unknown>;
+    resolve(parser: any): any;
 }
 export declare class Lambda<T> implements Renderable {
     protected op: string;
@@ -156,19 +200,24 @@ export declare class Lambda<T> implements Renderable {
     protected alias?: string | undefined;
     constructor(op: string, values: any[], alias?: string | undefined);
     get [Symbol.toStringTag](): string;
-    toJSON(): {
+    toJson(): {
         $type: string;
         op: string;
         values: any[];
         alias: string | undefined;
     };
-    render({ aliases, escape, prefix, parser, }: {
+    static fromJson<T>(json: {
+        [name: string]: any;
+    }): Lambda<T>;
+    render({ aliases, escape, prefix, parser, options, }: {
         aliases?: QueryCustomType[];
         escape?: boolean;
         prefix?: string;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): string;
     clone(): Lambda<unknown>;
+    resolve(parser: any): any;
 }
 export declare class LambdaOperators<T> {
     any(left: T, right: any, alias?: string): Lambda<unknown>;

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

@@ -14,7 +14,7 @@ export declare class ODataQueryOptionHandler<T> {
      * Converts the managed odata query option to a json object.
      * @returns {any}
      */
-    toJSON(): 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.

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

@@ -1,3 +1,4 @@
 export * from './builder';
 export * from './options';
 export * from './handlers';
+export * from './expressions';

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

@@ -1,4 +1,4 @@
-import { Parser, QueryOption } from '../../types';
+import { Parser, ParserOptions, QueryOption } from '../../types';
 import { Expand, Filter, OrderBy, Select, Transform } from './builder';
 import { ComputeExpression, Expression, FilterExpression, OrderByExpression, SearchExpression } from './expressions';
 import { ExpandExpression } from './expressions/expand';
@@ -24,9 +24,10 @@ export declare class ODataQueryOptions<T> {
     constructor(values?: Map<QueryOption, any> | {
         [name: string]: any;
     });
-    pathAndParams({ escape, parser, }?: {
+    pathAndParams({ escape, parser, options, }?: {
         escape?: boolean;
         parser?: Parser<T>;
+        options?: ParserOptions;
     }): [
         string,
         {
@@ -37,7 +38,7 @@ export declare class ODataQueryOptions<T> {
         escape?: boolean;
         parser?: Parser<T>;
     }): string;
-    toJSON(): {};
+    toJson(): {};
     toQueryArguments(): ODataQueryArguments<T>;
     clone<O>(): ODataQueryOptions<O>;
     expression(key: QueryOption, exp?: Expression<T>): any;

package/lib/resources/request.d.ts

@@ -1,6 +1,6 @@
 import { HttpContext, HttpHeaders, HttpParams } from '@angular/common/http';
 import { ODataApi } from '../api';
-import { QueryOption } from '../types';
+import { FetchPolicy, ParserOptions, QueryOption } from '../types';
 import { ODataResource } from './resource';
 import { ODataOptions } from './types';
 export declare class ODataRequest<T> {
@@ -34,7 +34,8 @@ export declare class ODataRequest<T> {
             [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
         };
         responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
-        fetchPolicy?: 'cache-first' | 'cache-and-network' | 'network-only' | 'no-cache' | 'cache-only';
+        fetchPolicy?: FetchPolicy;
+        parserOptions?: ParserOptions;
         withCredentials?: boolean;
         bodyQueryOptions?: QueryOption[];
     });

package/lib/resources/resource.d.ts

@@ -52,22 +52,27 @@ export declare class ODataResource<T> {
     isSubtypeOf(other: ODataResource<any>): boolean;
     isSupertypeOf(other: ODataResource<any>): boolean;
     isEqualTo(other: ODataResource<any>, test?: 'path' | 'params'): boolean;
-    pathAndParams(escape?: boolean): [string, {
+    pathAndParams({ escape, ...options }?: ParserOptions & {
+        escape?: boolean;
+    }): [string, {
         [name: string]: any;
     }];
     endpointUrl(params?: boolean): string;
-    toString(escape?: boolean): string;
+    toString({ escape, ...options }?: ParserOptions & {
+        escape?: boolean;
+    }): string;
     clone(): ODataResource<T>;
-    private __parser;
+    private __serializeParser;
+    private __deserializeParser;
     deserialize(value: any, options?: ParserOptions): any;
     serialize(value: any, options?: ParserOptions): any;
     encode(value: any, options?: ParserOptions): any;
-    toJSON(): {
+    toJson(): {
         segments: any[];
         options: {};
     };
     cloneSegments(): ODataPathSegments;
-    clearQuery(): void;
+    clearQuery(): this;
     cloneQuery<P>(): ODataQueryOptions<P>;
     /**
      * Handle the path segments of the resource

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

@@ -6,33 +6,33 @@ export declare abstract class ODataAnnotations<T> {
     protected context?: ODataContext | undefined;
     constructor(helper: ODataVersionHelper, annotations?: Map<string, any>, context?: ODataContext | undefined);
     attributes(data: {
-        [key: string]: any;
+        [name: string]: any;
     }, metadata: ODataMetadataType): Partial<T>;
     update(data: {
-        [key: string]: any;
+        [name: string]: any;
     }): void;
     get entitySet(): string | undefined;
     get type(): string | undefined;
     abstract union(other: ODataAnnotations<any>): ODataAnnotations<any>;
     abstract clone(): ODataAnnotations<any>;
     abstract data(data: {
-        [key: string]: any;
+        [name: string]: any;
     }): {
-        [key: string]: any;
+        [name: string]: any;
     };
 }
 export declare class ODataPropertyAnnotations<T> extends ODataAnnotations<T> {
     union(other: ODataPropertyAnnotations<any>): ODataPropertyAnnotations<any>;
     clone(): ODataPropertyAnnotations<any>;
     data(data: {
-        [key: string]: any;
+        [name: string]: any;
     }): any;
 }
 export declare class ODataEntityAnnotations<T> extends ODataAnnotations<T> {
     union(other: ODataEntityAnnotations<any>): ODataEntityAnnotations<any>;
     clone(): ODataEntityAnnotations<any>;
     data(data: {
-        [key: string]: any;
+        [name: string]: any;
     }): any;
     get id(): string | undefined;
     get etag(): string | undefined;
@@ -49,7 +49,7 @@ export declare class ODataEntityAnnotations<T> extends ODataAnnotations<T> {
     property<F>(name: keyof T, type: 'single'): ODataEntityAnnotations<F>;
     private _functions?;
     get functions(): {
-        [key: string]: any;
+        [name: string]: any;
     };
     function(name: string): any;
 }
@@ -57,7 +57,7 @@ export declare class ODataEntitiesAnnotations<T> extends ODataAnnotations<T> {
     union(other: ODataEntitiesAnnotations<any>): ODataEntitiesAnnotations<any>;
     clone(): ODataEntitiesAnnotations<any>;
     data(data: {
-        [key: string]: any;
+        [name: string]: any;
     }): any;
     get readLink(): string | undefined;
     get count(): number | undefined;
@@ -68,7 +68,7 @@ export declare class ODataEntitiesAnnotations<T> extends ODataAnnotations<T> {
     get skiptoken(): string | undefined;
     private _functions?;
     get functions(): {
-        [key: string]: any;
+        [name: string]: any;
     };
     function(name: string): any;
 }

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

@@ -21,7 +21,7 @@ export declare class ODataResponse<T> extends HttpResponse<T> {
         url?: string;
     });
     static fromHttpResponse<T>(req: ODataRequest<T>, res: HttpResponse<T>): ODataResponse<T>;
-    static fromJSON<T>(req: ODataRequest<T>, json: {
+    static fromJson<T>(req: ODataRequest<T>, json: {
         body: T | null;
         headers: {
             [name: string]: string | string[];
@@ -30,7 +30,7 @@ export declare class ODataResponse<T> extends HttpResponse<T> {
         statusText: string;
         url: string | null;
     }): ODataResponse<T>;
-    toJSON(): {
+    toJson(): {
         body: T | null;
         headers: {
             [x: string]: string[];

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

@@ -1,16 +1,20 @@
 import { Observable } from 'rxjs';
 import { ODataApi } from '../../api';
+import { EdmType } from '../../types';
 import { ODataPathSegments } from '../path';
 import { ODataQueryOptions } from '../query';
 import { ODataResource } from '../resource';
 import { ODataOptions } from './options';
+import { ODataStructuredType } from '../../schema';
 export declare class ODataCountResource<T> extends ODataResource<T> {
-    static factory<T>(api: ODataApi, { segments, query, }: {
+    static factory<T>(api: ODataApi, { schema, segments, query, }: {
+        schema?: ODataStructuredType<T>;
         segments: ODataPathSegments;
         query?: ODataQueryOptions<T>;
     }): ODataCountResource<T>;
     clone(): ODataCountResource<T>;
     protected get(options?: ODataOptions): Observable<any>;
+    returnType(): EdmType;
     /**
      * Fetch the count of the set.
      * @param options Options for the request

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

@@ -18,9 +18,6 @@ export declare class ODataFunctionResource<P, R> extends ODataResource<R> {
     static fromResource<P, R>(resource: ODataResource<any>, path: string): ODataFunctionResource<P, R>;
     clone(): ODataFunctionResource<P, R>;
     returnType(): string | undefined;
-    pathAndParams(escape?: boolean): [string, {
-        [name: string]: any;
-    }];
     parameters(params: P | null, { alias }?: {
         alias?: boolean;
     }): ODataFunctionResource<P, R>;

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

@@ -1,5 +1,5 @@
 import { HttpContext, HttpHeaders, HttpParams } from '@angular/common/http';
-import { FetchPolicy } from '../../types';
+import { FetchPolicy, ParserOptions } from '../../types';
 import { ODataQueryArguments } from '../query';
 export type ODataOptions = {
     etag?: string;
@@ -13,6 +13,7 @@ export type ODataOptions = {
     reportProgress?: boolean;
     withCredentials?: boolean;
     fetchPolicy?: FetchPolicy;
+    parserOptions?: ParserOptions;
 };
 export type ODataEntityOptions = ODataOptions & {
     responseType?: 'entity';

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

@@ -9,6 +9,7 @@ import { ODataResource } from '../resource';
 import { ODataEntities, ODataEntitiesAnnotations, ODataEntity, ODataProperty } from '../responses';
 import { ODataEntitiesOptions, ODataEntityOptions, ODataOptions, ODataPropertyOptions } from './options';
 import { ODataValueResource } from './value';
+import { ODataCountResource } from './count';
 export declare class ODataPropertyResource<T> extends ODataResource<T> {
     static factory<P>(api: ODataApi, { path, type, schema, segments, query, }: {
         path: string;
@@ -22,6 +23,7 @@ export declare class ODataPropertyResource<T> extends ODataResource<T> {
     key(value: any): ODataPropertyResource<T>;
     keys(values: any[]): ODataPropertyResource<T>;
     value(): ODataValueResource<T>;
+    count(): ODataCountResource<T>;
     property<P>(path: string): ODataPropertyResource<P>;
     protected get(options?: ODataEntityOptions & ODataEntitiesOptions & ODataPropertyOptions): Observable<any>;
     /**

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

@@ -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;
+    isSupertypeOf(type: string): boolean;
     isOpenType(): boolean;
     findChildParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): ODataStructuredTypeParser<any> | undefined;
     childParser(predicate: (p: ODataStructuredTypeParser<any>) => boolean): Parser<any>;

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

@@ -55,12 +55,13 @@ export declare class ODataStructuredType<T> extends ODataSchemaElement {
      * @returns The schema that matches the predicate.
      */
     findParentSchema(predicate: (p: ODataStructuredType<any>) => boolean): ODataStructuredType<any> | undefined;
+    findChildSchema(predicate: (p: ODataStructuredType<any>) => boolean): ODataStructuredType<any> | undefined;
     /**
      * Find a parent schema of the structured type for the given field.
      * @param field Field that belongs to the structured type
      * @returns The schema of the field
      */
-    findSchemaForField<E>(field: ODataStructuredTypeFieldParser<any>): ODataStructuredType<E>;
+    findParentSchemaForField<E>(field: ODataStructuredTypeFieldParser<any>): ODataStructuredType<E>;
     /**
      * Picks the fields from attributes.
      * @param attrs