angular-odata/index.d.ts

Client side OData typescript library for Angular

import { Observable, Subject, Subscription } from 'rxjs';
import * as angular_odata from 'angular-odata';
import { HttpContext, HttpHeaders, HttpParams, HttpResponse, HttpResponseBase, HttpErrorResponse, HttpClient, HttpEvent } from '@angular/common/http';
import * as i0 from '@angular/core';
import { EventEmitter, Provider, InjectionToken, EnvironmentProviders, ModuleWithProviders } from '@angular/core';
import * as i1 from '@angular/common';

type ODataVersion = '2.0' | '3.0' | '4.0';
type FetchPolicy = 'cache-first' | 'cache-and-network' | 'network-only' | 'no-cache' | 'cache-only';
type ODataMetadataType = 'minimal' | 'full' | 'none';
type CacheCacheability = 'public' | 'private' | 'no-cache' | 'no-store';
declare enum PathSegment {
    batch = "batch",
    metadata = "metadata",
    entitySet = "entitySet",
    singleton = "singleton",
    type = "type",
    property = "property",
    navigationProperty = "navigationProperty",
    reference = "reference",
    value = "value",
    count = "count",
    function = "function",
    action = "action"
}
declare enum QueryOption {
    select = "select",
    expand = "expand",
    compute = "compute",
    apply = "apply",
    filter = "filter",
    search = "search",
    transform = "transform",
    orderBy = "orderBy",
    top = "top",
    skip = "skip",
    skiptoken = "skiptoken",
    format = "format",
    levels = "levels",
    count = "count"
}
declare enum EdmType {
    Guid = "Edm.Guid",
    Int16 = "Edm.Int16",
    String = "Edm.String",
    Boolean = "Edm.Boolean",
    Byte = "Edm.Byte",
    SByte = "Edm.SByte",
    Int32 = "Edm.Int32",
    Int64 = "Edm.Int64",
    Date = "Edm.Date",
    TimeOfDay = "Edm.TimeOfDay",
    DateTimeOffset = "Edm.DateTimeOffset",
    Duration = "Edm.Duration",
    Decimal = "Edm.Decimal",
    Double = "Edm.Double",
    Single = "Edm.Single",
    Binary = "Edm.Binary",
    Stream = "Edm.Stream",
    Geography = "Edm.Geography",
    GeographyPoint = "Edm.GeographyPoint",
    GeographyLineString = "Edm.GeographyLineString",
    GeographyPolygon = "Edm.GeographyPolygon",
    GeographyMultiPoint = "Edm.GeographyMultiPoint",
    GeographyMultiLineString = "Edm.GeographyMultiLineString",
    GeographyMultiPolygon = "Edm.GeographyMultiPolygon",
    GeographyCollection = "Edm.GeographyCollection",
    Geometry = "Edm.Geometry",
    GeometryPoint = "Edm.GeometryPoint",
    GeometryLineString = "Edm.GeometryLineString",
    GeometryPolygon = "Edm.GeometryPolygon",
    GeometryMultiPoint = "Edm.GeometryMultiPoint",
    GeometryMultiLineString = "Edm.GeometryMultiLineString",
    GeometryMultiPolygon = "Edm.GeometryMultiPolygon",
    GeometryCollection = "Edm.GeometryCollection"
}
declare enum JsonType {
    string = "string",
    number = "number",
    integer = "integer",
    object = "object",
    array = "array",
    boolean = "boolean",
    null = "null"
}
interface ParserOptions {
    version?: ODataVersion;
    exponentialDecimals?: boolean;
    metadata?: ODataMetadataType;
    ieee754Compatible?: boolean;
    streaming?: boolean;
    stringAsEnum?: boolean;
    deleteRefBy?: 'path' | 'id';
    nonParenthesisForEmptyParameterFunction?: boolean;
}
interface ResponseOptions extends ParserOptions {
    cacheability?: CacheCacheability;
    maxAge?: number;
}
interface StructuredTypeFieldOptions extends ParserOptions {
    field: ODataStructuredTypeFieldConfig;
}
interface Parser<T> {
    deserialize(value: any, options?: ParserOptions | StructuredTypeFieldOptions): T | T[];
    serialize(value: T, options?: ParserOptions | StructuredTypeFieldOptions): any;
    encode(value: T, options?: ParserOptions | StructuredTypeFieldOptions): any;
}
interface FieldParser<T> extends Parser<T> {
    nullable?: boolean;
    default?: any;
    maxLength?: number;
    precision?: number;
    scale?: number | 'variable';
}
declare const NONE_PARSER: Parser<any>;
interface ODataCache {
    put<T>(key: string, payload: T, ...opts: any[]): void;
    get<T>(key: string, ...opts: any[]): T | undefined;
    handleRequest(req: any, res$: Observable<any>): Observable<any>;
    flush(): void;
}
interface ODataApiConfigOptions {
    version?: ODataVersion;
    params?: {
        [param: string]: string | string[];
    };
    headers?: {
        [param: string]: string | string[];
    };
    withCredentials?: boolean;
    accept?: {
        exponentialDecimals?: boolean;
        metadata?: ODataMetadataType;
        ieee754Compatible?: boolean;
        streaming?: boolean;
    };
    etag?: {
        ifMatch?: boolean;
        ifNoneMatch?: boolean;
    };
    prefer?: {
        maxPageSize?: number;
        return?: 'representation' | 'minimal';
        continueOnError?: boolean;
        includeAnnotations?: string;
    };
    stripMetadata?: ODataMetadataType;
    fetchPolicy?: FetchPolicy;
    bodyQueryOptions?: QueryOption[];
    stringAsEnum?: boolean;
    deleteRefBy?: 'path' | 'id';
    nonParenthesisForEmptyParameterFunction?: boolean;
    jsonBatchFormat?: boolean;
    relativeUrls?: boolean;
}
type ODataApiConfig = {
    serviceRootUrl: string;
    metadataUrl?: string;
    name?: string;
    version?: ODataVersion;
    default?: boolean;
    creation?: Date;
    cache?: ODataCache;
    errorHandler?: (error: any, caught: Observable<any>) => Observable<never>;
    options?: ODataApiConfigOptions;
    parsers?: {
        [type: string]: Parser<any>;
    };
    schemas?: ODataSchemaConfig[];
    references?: ODataReferenceConfig[];
};
type ODataAnnotationConfig = {
    term: string;
    string?: string;
    bool?: boolean;
    int?: number;
    permissions?: string[];
    properties?: string[];
};
type ODataReferenceConfig = {
    uri: string;
    includes?: string;
    annotations?: ODataAnnotationConfig[];
    enums?: ODataEnumTypeConfig[];
    entities?: ODataStructuredTypeConfig[];
    callables?: ODataCallableConfig[];
    containers?: ODataEntityContainerConfig[];
};
type ODataSchemaConfig = {
    namespace: string;
    alias?: string;
    annotations?: ODataAnnotationConfig[];
    enums?: ODataEnumTypeConfig[];
    entities?: ODataStructuredTypeConfig[];
    callables?: ODataCallableConfig[];
    containers?: ODataEntityContainerConfig[];
};
type ODataEntityContainerConfig = {
    name: string;
    annotations?: ODataAnnotationConfig[];
    entitySets?: ODataEntitySetConfig[];
    singletons?: ODataSingletonConfig[];
};
type ODataEnumTypeFieldConfig = {
    value: number;
    annotations?: ODataAnnotationConfig[];
};
type ODataEnumTypeConfig = {
    name: string;
    flags?: boolean;
    annotations?: ODataAnnotationConfig[];
    members: {
        [name: string]: number;
    } | {
        [value: number]: string;
    };
    fields: {
        [member: string]: ODataEnumTypeFieldConfig;
    };
};
type ODataStructuredTypeFieldConfig = {
    type: string;
    default?: any;
    maxLength?: number;
    key?: boolean;
    collection?: boolean;
    nullable?: boolean;
    navigation?: boolean;
    precision?: number;
    annotations?: ODataAnnotationConfig[];
    scale?: number | 'variable';
    referentials?: {
        property: string;
        referencedProperty: string;
    }[];
    referential?: string;
    referenced?: string;
};
type ODataStructuredTypeConfig = {
    name: string;
    base?: string;
    open?: boolean;
    model?: {
        new (...params: any[]): any;
    };
    collection?: {
        new (...params: any[]): any;
    };
    annotations?: ODataAnnotationConfig[];
    keys?: {
        name: string;
        alias?: string;
    }[];
    fields?: {
        [name: string]: ODataStructuredTypeFieldConfig;
    };
};
type ODataParameterConfig = {
    type: string;
    nullable?: boolean;
    collection?: boolean;
};
type ODataCallableConfig = {
    name: string;
    entitySetPath?: string;
    bound?: boolean;
    composable?: boolean;
    parameters?: {
        [name: string]: ODataParameterConfig;
    };
    return?: {
        type: string;
        collection?: boolean;
    };
};
type ODataEntitySetConfig = {
    name: string;
    entityType: string;
    service: {
        new (...params: any[]): any;
    };
    annotations?: ODataAnnotationConfig[];
};
type ODataSingletonConfig = {
    name: string;
    type: string;
    service: {
        new (...params: any[]): any;
    };
    annotations?: ODataAnnotationConfig[];
};

type LooseUnion<U> = U | (U extends string ? Record<never, never> & string : never);
type ObjectValues<T> = T[keyof T];
type Unpacked<T> = NonNullable<T> extends (infer U)[] ? U : NonNullable<T>;
type Select<T> = SelectType<T> | SelectType<T>[];
type SelectType<T> = LooseUnion<keyof T>;
type Filter<T> = FilterType<T> | FilterType<T>[];
type FilterType<T> = string | Record<string | keyof T, any>;
declare const StandardAggregateMethods: {
    readonly sum: "sum";
    readonly min: "min";
    readonly max: "max";
    readonly average: "average";
    readonly countdistinct: "countdistinct";
};
type StandardAggregateMethods = ObjectValues<typeof StandardAggregateMethods>;
type AggregateType<T> = string | Record<string | keyof T, {
    with: StandardAggregateMethods;
    as: string;
}>;
type OrderBy<T> = OrderByType<T> | OrderByType<T>[];
type OrderByType<T> = LooseUnion<OrderByObject<T>>;
type OrderByObject<T> = keyof T | [keyof T | string, 'asc' | 'desc'] | NestedOrderBy<T>;
type NestedOrderBy<T> = {
    [P in keyof T]?: T[P] extends Array<infer E> ? OrderBy<E> : OrderBy<T[P]>;
};
type Expand<T> = ExpandType<T> | ExpandType<T>[];
type ExpandType<T> = LooseUnion<ExpandObject<T>>;
type ExpandObject<T> = keyof T | NestedExpandOptions<T>;
type NestedExpandOptions<T> = {
    [P in keyof T]?: ExpandOptions<Unpacked<T[P]>>;
};
type ExpandOptions<T> = {
    select?: Select<T>;
    filter?: Filter<T>;
    orderBy?: OrderBy<T>;
    top?: number;
    skip?: number;
    levels?: number | 'max';
    count?: boolean | Filter<T>;
    expand?: Expand<T>;
};
type Transform<T> = {
    aggregate?: AggregateType<T> | Array<AggregateType<T>>;
    filter?: Filter<T> | null;
    groupBy?: GroupByType<T>;
};
type GroupByType<T> = {
    properties: Array<LooseUnion<keyof T>>;
    transform?: Transform<T>;
};
declare const QueryCustomTypes: {
    readonly Raw: "Raw";
    readonly Alias: "Alias";
    readonly Duration: "Duration";
    readonly Binary: "Binary";
};
type QueryCustomTypes = ObjectValues<typeof QueryCustomTypes>;
type QueryCustomType = {
    type: QueryCustomTypes;
    value: any;
    name?: string;
};
type Value = string | Date | number | boolean | QueryCustomType;
declare const raw: (value: string) => QueryCustomType;
declare const alias: (value: any, name?: string) => QueryCustomType;
declare const duration: (value: string) => QueryCustomType;
declare const binary: (value: string) => QueryCustomType;
declare const isQueryCustomType: (value: any) => boolean;
declare const isRawType: (value: any) => boolean;
type QueryOptions<T> = ExpandOptions<T> & {
    search: string;
    apply: string;
    transform: Transform<T> | Transform<T>[];
    compute: string;
    skip: number;
    skiptoken: string;
    key: string | number | Record<string | keyof T, any>;
    count: boolean | Filter<T>;
    action: string;
    func: string | {
        [functionName: string]: {
            [parameterName: string]: any;
        };
    };
    format: string;
    aliases: QueryCustomType[];
    escape: boolean;
};
declare const ITEM_ROOT = "";
declare function buildPathAndQuery<T>({ select, search, skiptoken, format, top, skip, filter, apply, transform, compute, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): [string, {
    [name: string]: any;
}];
declare function normalizeValue(value: Value, { aliases, escape }?: {
    aliases?: QueryCustomType[];
    escape?: boolean;
}): any;

type Normalize = 'all' | 'right' | 'left' | 'none';
interface Renderable {
    render({ aliases, escape, prefix, parser, options, }: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<any>;
        options?: ParserOptions;
    }): string;
    toJson(): any;
    clone(): any;
    resolve(parser: any): any;
    toString(): any;
}
declare const FieldFactory: <T extends object>(names?: (string | Renderable)[]) => any;
declare const RenderableFactory: (value: any) => Renderable;
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;
declare function resolve(values: any, parser?: Parser<any>): any;
declare function encode(values: any, parser?: Parser<any>, options?: ParserOptions): any;
declare class Function<T> implements Renderable {
    protected name: string;
    protected values: any[];
    protected normalize: Normalize;
    protected escape: boolean;
    constructor(name: string, values: any[], normalize: Normalize, escape?: boolean);
    get [Symbol.toStringTag](): string;
    toJson(): {
        $type: string;
        name: string;
        values: any[];
        normalize: Normalize;
    };
    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;
}
declare class StringAndCollectionFunctions<T> {
    concat(left: any, right: any, normalize?: Normalize): Function<T>;
    contains(left: any, right: any, normalize?: Normalize): Function<T>;
    endsWith(left: any, right: any, normalize?: Normalize): Function<T>;
    indexOf(left: any, right: any, normalize?: Normalize): Function<T>;
    length(left: any, normalize?: Normalize): Function<T>;
    startsWith(left: any, right: any, normalize?: Normalize): Function<T>;
    subString(left: any, right: number, length?: number, normalize?: Normalize): Function<T>;
}
declare class CollectionFunctions<T> {
    hasSubset(left: T, right: any, normalize?: Normalize): Function<T>;
    hasSubsequence(left: T, right: any, normalize?: Normalize): Function<T>;
}
declare class StringFunctions<T> {
    matchesPattern(left: any | string, pattern: string, normalize?: Normalize): Function<T>;
    toLower(left: any, normalize?: Normalize): Function<T>;
    toUpper(left: any, normalize?: Normalize): Function<T>;
    trim(left: any, normalize?: Normalize): Function<T>;
}
declare class DateAndTimeFunctions<T> {
    date(left: any, normalize?: Normalize): Function<T>;
    day(left: any, normalize?: Normalize): Function<T>;
    fractionalseconds(left: any, normalize?: Normalize): Function<T>;
    hour(left: any, normalize?: Normalize): Function<T>;
    maxdatetime(left: any, normalize?: Normalize): Function<T>;
    mindatetime(left: any, normalize?: Normalize): Function<T>;
    minute(left: any, normalize?: Normalize): Function<T>;
    month(left: any, normalize?: Normalize): Function<T>;
    now(): Function<T>;
    second(left: any, normalize?: Normalize): Function<T>;
    time(left: any, normalize?: Normalize): Function<T>;
    totaloffsetminutes(left: any, normalize?: Normalize): Function<T>;
    totalseconds(left: any, normalize?: Normalize): Function<T>;
    year(left: any, normalize?: Normalize): Function<T>;
}
declare class ArithmeticFunctions<T> {
    ceiling(left: T | string, normalize?: Normalize): Function<T>;
    floor(left: T | string, normalize?: Normalize): Function<T>;
    round(left: T | string, normalize?: Normalize): Function<T>;
}
declare class TypeFunctions<T> {
    cast<N>(left: T | string, type?: string): N;
    isof(left: T | string, type?: string): Type<T>;
}
declare class GeoFunctions<T> {
    geoDistance(left: T, right: string, normalize?: Normalize): Function<T>;
    geoIntersects(left: T, right: string, normalize?: Normalize): Function<T>;
    geoLength(left: T, normalize?: Normalize): Function<T>;
}
declare class ConditionalFunctions<T> {
    case(left: T | string, right: any, normalize?: Normalize): Function<T>;
}
declare class Operator<T> implements Renderable {
    protected op: string;
    protected values: any[];
    protected normalize: Normalize;
    constructor(op: string, values: any[], normalize: Normalize);
    get [Symbol.toStringTag](): string;
    toJson(): {
        $type: string;
        op: string;
        values: any[];
        normalize: Normalize;
    };
    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;
}
declare class LogicalOperators<T> {
    eq(left: any, right: any, normalize?: Normalize): Operator<unknown>;
    ne(left: any, right: any, normalize?: Normalize): Operator<unknown>;
    gt(left: any, right: any, normalize?: Normalize): Operator<unknown>;
    ge(left: any, right: any, normalize?: Normalize): Operator<unknown>;
    lt(left: any, right: any, normalize?: Normalize): Operator<unknown>;
    le(left: any, right: any, normalize?: Normalize): Operator<unknown>;
    not(left: any, normalize?: Normalize): Operator<T>;
    has(left: any, right: any, normalize?: Normalize): Operator<unknown>;
    in(left: any, right: any, normalize?: Normalize): Operator<unknown>;
}
declare class ArithmeticOperators<T> {
    add(left: any, right: any, normalize?: Normalize): Operator<T>;
    sub(left: any, right: any, normalize?: Normalize): Operator<unknown>;
    mul(left: any, right: any, normalize?: Normalize): Operator<unknown>;
    div(left: any, right: any, normalize?: Normalize): Operator<unknown>;
    mod(left: any, right: any, normalize?: Normalize): Operator<unknown>;
    neg(value: any, normalize?: Normalize): Operator<unknown>;
}
declare class Grouping<T> implements Renderable {
    protected group: Renderable;
    constructor(group: Renderable);
    get [Symbol.toStringTag](): string;
    toJson(): {
        $type: string;
        group: any;
    };
    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;
}
declare class GroupingOperators<T> {
    group(value: any): Grouping<T>;
    rollup(...values: any): Function<T>;
}
type AggregateMethod = 'sum' | 'min' | 'max' | 'average' | 'countdistinct';
declare class Aggregate<T> implements Renderable {
    protected value: Renderable;
    protected method: AggregateMethod;
    protected alias: string;
    constructor(value: Renderable, method: AggregateMethod, alias: string);
    get [Symbol.toStringTag](): string;
    toJson(): {
        $type: string;
        value: any;
        method: AggregateMethod;
        alias: string;
    };
    static fromJson<T>(json: {
        [name: string]: any;
    }): Aggregate<T>;
    render({ aliases, escape, prefix, parser, options, }: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<T>;
        options?: ParserOptions;
    }): string;
    clone(): Aggregate<unknown>;
    resolve(parser: any): any;
}
declare class GroupBy<T> implements Renderable {
    protected properties: Renderable[];
    protected transformations?: Renderable | undefined;
    constructor(properties: Renderable[], transformations?: Renderable | undefined);
    get [Symbol.toStringTag](): string;
    toJson(): {
        $type: string;
        properties: any[];
        transformations: any;
    };
    static fromJson<T>(json: {
        [name: string]: any;
    }): GroupBy<T>;
    render({ aliases, escape, prefix, parser, options, }: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<T>;
        options?: ParserOptions;
    }): string;
    clone(): GroupBy<unknown>;
    resolve(parser: any): any;
}
declare class Transformations<T> {
    aggregate(value: Renderable, method: AggregateMethod, alias: string): Aggregate<T>;
    groupby(properties: Renderable[], options?: Renderable): GroupBy<T>;
    topCount(value: number, field: Renderable, normalize?: Normalize): Function<T>;
    topSum(value: number, field: Renderable, normalize?: Normalize): Function<T>;
    topPercent(value: number, field: Renderable, normalize?: Normalize): Function<T>;
    bottomCount(value: number, field: Renderable, normalize?: Normalize): Function<T>;
    bottomSum(value: number, field: Renderable, normalize?: Normalize): Function<T>;
    bottomPercent(value: number, field: Renderable, normalize?: Normalize): Function<T>;
    identity(): Function<T>;
    search(value: any, normalize?: Normalize): Function<T>;
    filter(value: any, normalize?: Normalize): Function<T>;
    skip(value: number, normalize?: Normalize): Function<T>;
    top(value: number, normalize?: Normalize): Function<T>;
    orderby(value: any, normalize?: Normalize): Function<T>;
}
declare class Type<T> implements Renderable {
    protected name: string;
    protected type: string;
    protected value?: any | undefined;
    constructor(name: string, type: string, value?: any | undefined);
    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;
}
declare class Lambda<T> implements Renderable {
    protected op: string;
    protected values: any[];
    protected alias?: string | undefined;
    constructor(op: string, values: any[], alias?: string | undefined);
    get [Symbol.toStringTag](): string;
    toJson(): {
        $type: string;
        op: string;
        values: any[];
        alias: string | undefined;
    };
    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;
}
declare class LambdaOperators<T> {
    any(left: T, right: any, alias?: string): Lambda<unknown>;
    all(left: T, right: any, alias?: string): Lambda<unknown>;
}
declare class ODataOperators<T> {
}
interface ODataOperators<T> extends LogicalOperators<T>, ArithmeticOperators<T>, GroupingOperators<T>, LambdaOperators<T> {
}
declare const operators: ODataOperators<any>;
declare class ODataFunctions<T> {
}
interface ODataFunctions<T> extends StringAndCollectionFunctions<T>, CollectionFunctions<T>, StringFunctions<T>, DateAndTimeFunctions<T>, ArithmeticFunctions<T>, TypeFunctions<T>, GeoFunctions<T>, ConditionalFunctions<T> {
}
declare const functions: ODataFunctions<any>;
declare class ODataTransformations<T> {
}
interface ODataTransformations<T> extends Transformations<T> {
}
declare const transformations: ODataTransformations<any>;
declare class ODataSyntax<T> {
}
interface ODataSyntax<T> extends ODataOperators<T>, ODataFunctions<T>, ODataTransformations<T> {
}
declare const syntax: ODataSyntax<any>;

declare abstract class Expression<T> implements Renderable {
    protected _children: Renderable[];
    constructor({ children, }?: {
        children?: Renderable[];
    });
    get [Symbol.toStringTag](): string;
    abstract render({ aliases, escape, prefix, parser, options, }: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<T>;
        options?: ParserOptions;
    }): string;
    abstract clone(): Expression<T>;
    children(): Renderable[];
    length(): number;
    toJson(): {
        $type: string;
        children: any[];
    };
    resolve(parser: any): any;
    toString(): string;
}

type ComputeExpressionBuilder<T> = {
    t: Required<T>;
    e: () => ComputeExpression<T>;
};
declare class ComputeExpression<T> extends Expression<T> {
    protected names: string[];
    constructor({ children, names, }?: {
        children?: Renderable[];
        names?: string[];
    });
    get [Symbol.toStringTag](): string;
    static factory<T>(opts: (builder: ComputeExpressionBuilder<T>, current: ComputeExpression<T>) => ComputeExpression<T>, current?: ComputeExpression<T>): ComputeExpression<T>;
    toJson(): {
        $type: string;
        children: any[];
    } & {
        names: string[];
    };
    static fromJson<T>(json: {
        [name: string]: any;
    }): ComputeExpression<T>;
    render({ aliases, escape, prefix, parser, options, }?: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<T>;
        options?: ParserOptions;
    }): string;
    clone(): ComputeExpression<T>;
    private _add;
    field<T>(name: string, opts: (e: {
        o: ODataOperators<T>;
        f: ODataFunctions<T>;
    }) => Renderable): ComputeExpression<T>;
}

declare class CountField<T> implements Renderable {
    protected field: any;
    private values;
    constructor(field: any, values?: {
        [name: string]: any;
    });
    get [Symbol.toStringTag](): string;
    toJson(): {
        field: any;
    };
    render({ aliases, escape, prefix, parser, options, }: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<T>;
        options?: ParserOptions;
    }): string;
    filter(opts: (builder: FilterExpressionBuilder<T>, current?: FilterExpression<T>) => FilterExpression<T>): any;
    clone(): CountField<T>;
    resolve(parser: any): any;
    private option;
}
type CountExpressionBuilder<T> = {
    t: Required<T>;
    e: () => CountExpression<T>;
};
declare class CountExpression<T> extends Expression<T> {
    constructor({ children, }?: {
        children?: Renderable[];
    });
    get [Symbol.toStringTag](): string;
    static factory<T>(opts: (builder: CountExpressionBuilder<T>, current: CountExpression<T>) => CountExpression<T>, current?: CountExpression<T>): CountExpression<T>;
    private _add;
    toJson(): {
        $type: string;
        children: any[];
    };
    static fromJson<T>(json: {
        [name: string]: any;
    }): CountExpression<T>;
    render({ aliases, escape, prefix, parser, options, }?: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<T>;
        options?: ParserOptions;
    }): string;
    clone(): CountExpression<T>;
    field<F>(field: F[], opts?: (e: {
        t: F;
        f: CountField<F>;
    }) => CountExpression<F>): CountExpression<F>;
}

type FilterConnector = 'and' | 'or';
type FilterExpressionBuilder<T> = {
    t: Required<T>;
    e: (connector?: FilterConnector) => FilterExpression<T>;
    o: ODataOperators<T>;
    f: ODataFunctions<T>;
};
declare class FilterExpression<F> extends Expression<F> {
    private _connector;
    private _negated;
    constructor({ children, connector, negated, }?: {
        children?: Renderable[];
        connector?: FilterConnector;
        negated?: boolean;
    });
    get [Symbol.toStringTag](): string;
    static factory<T>(opts: (builder: FilterExpressionBuilder<T>, current: FilterExpression<T>) => FilterExpression<T>, current?: FilterExpression<T>): FilterExpression<T>;
    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, options, }?: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<any>;
        options?: ParserOptions;
    }): string;
    clone(): FilterExpression<F>;
    private _add;
    or(exp: FilterExpression<F>): FilterExpression<F>;
    and(exp: FilterExpression<F>): FilterExpression<F>;
    not(exp: FilterExpression<F>): FilterExpression<F>;
    eq(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
    ne(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
    gt(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
    ge(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
    lt(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
    le(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
    has(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
    in(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
    contains(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
    startsWith(left: any, right: any, normalize?: Normalize): FilterExpression<F>;
    endsWith(left: any, right: any, normalize?: Normalize): FilterExpression<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: {
        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;
        f: CountField<N>;
    }) => CountExpression<N>): FilterExpression<F>;
    isof(type: string): FilterExpression<F>;
    isof(left: F, type: string): FilterExpression<F>;
    combine(exp: FilterExpression<F>, connector?: FilterConnector): FilterExpression<F>;
}

type SearchConnector = 'AND' | 'OR';
declare class SearchTerm implements Renderable {
    protected value: string;
    constructor(value: string);
    get [Symbol.toStringTag](): string;
    toJson(): {
        $type: string;
        value: string;
    };
    render({ aliases, escape, prefix, parser, options, }: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<any>;
        options?: ParserOptions;
    }): string;
    clone(): SearchTerm;
    resolve(parser: any): any;
}
type SearchExpressionBuilder<T> = {
    e: (connector?: SearchConnector) => SearchExpression<T>;
};
declare class SearchExpression<T> extends Expression<T> {
    private _connector;
    private _negated;
    constructor({ children, connector, negated, }?: {
        children?: Renderable[];
        connector?: SearchConnector;
        negated?: boolean;
    });
    get [Symbol.toStringTag](): string;
    static factory<T>(opts: (builder: SearchExpressionBuilder<T>, current: SearchExpression<T>) => SearchExpression<T>, current?: SearchExpression<T>): SearchExpression<T>;
    private _add;
    render({ aliases, escape, prefix, parser, options, }?: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<T>;
        options?: ParserOptions;
    }): string;
    clone(): SearchExpression<T>;
    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>;
    and(exp: SearchExpression<T>): SearchExpression<T>;
    not(exp: SearchExpression<T>): SearchExpression<T>;
    term(value: any): SearchExpression<T>;
    combine(expression: SearchExpression<T>, connector?: SearchConnector): SearchExpression<T>;
}

declare class GroupByTransformations<T> extends Expression<T> {
    protected methods: (AggregateMethod | string)[];
    protected aliases: string[];
    constructor({ children, methods, aliases, }?: {
        children?: Renderable[];
        methods?: (AggregateMethod | string)[];
        aliases?: string[];
    });
    get [Symbol.toStringTag](): string;
    toJson(): {
        $type: string;
        children: any[];
    } & {
        methods: string[];
        aliases: string[];
    };
    static fromJson<T>(json: {
        [name: string]: any;
    }): GroupByTransformations<T>;
    render({ aliases, escape, prefix, parser, options, }?: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<T>;
        options?: ParserOptions;
    }): string;
    clone(): GroupByTransformations<T>;
    private _add;
    aggregate(value: any, method: AggregateMethod | string, alias: string): GroupByTransformations<T>;
    sum(value: any, alias: string): GroupByTransformations<T>;
    min(value: any, alias: string): GroupByTransformations<T>;
    max(value: any, alias: string): GroupByTransformations<T>;
    average(value: any, alias: string): GroupByTransformations<T>;
    countdistinct(value: any, alias: string): GroupByTransformations<T>;
    count(alias: string): GroupByTransformations<T>;
}
type ApplyExpressionBuilder<T> = {
    t: Required<T>;
    e: () => ApplyExpression<T>;
};
declare class ApplyExpression<T> extends Expression<T> {
    constructor({ children, }?: {
        children?: Renderable[];
    });
    get [Symbol.toStringTag](): string;
    static factory<T>(opts: (builder: ApplyExpressionBuilder<T>, current: ApplyExpression<T>) => ApplyExpression<T>, current?: ApplyExpression<T>): ApplyExpression<T>;
    toJson(): {
        $type: string;
        children: any[];
    };
    static fromJson<T>(json: {
        [name: string]: any;
    }): ApplyExpression<T>;
    render({ aliases, escape, prefix, parser, options, }?: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<T>;
        options?: ParserOptions;
    }): string;
    clone(): ApplyExpression<T>;
    private _add;
    aggregate(value: any, method: AggregateMethod, alias: string): ApplyExpression<T>;
    topCount(opts: (e: {
        o: ODataOperators<T>;
        f: ODataFunctions<T>;
    }) => Renderable): ApplyExpression<T>;
    topSum(opts: (e: {
        o: ODataOperators<T>;
        f: ODataFunctions<T>;
    }) => Renderable): ApplyExpression<T>;
    topPercent(opts: (e: {
        o: ODataOperators<T>;
        f: ODataFunctions<T>;
    }) => Renderable): ApplyExpression<T>;
    bottomCount(opts: (e: {
        o: ODataOperators<T>;
        f: ODataFunctions<T>;
    }) => Renderable): ApplyExpression<T>;
    bottomSum(opts: (e: {
        o: ODataOperators<T>;
        f: ODataFunctions<T>;
    }) => Renderable): ApplyExpression<T>;
    bottomPercent(opts: (e: {
        o: ODataOperators<T>;
        f: ODataFunctions<T>;
    }) => Renderable): ApplyExpression<T>;
    identity(opts: (e: {
        o: ODataOperators<T>;
        f: ODataFunctions<T>;
    }) => Renderable): ApplyExpression<T>;
    concat(opts: (e: {
        o: ODataOperators<T>;
        f: ODataFunctions<T>;
    }) => Renderable): ApplyExpression<T>;
    groupBy(props: (e: {
        rollup: (f: any) => any;
    }) => any | any[], opts?: (e: GroupByTransformations<T>) => GroupByTransformations<T>): ApplyExpression<T>;
    filter(opts: (e: {
        t: T;
        e: (connector?: FilterConnector) => FilterExpression<T>;
        o: ODataOperators<T>;
        f: ODataFunctions<T>;
    }) => FilterExpression<T>): ApplyExpression<T>;
    expand(opts: (e: {
        o: ODataOperators<T>;
        f: ODataFunctions<T>;
    }) => Renderable): ApplyExpression<T>;
    search(opts: (e: {
        t: T;
        e: (connector?: SearchConnector) => SearchExpression<T>;
        o: ODataOperators<T>;
        f: ODataFunctions<T>;
    }) => SearchExpression<T>): ApplyExpression<T>;
    compute(opts: (e: {
        o: ODataOperators<T>;
        f: ODataFunctions<T>;
    }) => Renderable): ApplyExpression<T>;
}

type OrderAttribute = 'asc' | 'desc';
declare class OrderByField implements Renderable {
    protected field: Renderable;
    protected order: OrderAttribute;
    constructor(field: Renderable, order: OrderAttribute);
    get [Symbol.toStringTag](): string;
    toJson(): {
        $type: string;
        field: any;
        order: OrderAttribute;
    };
    render({ aliases, escape, prefix, parser, options, }: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<any>;
        options?: ParserOptions;
    }): string;
    clone(): OrderByField;
    resolve(parser: any): any;
}
type OrderByExpressionBuilder<T> = {
    t: Required<T>;
    e: () => OrderByExpression<T>;
};
declare class OrderByExpression<T> extends Expression<T> {
    constructor({ children, }?: {
        children?: Renderable[];
    });
    get [Symbol.toStringTag](): string;
    static factory<T>(opts: (builder: OrderByExpressionBuilder<T>, current: OrderByExpression<T>) => OrderByExpression<T>, current?: OrderByExpression<T>): OrderByExpression<T>;
    private _add;
    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>;
    descending(field: any): OrderByExpression<T>;
    combine(expression: OrderByExpression<T>): OrderByExpression<T>;
}

type SelectExpressionBuilder<T> = {
    t: Required<T>;
    e: () => SelectExpression<T>;
};
declare class SelectExpression<T> extends Expression<T> {
    constructor({ children, }?: {
        children?: Renderable[];
    });
    get [Symbol.toStringTag](): string;
    static factory<T>(opts: (builder: SelectExpressionBuilder<T>, current: SelectExpression<T>) => SelectExpression<T>, current?: SelectExpression<T>): SelectExpression<T>;
    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;
    field(field: any): SelectExpression<T>;
    fields(...fields: any[]): SelectExpression<T>;
    combine(expression: SelectExpression<T>): SelectExpression<T>;
}

declare class ExpandField<T> implements Renderable {
    protected field: any;
    private values;
    constructor(field: any, values?: {
        [name: string]: any;
    });
    get [Symbol.toStringTag](): string;
    toJson(): {
        field: any;
    };
    render({ aliases, escape, prefix, parser, options, }: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<T>;
        options?: ParserOptions;
    }): string;
    clone(): ExpandField<T>;
    resolve(parser: any): any;
    select(opts: (builder: SelectExpressionBuilder<T>, current: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
    expand(opts: (builder: ExpandExpressionBuilder<T>, current: ExpandExpression<T>) => ExpandExpression<T>): ExpandExpression<T>;
    filter(opts: (builder: FilterExpressionBuilder<T>, current: FilterExpression<T>) => FilterExpression<T>): FilterExpression<T>;
    search(opts: (builder: SearchExpressionBuilder<T>, current: SearchExpression<T>) => SearchExpression<T>): SearchExpression<T>;
    orderBy(opts: (builder: OrderByExpressionBuilder<T>, current: OrderByExpression<T>) => OrderByExpression<T>): OrderByExpression<T>;
    compute(opts: (builder: ComputeExpressionBuilder<T>, current: ComputeExpression<T>) => ComputeExpression<T>): ComputeExpression<T>;
    skip(n: number): number;
    top(n: number): number;
    levels(n: number | 'max'): number | "max";
    count(): boolean;
    private option;
}
type ExpandExpressionBuilder<T> = {
    t: Required<T>;
    e: () => ExpandExpression<T>;
};
declare class ExpandExpression<T> extends Expression<T> {
    constructor({ children, }?: {
        children?: Renderable[];
    });
    get [Symbol.toStringTag](): string;
    static factory<T>(opts: (builder: ExpandExpressionBuilder<T>, current: ExpandExpression<T>) => ExpandExpression<T>, current?: ExpandExpression<T>): ExpandExpression<T>;
    toJson(): {
        $type: string;
        children: any[];
    };
    static fromJson<T>(json: {
        [name: string]: any;
    }): ExpandExpression<T>;
    render({ aliases, escape, prefix, parser, options, }?: {
        aliases?: QueryCustomType[];
        escape?: boolean;
        prefix?: string;
        parser?: Parser<T>;
        options?: ParserOptions;
    }): string;
    clone(): ExpandExpression<T>;
    private _add;
    field<F>(field: F, opts?: (e: ExpandField<Unpacked<F>>) => void): ExpandExpression<T>;
    combine(expression: ExpandExpression<T>): ExpandExpression<T>;
}

declare class ODataQueryOptionHandler<T> {
    private o;
    private n;
    constructor(o: Map<QueryOption, any>, n: QueryOption);
    /**
     * The name of the managed odata query option.
     */
    get name(): QueryOption;
    /**
     * 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;
    }): {
        [attr: string]: any;
    };
    /**
     * Clear the managed odata query option.
     */
    clear(): void;
    toString({ escape, parser }?: {
        escape?: boolean;
        parser?: Parser<T>;
    }): string;
}
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): angular_odata.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
     * @param value The value of the alias
     * @param name The name of the alias
     * @returns The alias
     */
    alias(value: any, name?: string): angular_odata.QueryCustomType;
    /**
     * Create a duration odata value
     * @param value The value to duration
     * @returns The duration value
     */
    duration(value: any): angular_odata.QueryCustomType;
    /**
     * Create a binary odata value
     * @param value The value to binary
     * @returns The binary value
     */
    binary(value: any): angular_odata.QueryCustomType;
    /**
     * Normalize the given value to a valid odata value
     * @param value The value to normalize
     * @returns The normalized value
     */
    normalize(value: any): any;
    /**
     * 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: (builder: SelectExpressionBuilder<T>, current: SelectExpression<T>) => SelectExpression<T>): SelectExpression<T>;
    select(opts: Select<T>): ODataQueryOptionHandler<T>;
    select(): ODataQueryOptionHandler<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: (builder: ExpandExpressionBuilder<T>, current: ExpandExpression<T>) => ExpandExpression<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: 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 $apply option.
     * If opts is given then set te value as new value for $compute.
     * @link http://docs.oasis-open.org/odata/odata-data-aggregation-ext/v4.0/cs02/odata-data-aggregation-ext-v4.0-cs02.html
     * @param opts string value or builder function for ApplyExpression<T>
     */
    apply(opts: (builder: ApplyExpressionBuilder<T>, current: ApplyExpression<T>) => ApplyExpression<T>): ApplyExpression<T>;
    apply(opts: string): ODataQueryOptionHandler<T>;
    apply(): 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>;
    /**
     * 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>;
    /**
     * 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>;
    /**
     * 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 op