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[];
    models?: {
        [type: string]: {
            new (...params: any[]): any;
        };
    };
    collections?: {
        [type: string]: {
            new (...params: any[]): any;
        };
    };
};
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 opts is given then set te value as new value for $top.
     * @param opts number value
     */
    top(opts: number): ODataQueryOptionHandler<T>;
    top(): ODataQueryOptionHandler<T>;
    /**
     * Build and return a handler for modifying the $skip option.
     * If opts is given then set te value as new value for $skip.
     * @param opts number value
     */
    skip(opts: number): ODataQueryOptionHandler<T>;
    skip(): ODataQueryOptionHandler<T>;
    /**
     * Build and return a handler for modifying the $skiptoken option.
     * If opts is given then set te value as new value for $skiptoken.
     * @param opts string value
     */
    skiptoken(opts: string): ODataQueryOptionHandler<T>;
    skiptoken(): ODataQueryOptionHandler<T>;
    remove(...keys: QueryOption[]): void;
    keep(...keys: QueryOption[]): void;
    /**
     * Shortcut for set $top, $skip, $skiptoken.
     * @param param0 skip or top or skiptoken
     */
    paging({ skip, skiptoken, top, }?: {
        skip?: number | null;
        skiptoken?: string | null;
        top?: number | null;
    }): void;
    /**
     * Shortcut for clear pagination by unset $top, $skip, $skiptoken.
     */
    removePaging(): void;
    /**
     * Shortcut for clear query.
     */
    clear(): void;
    /**
     * Store the query options from the current query.
     */
    store(): ODataQueryArguments<T>;
    /**
     * Restore the given query options to the current query.
     * @param options The query to be applied.
     */
    restore(options: ODataQueryArguments<T>): void;
    /**
     * Combine the given query options with the current query.
     * @param options The query to be combined.
     */
    combine(options: ODataQueryArguments<T>): void;
    toJson(): {};
    fromJson(json: {
        [name: string]: any;
    }): void;
    toString({ escape, parser }?: {
        escape?: boolean;
        parser?: Parser<T>;
    }): string;
    pathAndParams({ escape, parser, options, }?: {
        escape?: boolean;
        parser?: Parser<T>;
        options?: ParserOptions;
    }): [string, {
        [name: string]: any;
    }];
}

type ODataQueryArguments<T> = {
    [QueryOption.select]?: Select<T> | SelectExpression<T> | null;
    [QueryOption.expand]?: Expand<T> | ExpandExpression<T> | null;
    [QueryOption.compute]?: string | ComputeExpression<T> | null;
    [QueryOption.apply]?: string | ApplyExpression<T> | null;
    [QueryOption.filter]?: Filter<T> | FilterExpression<T> | null;
    [QueryOption.search]?: string | SearchExpression<T> | null;
    [QueryOption.transform]?: Transform<T> | null;
    [QueryOption.orderBy]?: OrderBy<T> | OrderByExpression<T> | null;
    [QueryOption.top]?: number | null;
    [QueryOption.skip]?: number | null;
    [QueryOption.skiptoken]?: string | null;
    [QueryOption.format]?: string | null;
    [QueryOption.levels]?: number | 'max' | null;
    [QueryOption.count]?: boolean | null;
};
declare const pathAndParamsFromQueryOptions: <T>(values: Map<QueryOption, any>, { escape, parser, options, }?: {
    escape?: boolean;
    parser?: Parser<T>;
    options?: ParserOptions;
}) => [string, {
    [name: string]: any;
}];
declare class ODataQueryOptions<T> {
    private _values;
    constructor(values?: Map<QueryOption, any>);
    pathAndParams({ escape, parser, options, }?: {
        escape?: boolean;
        parser?: Parser<T>;
        options?: ParserOptions;
    }): [string, {
        [name: string]: any;
    }];
    toString({ escape, parser }?: {
        escape?: boolean;
        parser?: Parser<T>;
    }): string;
    toJson(): {};
    fromJson<T>(json: {
        [name: string]: any;
    }): this;
    static fromJson<T>(json: {
        [name: string]: any;
    }): ODataQueryOptions<T>;
    toQueryArguments(): ODataQueryArguments<T>;
    clone<O>(): ODataQueryOptions<O>;
    expression(key: QueryOption, exp?: Expression<T>): any;
    option<O>(key: QueryOption, opts?: O): ODataQueryOptionHandler<O>;
    has(key: QueryOption): boolean;
    remove(...keys: QueryOption[]): void;
    keep(...keys: QueryOption[]): void;
    clear(): void;
}

type ODataContext = {
    serviceRootUrl?: string;
    metadataUrl?: string;
    entitySet?: string;
    key?: string;
    expand?: string;
    type?: string;
    property?: string;
    entity?: boolean;
};
interface ODataVersionHelper {
    VALUE: string;
    ODATA_ANNOTATION_PREFIX: string;
    ODATA_FUNCTION_PREFIX: string;
    ODATA_ID: string;
    ODATA_TYPE: string;
    ODATA_COUNT: string;
    ODATA_ETAG: string;
    ODATA_CONTEXT: string;
    ODATA_MEDIA_ETAG: string;
    ODATA_NEXTLINK: string;
    ODATA_DEFERRED: string;
    ODATA_ANNOTATION: string;
    entity(value: {
        [name: string]: any;
    }): any;
    entities(value: {
        [name: string]: any;
    }): any;
    property(value: {
        [name: string]: any;
    }): any;
    annotations(value: {
        [name: string]: any;
    }): Map<string, any>;
    attributes(value: {
        [name: string]: any;
    }, metadata: ODataMetadataType): any;
    context(annots: Map<string, any> | {
        [name: string]: any;
    }): ODataContext;
    id(annots: Map<string, any> | {
        [name: string]: any;
    }): string | undefined;
    etag(annots: Map<string, any> | {
        [name: string]: any;
    }): string | undefined;
    type(annots: Map<string, any> | {
        [name: string]: any;
    }): string | undefined;
    count(annots: Map<string, any>): number | undefined;
    functions(annots: Map<string, any>): Map<string, any>;
    properties<T>(annots: Map<string, any>): Map<keyof T, Map<string, any>>;
    mediaEtag(annots: Map<string, any>): string | undefined;
    metadataEtag(annots: Map<string, any>): string | undefined;
    nextLink(annots: Map<string, any>): string | undefined;
    readLink(annots: Map<string, any>): string | undefined;
    mediaReadLink(annots: Map<string, any>): string | undefined;
    editLink(annots: Map<string, any>): string | undefined;
    mediaEditLink(annots: Map<string, any>): string | undefined;
    mediaContentType(annots: Map<string, any>): string | undefined;
    deltaLink(annots: Map<string, any>): string | undefined;
    countParam(): {
        [name: string]: string;
    };
}

declare abstract class ODataAnnotations<T> {
    helper: ODataVersionHelper;
    protected annotations: Map<string, any>;
    protected context?: ODataContext | undefined;
    constructor(helper: ODataVersionHelper, annotations?: Map<string, any>, context?: ODataContext | undefined);
    attributes(data: {
        [name: string]: any;
    }, metadata: ODataMetadataType): Partial<T>;
    update(data: {
        [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: {
        [name: string]: any;
    }): {
        [name: string]: any;
    };
}
declare class ODataPropertyAnnotations<T> extends ODataAnnotations<T> {
    union(other: ODataPropertyAnnotations<any>): ODataPropertyAnnotations<any>;
    clone(): ODataPropertyAnnotations<any>;
    data(data: {
        [name: string]: any;
    }): any;
}
declare class ODataEntityAnnotations<T> extends ODataAnnotations<T> {
    union(other: ODataEntityAnnotations<any>): ODataEntityAnnotations<any>;
    clone(): ODataEntityAnnotations<any>;
    data(data: {
        [name: string]: any;
    }): any;
    get id(): string | undefined;
    get etag(): string | undefined;
    get mediaEtag(): string | undefined;
    get metadataEtag(): string | undefined;
    get readLink(): string | undefined;
    get editLink(): string | undefined;
    get mediaReadLink(): string | undefined;
    get mediaEditLink(): string | undefined;
    get mediaContentType(): string | undefined;
    private _properties?;
    get properties(): Map<keyof T, Map<string, any>>;
    property<F>(name: keyof T, type: 'collection'): ODataEntitiesAnnotations<F>;
    property<F>(name: keyof T, type: 'single'): ODataEntityAnnotations<F>;
    private _functions?;
    get functions(): {
        [name: string]: any;
    };
    function(name: string): any;
}
declare class ODataEntitiesAnnotations<T> extends ODataAnnotations<T> {
    union(other: ODataEntitiesAnnotations<any>): ODataEntitiesAnnotations<any>;
    clone(): ODataEntitiesAnnotations<any>;
    data(data: {
        [name: string]: any;
    }): any;
    get readLink(): string | undefined;
    get count(): number | undefined;
    get nextLink(): string | undefined;
    get deltaLink(): string | undefined;
    get top(): number | undefined;
    get skip(): number | undefined;
    get skiptoken(): string | undefined;
    private _functions?;
    get functions(): {
        [name: string]: any;
    };
    function(name: string): any;
    entity(): ODataEntityAnnotations<T>;
}

declare class ODataAnnotation {
    term: string;
    string?: string;
    bool?: boolean;
    int?: number;
    permissions?: string[];
    properties?: string[];
    constructor(annot: ODataAnnotationConfig);
}
declare class ODataAnnotatable {
    annotations: ODataAnnotation[];
    constructor(config: {
        annotations?: ODataAnnotationConfig[];
    });
    /**
     * Find an annotation inside the annotatable.
     * @param predicate Function that returns true if the annotation match.
     * @returns The annotation that matches the predicate.
     */
    findAnnotation(predicate: (annot: ODataAnnotation) => boolean): ODataAnnotation | undefined;
    /**
     * Find an annotation inside the annotatable and return its value.
     * @param term The term of the annotation to find.
     * @returns The value of the annotation.
     */
    annotatedValue<T>(term: string | RegExp): T | undefined;
}

declare class ODataSchemaElement extends ODataAnnotatable {
    name: string;
    schema: ODataSchema;
    constructor(config: {
        annotations?: ODataAnnotationConfig[];
        name: string;
    }, schema: ODataSchema);
    get api(): angular_odata.ODataApi;
    /**
     * Create a nicer looking title.
     * Titleize is meant for creating pretty output.
     * @param term The term of the annotation to find.
     * @returns The titleized string.
     */
    titleize(term?: string | RegExp): string;
    /**
     * Returns a full type of the structured type including the namespace/alias.
     * @param alias Use the alias of the namespace instead of the namespace.
     * @returns The string representation of the type.
     */
    type({ alias }?: {
        alias?: boolean;
    }): string;
    /**
     * Returns a boolean indicating if the structured type is of the given type.
     * @param type String representation of the type
     * @returns True if the callable is type of the given type
     */
    isTypeOf(element: ODataSchemaElement): boolean;
    /**
     * Returns a boolean indicating if the structured type is a subtype of the given type.
     * @param type String representation of the type
     * @returns True if the callable is type of the given type
     */
    isSubtypeOf(element: ODataSchemaElement): boolean;
    /**
     * Returns a boolean indicating if the structured type is a supertype of the given type.
     * @param type String representation of the type
     * @returns True if the callable is type of the given type
     */
    isSupertypeOf(element: ODataSchemaElement): boolean;
}
declare class ODataParserSchemaElement<E, P extends Parser<E>> extends ODataSchemaElement {
    parser: P;
    constructor(config: {
        annotations?: ODataAnnotationConfig[];
        name: string;
    }, schema: ODataSchema, parser: P);
}

declare const EDM_PARSERS: {
    [type: string]: FieldParser<any>;
};

declare class ODataEnumTypeFieldParser extends ODataAnnotatable {
    name: string;
    value: number;
    constructor(name: string, field: ODataEnumTypeFieldConfig);
    titleize(term?: string | RegExp): string;
}
declare class ODataEnumTypeParser<E> extends ODataAnnotatable implements FieldParser<E> {
    name: string;
    namespace: string;
    alias?: string;
    flags?: boolean;
    members: {
        [name: string]: number;
    } | {
        [value: number]: string;
    };
    private _fields;
    parserOptions?: ParserOptions;
    constructor(config: ODataEnumTypeConfig, namespace: string, alias?: string);
    configure({ options }: {
        options: ParserOptions;
    }): void;
    isTypeOf(type: string): boolean;
    fields(namesValue?: string | number | number[]): ODataEnumTypeFieldParser[];
    field(nameValue: string | number): ODataEnumTypeFieldParser | undefined;
    /**
     * 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) => R): R[];
    deserialize(value: string, options?: ParserOptions): E;
    serialize(value: E, options?: ParserOptions): string | undefined;
    encode(value: E, options?: ParserOptions): any;
    toJsonSchema(): {
        title: string;
        type: JsonType;
        items: {
            type: JsonType;
        };
        enum?: undefined;
    } | {
        type: JsonType;
        enum: number[];
        title?: undefined;
        items?: undefined;
    };
    validate(value: string | number, { method, navigation, }?: {
        method?: 'create' | 'update' | 'modify';
        navigation?: boolean;
    }): string[] | undefined;
    unpack(value: string | number): number[];
    pack(value: string | number | number[]): number;
}

type JsonSchemaSelect<T> = Array<keyof T>;
type JsonSchemaCustom<T> = {
    [P in keyof T]?: (schema: any, field: ODataStructuredTypeFieldParser<T[P]>) => any;
};
type JsonSchemaExpand<T> = {
    [P in keyof T]?: JsonSchemaOptions<T[P]>;
};
type JsonSchemaRequired<T> = {
    [P in keyof T]?: boolean;
};
type JsonSchemaOptions<T> = {
    select?: JsonSchemaSelect<T>;
    custom?: JsonSchemaCustom<T>;
    expand?: JsonSchemaExpand<T>;
    required?: JsonSchemaRequired<T>;
};
declare class ODataEntityTypeKey {
    name: string;
    alias?: string;
    constructor({ name, alias }: {
        name: string;
        alias?: string;
    });
}
declare class ODataReferential {
    property: string;
    referencedProperty: string;
    constructor({ property, referencedProperty }: {
        property: string;
        referencedProperty: string;
    });
}
declare class ODataStructuredTypeFieldParser<T> extends ODataAnnotatable implements FieldParser<T> {
    name: string;
    private structured;
    type: string | EdmType;
    private parser;
    collection: boolean;
    navigation: boolean;
    nullable?: boolean;
    default?: any;
    maxLength?: number;
    precision?: number;
    scale?: number | 'variable';
    referentials: ODataReferential[];
    parserOptions?: ParserOptions;
    constructor(name: string, structured: ODataStructuredTypeParser<any>, field: ODataStructuredTypeFieldConfig);
    validate(value: any, { method, navigation, }?: {
        method?: 'create' | 'update' | 'modify';
        navigation?: boolean;
    }): {
        [name: string]: any;
    } | {
        [name: string]: any;
    }[] | string[] | undefined;
    private parse;
    deserialize(value: any, options?: ParserOptions): T | T[];
    private toJson;
    serialize(value: T, options?: ParserOptions): any;
    encode(value: T, options?: ParserOptions): string;
    configure({ options, parserForType, }: {
        options: ParserOptions;
        parserForType: (type: string) => Parser<any>;
    }): void;
    toJsonSchema(options?: JsonSchemaOptions<T>): any;
    isKey(): boolean;
    hasReferentials(): boolean;
    isEdmType(): boolean;
    isEnumType(): boolean;
    enumType(): ODataEnumTypeParser<T>;
    isStructuredType(): boolean;
    structuredType(): ODataStructuredTypeParser<T>;
    field<F>(name: string): ODataStructuredTypeFieldParser<F>;
}
declare class ODataStructuredTypeParser<T> extends ODataAnnotatable implements Parser<T> {
    name: string;
    namespace: string;
    open: boolean;
    children: ODataStructuredTypeParser<any>[];
    alias?: string;
    base?: string;
    parent?: ODataStructuredTypeParser<any>;
    private _keys?;
    private _fields;
    parserOptions?: ParserOptions;
    constructor(config: ODataStructuredTypeConfig, namespace: string, alias?: string);
    addField<F>(name: string, config: ODataStructuredTypeFieldConfig): ODataStructuredTypeFieldParser<F>;
    /**
     * Create a nicer looking title.
     * Titleize is meant for creating pretty output.
     * @param term The term of the annotation to find.
     * @returns The titleized string.
     */
    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>;
    deserialize(value: any, options?: ParserOptions): T;
    serialize(value: Partial<T>, options?: ParserOptions): any;
    encode(value: T, options?: ParserOptions): any;
    configure({ options, parserForType, }: {
        options: ParserOptions;
        parserForType: (type: string) => Parser<any>;
    }): void;
    /**
     * 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[];
    isEntityType(): boolean;
    isComplexType(): boolean;
    /**
     * 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_id, include_key, include_parents, include_navigation, include_computed, include_etag, options, }?: {
        include_id?: boolean;
        include_key?: boolean;
        include_parents?: boolean;
        include_navigation?: boolean;
        include_computed?: boolean;
        include_etag?: boolean;
        options?: ParserOptions;
    }): Partial<T>;
    resolveKey(value: any, { resolve, single }?: {
        resolve?: boolean;
        single?: boolean;
    }): any;
    defaults(): {
        [name: string]: any;
    };
    toJsonSchema(options?: JsonSchemaOptions<T>): any;
    validate(attrs: any, { method, navigation, }?: {
        create?: boolean;
        method?: 'create' | 'update' | 'modify';
        navigation?: boolean;
    }): {
        [name: string]: any;
    } | undefined;
}

declare class ODataParameterParser<T> {
    name: string;
    type: string;
    private parser;
    collection?: boolean;
    nullable?: boolean;
    parserOptions?: ParserOptions;
    constructor(name: string, parameter: ODataParameterConfig);
    serialize(value: T, options?: ParserOptions): any;
    encode(value: any, options?: ParserOptions): any;
    configure({ options, parserForType, }: {
        options: ParserOptions;
        parserForType: (type: string) => Parser<any>;
    }): void;
    isEdmType(): boolean;
    isEnumType(): boolean;
    enumType(): ODataEnumTypeParser<T>;
    isStructuredType(): boolean;
    structuredType(): ODataStructuredTypeParser<T>;
    field<F>(name: string): angular_odata.ODataStructuredTypeFieldParser<F>;
}
declare class ODataCallableParser<R> implements Parser<R> {
    name: string;
    namespace: string;
    alias?: string;
    return?: {
        type: string;
        collection?: boolean;
    };
    parser: Parser<any>;
    parameters: ODataParameterParser<any>[];
    parserOptions?: ParserOptions;
    constructor(config: ODataCallableConfig, namespace: string, alias?: string);
    isTypeOf(type: string): boolean;
    deserialize(value: any, options?: ParserOptions): R;
    serialize(params: any, options?: ParserOptions): any;
    encode(params: any, options?: ParserOptions): any;
    configure({ options, parserForType, }: {
        options: ParserOptions;
        parserForType: (type: string) => Parser<any>;
    }): void;
    binding(): ODataParameterParser<any> | undefined;
    returnType(): string | undefined;
}

declare class ODataCallable<R> extends ODataParserSchemaElement<R, ODataCallableParser<R>> {
    entitySetPath?: string;
    bound?: boolean;
    composable?: boolean;
    constructor(config: ODataCallableConfig, schema: ODataSchema);
    path(): string;
    configure({ options }: {
        options: ParserOptions;
    }): void;
    /**
     * Deseialize the given value from the callable.
     * @param value Value to deserialize
     * @param options Options for deserialization
     * @returns Deserialized value
     */
    deserialize(value: any, options?: ParserOptions): any;
    /**
     * Serialize the given value for the callable.
     * @param value Value to serialize
     * @param options Options for serialization
     * @returns Serialized value
     */
    serialize(value: any, options?: ParserOptions): any;
    /**
     * Encode the given value for the callable.
     * @param value Value to encode
     * @param options Options for encoding
     * @returns Encoded value
     */
    encode(value: any, options?: ParserOptions): any;
    /**
     * Returns the binding parameter of the callable.
     * @returns The binding parameter of the callable.
     */
    binding(): angular_odata.ODataParameterParser<any> | undefined;
    returnType(): string | undefined;
}

declare class ODataEntitySet extends ODataSchemaElement {
    entityType: string;
    service: {
        new (...params: any[]): any;
    };
    constructor(config: ODataEntitySetConfig, schema: ODataSchema);
}

declare class ODataSingleton extends ODataSchemaElement {
    singletonType: string;
    service: {
        new (...params: any[]): any;
    };
    constructor(config: ODataSingletonConfig, schema: ODataSchema);
}

declare class ODataEntityContainer extends ODataSchemaElement {
    entitySets: ODataEntitySet[];
    singletons: ODataSingleton[];
    constructor(config: ODataEntityContainerConfig, schema: ODataSchema);
}

declare class ODataEnumType<E> extends ODataParserSchemaElement<E, ODataEnumTypeParser<E>> {
    members: {
        [name: string]: number;
    } | {
        [value: number]: string;
    };
    constructor(config: ODataEnumTypeConfig, schema: ODataSchema);
    configure({ options }: {
        options: ParserOptions;
    }): void;
    /**
     * Returns the fields of the enum type.
     * @returns The fields of the enum type.
     */
    fields(namesValue?: string | number): ODataEnumTypeFieldParser[];
    /**
     * 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
     */
    field(nameValue: string | number): ODataEnumTypeFieldParser | undefined;
    /**
     * 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[];
    /**
     * Deseialize the given value from the enum type.
     * @param value Value to deserialize
     * @param options Options for deserialization
     * @returns Deserialized value
     */
    deserialize(value: any, options?: ParserOptions): E;
    /**
     * Serialize the given value for the enum type.
     * @param value Value to serialize
     * @param options Options for serialization
     * @returns Serialized value
     */
    serialize(value: E, options?: ParserOptions): any;
    /**
     * Encode the given value for the enum type.
     * @param value Value to encode
     * @param options Options for encoding
     * @returns Encoded value
     */
    encode(value: E, options?: ParserOptions): any;
    unpack(value: string | number): number[];
    pack(value: string | number | number[]): number;
}

declare class ODataModel<T> {
    static options: ModelOptions;
    static meta: ODataModelOptions<any>;
    _parent: [ODataModel<any> | ODataCollection<any, ODataModel<any>>, ODataModelField<any> | null] | null;
    _resource: ODataResource<T> | null;
    _resources: {
        parent: [ODataModel<any> | ODataCollection<any, ODataModel<any>>, ODataModelField<any> | null] | null;
        resource: ODataResource<T> | null;
    }[];
    _attributes: Map<string, ODataModelAttribute<any>>;
    _annotations: ODataEntityAnnotations<T>;
    _meta: ODataModelOptions<any>;
    events$: ODataModelEventEmitter<T>;
    static buildMetaOptions<T>({ config, structuredType, }: {
        config?: ModelOptions;
        structuredType: ODataStructuredType<T>;
    }): ODataModelOptions<T>;
    constructor(data?: Partial<T> | {
        [name: string]: any;
    }, { parent, resource, annots, reset, }?: {
        parent?: [
            ODataModel<any> | ODataCollection<any, ODataModel<any>>,
            ODataModelField<any> | null
        ];
        resource?: ODataResource<T> | null;
        annots?: ODataEntityAnnotations<T>;
        reset?: boolean;
    });
    resource(): ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T> | null;
    pushResource(resource: ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T> | null): void;
    popResource(): {
        parent: [ODataModel<any> | ODataCollection<any, ODataModel<any>>, ODataModelField<any> | null] | null;
        resource: ODataResource<T> | null;
    } | undefined;
    navigationProperty<N>(name: keyof T | string): ODataNavigationPropertyResource<N>;
    property<N>(name: string): ODataPropertyResource<N>;
    attach(resource: ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T>): void;
    schema(): ODataStructuredType<any>;
    annots(): ODataEntityAnnotations<T>;
    key({ field_mapping, resolve, }?: {
        field_mapping?: boolean;
        resolve?: boolean;
    }): EntityKey<T> | {
        [name: string]: any;
    } | undefined;
    isOpenModel(): boolean;
    isParentOf(child: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
    referential(attr: ODataModelAttribute<any> | ODataModelField<any>, { field_mapping, resolve }?: {
        field_mapping?: boolean;
        resolve?: boolean;
    }): {
        [name: string]: any;
    } | null | undefined;
    referenced(attr: ODataModelAttribute<any> | ODataModelField<any>, { field_mapping, resolve }?: {
        field_mapping?: boolean;
        resolve?: boolean;
    }): {
        [name: string]: any;
    } | null | undefined;
    _errors?: {
        [name: string]: any;
    };
    validate({ method, navigation, }?: {
        method?: 'create' | 'update' | 'modify';
        navigation?: boolean;
    }): {
        [name: string]: string[];
    } | undefined;
    isValid({ method, navigation, }?: {
        method?: 'create' | 'update' | 'modify';
        navigation?: boolean;
    }): boolean;
    defaults(): any;
    toEntity({ client_id, include_navigation, include_concurrency, include_computed, include_key, include_id, include_non_field, changes_only, field_mapping, chain, }?: {
        client_id?: boolean;
        include_navigation?: boolean;
        include_concurrency?: boolean;
        include_computed?: boolean;
        include_key?: boolean;
        include_id?: boolean;
        include_non_field?: boolean;
        changes_only?: boolean;
        field_mapping?: boolean;
        chain?: (ODataModel<any> | ODataCollection<any, ODataModel<any>>)[];
    }): T | {
        [name: string]: any;
    };
    toJson(): T | {
        [name: string]: any;
    };
    set(path: keyof T | string | string[], value: any, { type }?: {
        type?: EdmType | string;
    }): any;
    get(path: keyof T | string | string[]): any;
    has(path: keyof T | string | string[]): boolean;
    reset({ path, silent }?: {
        path?: keyof T | string | string[];
        silent?: boolean;
    }): void;
    clear({ silent }?: {
        silent?: boolean;
    }): void;
    assign(entity: Partial<T> | {
        [name: string]: any;
    }, { add, merge, remove, reset, reparent, silent, }?: {
        add?: boolean;
        merge?: boolean;
        remove?: boolean;
        reset?: boolean;
        reparent?: boolean;
        silent?: boolean;
    }): this;
    clone<M extends ODataModel<T>>(): M;
    private _request;
    fetch({ ...options }?: ODataOptions & {
        options?: ODataOptions;
    }): Observable<this>;
    save({ method, navigation, validate, ...options }?: ODataOptions & {
        method?: 'create' | 'update' | 'modify';
        navigation?: boolean;
        validate?: boolean;
        options?: ODataOptions;
    }): Observable<this>;
    destroy({ ...options }?: ODataOptions & {
        options?: ODataOptions;
    }): Observable<any>;
    /**
     * Create an execution context for change the internal query of a resource
     * @param ctx Function to execute
     */
    query(ctx: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): this;
    /**
     * Perform a check on the internal state of the model and return true if the model is changed.
     * @param include_navigation Check in navigation properties
     * @returns true if the model has changed, false otherwise
     */
    hasChanged({ include_navigation }?: {
        include_navigation?: boolean;
    }): boolean;
    encode<E>(name: keyof T, options?: ParserOptions): any;
    isNew(): boolean;
    withResource<R>(resource: any, ctx: (model: this) => R): R;
    /**
     * Create an execution context for a given function, where the model is bound to its entity endpoint
     * @param ctx Context function
     * @returns The result of the context
     */
    asEntity<R>(ctx: (model: this) => R): R;
    callFunction<P, R>(name: string, params: P | null, responseType: 'property' | 'model' | 'collection' | 'none' | 'blob' | 'arraybuffer', options?: ODataFunctionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null | Blob | ArrayBuffer>;
    callAction<P, R>(name: string, params: P | null, responseType?: 'property' | 'model' | 'collection' | 'none' | 'blob' | 'arraybuffer', { ...options }?: {} & ODataActionOptions<R>): Observable<R | ODataModel<R> | ODataCollection<R, ODataModel<R>> | null | Blob | ArrayBuffer>;
    cast<S>(type: string, ModelType?: typeof ODataModel): ODataModel<T> & ModelInterface<T>;
    cast<S, M extends ODataModel<S>>(type: string, ModelType?: typeof ODataModel): M;
    fetchNavigationProperty<S>(name: keyof T | string, responseType: 'model' | 'collection', options?: ODataQueryArgumentsOptions<S>): Observable<ODataModel<S> | ODataCollection<S, ODataModel<S>> | null>;
    fetchAttribute<P>(name: keyof T, options?: ODataQueryArgumentsOptions<P>): Observable<P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null>;
    getAttribute<P>(name: keyof T | string): P | ODataModel<P> | ODataCollection<P, ODataModel<P>> | null;
    setAttribute<N>(name: keyof T, model: ODataModel<N> | ODataCollection<N, ODataModel<N>> | null, options?: ODataOptions): Observable<this>;
    setReference<N>(name: keyof T | string, model: ODataModel<N> | ODataCollection<N, ODataModel<N>> | null, options?: ODataOptions): Observable<this>;
    get [Symbol.toStringTag](): string;
    equals(other: ODataModel<T>): boolean;
    collection(): ODataCollection<T, ODataModel<T>> | undefined;
    next(): ODataModel<T> | undefined;
    prev(): ODataModel<T> | undefined;
}

declare class ODataCollection<T, M extends ODataModel<T>> implements Iterable<M> {
    static model: typeof ODataModel<any> | null;
    _parent: [ODataModel<any> | ODataCollection<any, ODataModel<any>>, ODataModelField<any> | null] | null;
    _resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null;
    _resources: {
        parent: [ODataModel<any> | ODataCollection<any, ODataModel<any>>, ODataModelField<any> | null] | null;
        resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null;
    }[];
    _annotations: ODataEntitiesAnnotations<T>;
    _entries: ODataModelEntry<T, M>[];
    _model: typeof ODataModel;
    models(): M[];
    get length(): number;
    events$: ODataModelEventEmitter<T>;
    constructor(entities?: Partial<T>[] | {
        [name: string]: any;
    }[], { parent, resource, annots, model, reset, }?: {
        parent?: [ODataModel<any>, ODataModelField<any>];
        resource?: ODataResource<T> | null;
        annots?: ODataEntitiesAnnotations<T>;
        model?: typeof ODataModel;
        reset?: boolean;
    });
    isParentOf(child: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
    resource(): ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null;
    pushResource(resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null): void;
    popResource(): {
        parent: [ODataModel<any> | ODataCollection<any, ODataModel<any>>, ODataModelField<any> | null] | null;
        resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null;
    } | undefined;
    attach(resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T>): void;
    withResource<R>(resource: ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null, ctx: (collection: this) => R): R;
    asEntitySet<R>(ctx: (collection: this) => R): R;
    annots(): ODataEntitiesAnnotations<T>;
    private modelFactory;
    toEntities({ client_id, include_navigation, include_concurrency, include_computed, include_key, include_id, include_non_field, changes_only, field_mapping, chain, }?: {
        client_id?: boolean;
        include_navigation?: boolean;
        include_concurrency?: boolean;
        include_computed?: boolean;
        include_key?: boolean;
        include_id?: boolean;
        include_non_field?: boolean;
        changes_only?: boolean;
        field_mapping?: boolean;
        chain?: (ODataModel<any> | ODataCollection<any, ODataModel<any>>)[];
    }): (Partial<T> | {
        [name: string]: any;
    })[];
    toJson(): (Partial<T> | {
        [name: string]: any;
    })[];
    hasChanged({ include_navigation }?: {
        include_navigation?: boolean;
    }): boolean;
    clone<C extends ODataCollection<T, M>>(): C;
    private _request;
    fetch({ add, merge, remove, withCount, ...options }?: ODataOptions & {
        add?: boolean;
        merge?: boolean;
        remove?: boolean;
        withCount?: boolean;
    }): Observable<M[]>;
    fetchAll({ add, merge, remove, withCount, ...options }?: ODataOptions & {
        add?: boolean;
        merge?: boolean;
        remove?: boolean;
        withCount?: boolean;
    }): Observable<M[]>;
    fetchMany(top: number, { add, merge, remove, withCount, ...options }?: ODataOptions & {
        add?: boolean;
        merge?: boolean;
        remove?: boolean;
        withCount?: boolean;
    }): Observable<M[]>;
    fetchOne({ add, merge, remove, withCount, ...options }?: ODataOptions & {
        add?: boolean;
        merge?: boolean;
        remove?: boolean;
        withCount?: boolean;
    }): Observable<M | null>;
    /**
     * Save all models in the collection
     * @param relModel The model is relationship
     * @param method The method to use
     * @param options HttpOptions
     */
    save({ relModel, method, ...options }?: ODataOptions & {
        relModel?: boolean;
        method?: 'update' | 'modify';
    }): Observable<M[]>;
    private _addServer;
    private _addModel;
    add(model: M, { silent, reparent, server, merge, position, reset, }?: {
        silent?: boolean;
        reparent?: boolean;
        server?: boolean;
        merge?: boolean;
        position?: number;
        reset?: boolean;
    }): Observable<M>;
    private _removeServer;
    private _removeModel;
    remove(model: M, { silent, server, reset, }?: {
        silent?: boolean;
        server?: boolean;
        reset?: boolean;
    }): Observable<M>;
    private _moveModel;
    create(attrs?: T, { silent, server }?: {
        silent?: boolean;
        server?: boolean;
    }): Observable<M>;
    set(path: string | string[], value: any, {}: {} & ModelFieldOptions): any;
    get(path: number): M | undefined;
    get(path: string | string[]): any;
    has(path: number | string | string[]): boolean;
    reset({ path, silent }?: {
        path?: string | string[];
        silent?: boolean;
    }): void;
    clear({ silent }?: {
        silent?: boolean;
    }): void;
    assign(objects: Partial<T>[] | {
        [name: string]: any;
    }[] | M[], { add, merge, remove, reset, reparent, silent, }?: {
        add?: boolean;
        merge?: boolean;
        remove?: boolean;
        reset?: boolean;
        reparent?: boolean;
        silent?: boolean;
    }): M[];
    query(ctx: (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;
    private _link;
    private _findEntry;
    equals(other: ODataCollection<T, ODataModel<T>>): boolean;
    get [Symbol.toStringTag](): string;
    [Symbol.iterator](): Iterator<M>;
    filter(predicate: (value: M, index: number, array: M[]) => unknown, thisArg?: any): M[];
    map<U>(callbackfn: (value: M, index: number, array: M[]) => U, thisArg?: any): U[];
    find(predicate: (value: M, index: number, obj: M[]) => unknown): M | undefined;
    reduce<U>(callbackfn: (previousValue: U, currentValue: M, currentIndex: number, array: M[]) => U, initialValue: U): U;
    first(): M | undefined;
    last(): M | undefined;
    next(model: M): M | undefined;
    prev(model: M): M | undefined;
    every(predicate: (m: M, index: number) => boolean): boolean;
    some(predicate: (m: M, index: number) => boolean): boolean;
    includes(model: M, start?: number): boolean;
    indexOf(model: M): number;
    forEach(predicate: (value: M, index: number, array: M[]) => void, thisArg?: any): void;
    isEmpty(): boolean;
    private _compare;
    _sortBy: {
        field: string | keyof T;
        order?: 1 | -1;
    }[] | null;
    isSorted(): boolean;
    sort(by: {
        field: string | keyof T;
        order?: 1 | -1;
        comparator?: (a: any, b: any) => number;
    }[], { silent }?: {
        silent?: boolean;
    }): void;
}

declare class ODataStructuredType<T> extends ODataParserSchemaElement<T, ODataStructuredTypeParser<T>> {
    base?: string;
    parent?: ODataStructuredType<any>;
    children: ODataStructuredType<any>[];
    model?: typeof ODataModel<any>;
    collection?: typeof ODataCollection<any, ODataModel<any>>;
    constructor(config: ODataStructuredTypeConfig, schema: ODataSchema);
    configure({ options }: {
        options: ParserOptions;
    }): void;
    /**
     * Returns a boolean indicating if the structured type is a subtype of the given type.
     * @param type String representation of the type
     * @returns True if the callable is type of the given type
     */
    isSubtypeOf(schema: ODataStructuredType<any>): boolean;
    /**
     * Returns a boolean indicating if the structured type is a supertype of the given type.
     * @param type String representation of the type
     * @returns True if the callable is type of the given type
     */
    isSupertypeOf(schema: ODataStructuredType<any>): boolean;
    /**
     * Returns a boolean indicating if the structured type has a simple key.
     * @returns True if the structured type has a simple key
     */
    isSimpleKey(): boolean;
    /**
     * Returns a boolean indicating if the structured type has a compound key.
     * @returns True if the structured type has a compound key.
     */
    isCompoundKey(): boolean;
    isOpenType(): boolean;
    isEntityType(): boolean;
    isComplexType(): boolean;
    /**
     * 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>;
    addField<F>(name: string, config: ODataStructuredTypeFieldConfig): ODataStructuredTypeFieldParser<F>;
    /**
     * Find a parent schema of the structured type.
     * @param predicate Function for evaluate the schemas in the hierarchy.
     * @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
     */
    findParentSchemaForField<E>(field: ODataStructuredTypeFieldParser<any>): ODataStructuredType<E>;
    /**
     * 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_id, include_key, include_parents, include_navigation, include_computed, include_etag, }?: {
        include_id?: boolean;
        include_key?: boolean;
        include_parents?: boolean;
        include_navigation?: boolean;
        include_computed?: boolean;
        include_etag?: boolean;
    }): Partial<T>;
    /**
     * Deseialize the given value from the structured type.
     * @param value Value to deserialize
     * @param options Options for deserialization
     * @returns Deserialized value
     */
    deserialize(value: any, options?: ParserOptions): T;
    /**
     * Serialize the given value for the structured type.
     * @param value Value to serialize
     * @param options Options for serialization
     * @returns Serialized value
     */
    serialize(value: T, options?: ParserOptions): any;
    /**
     * Encode the given value for the structured type.
     * @param value Value to encode
     * @param options Options for encoding
     * @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
     * @returns Resolved key
     */
    resolveKey(attrs: T | {
        [name: string]: any;
    }): any;
    /**
     * Returns the defaults values for the structured type.
     * @returns Default values for the structured type
     */
    defaults(): {
        [name: string]: any;
    };
    /**
     * Convert the structured type to json schema
     * @param options Options for json schema
     * @returns Json Schema
     */
    toJsonSchema(options?: JsonSchemaOptions<T>): any;
    /**
     * Validate the given value against the structured type.
     * @param attrs Attributes of the value
     * @param method Method to use for the process validation
     * @returns Object with the errors
     */
    validate(attrs: Partial<T>, { method, navigation, }?: {
        method?: 'create' | 'update' | 'modify';
        navigation?: boolean;
    }): {
        [name: string]: any;
    } | undefined;
}

declare class ODataSchema extends ODataAnnotatable {
    api: ODataApi;
    namespace: string;
    alias?: string;
    enums: ODataEnumType<any>[];
    entities: ODataStructuredType<any>[];
    callables: ODataCallable<any>[];
    containers: ODataEntityContainer[];
    constructor(config: ODataSchemaConfig, api: ODataApi);
    isNamespaceOf(type: string): boolean;
    get entitySets(): ODataEntitySet[];
    get singletons(): ODataSingleton[];
    createStructuredType<T>(config: ODataStructuredTypeConfig): ODataStructuredType<T>;
    configure({ options }: {
        options: ParserOptions;
    }): void;
}

type ODataOptions = {
    etag?: string;
    context?: HttpContext;
    headers?: HttpHeaders | {
        [header: string]: string | string[];
    };
    params?: HttpParams | {
        [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
    };
    reportProgress?: boolean;
    withCredentials?: boolean;
    fetchPolicy?: FetchPolicy;
    parserOptions?: ParserOptions;
};
type ODataEntityOptions = ODataOptions & {
    responseType?: 'entity';
};
type ODataEntitiesOptions = ODataOptions & {
    responseType?: 'entities';
    withCount?: boolean;
};
type ODataPropertyOptions = ODataOptions & {
    responseType?: 'property';
};
type ODataQueryArgumentsOptions<T> = ODataOptions & ODataQueryArguments<T>;
type ODataActionOptions<T> = ODataQueryArgumentsOptions<T>;
type ODataFunctionOptions<T> = ODataQueryArgumentsOptions<T> & {
    alias?: boolean;
};

declare class ODataRequest<T> {
    readonly api: ODataApi;
    readonly observe: 'events' | 'response';
    readonly context?: HttpContext;
    readonly reportProgress?: boolean;
    readonly withCredentials?: boolean;
    readonly bodyQueryOptions: QueryOption[];
    readonly fetchPolicy: 'cache-first' | 'cache-and-network' | 'network-only' | 'no-cache' | 'cache-only';
    readonly resource: ODataResource<T>;
    private readonly _responseType?;
    private readonly _method;
    private readonly _body;
    private readonly _headers;
    private readonly _params;
    private readonly _path;
    constructor(init: {
        method: string;
        api: ODataApi;
        resource: ODataResource<T>;
        body: any;
        observe: 'events' | 'response';
        context?: HttpContext;
        etag?: string;
        headers?: HttpHeaders | {
            [header: string]: string | string[];
        };
        reportProgress?: boolean;
        params?: HttpParams | {
            [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
        };
        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
        fetchPolicy?: FetchPolicy;
        parserOptions?: ParserOptions;
        withCredentials?: boolean;
        bodyQueryOptions?: QueryOption[];
    });
    static factory(api: ODataApi, method: string, resource: ODataResource<any>, options: ODataOptions & {
        body?: any;
        etag?: string;
        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
        observe: 'events' | 'response';
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): ODataRequest<any>;
    get responseType(): 'arraybuffer' | 'blob' | 'json' | 'text';
    get path(): string;
    get method(): string;
    get body(): any;
    get params(): HttpParams;
    get headers(): HttpHeaders;
    get pathWithParams(): string;
    get url(): string;
    get urlWithParams(): string;
    get cacheKey(): string;
    isQueryBody(): boolean;
    isBatch(): boolean;
    isFetch(): boolean;
    isMutate(): boolean;
}

declare class ODataResponseOptions implements ResponseOptions {
    version: ODataVersion;
    streaming?: boolean;
    metadata?: ODataMetadataType;
    ieee754Compatible?: boolean;
    location?: string;
    cacheability?: 'public' | 'private' | 'no-cache' | 'no-store';
    maxAge?: number;
    constructor(config: ParserOptions);
    get helper(): ODataVersionHelper;
    clone(): ODataResponseOptions;
    setFeatures(features: string): void;
    setVersion(version: string): void;
    setLocation(location: string): void;
    setPreferenceApplied(preference: string): void;
    setCache(cacheControl: string): void;
}

type ODataEntity<T> = {
    entity: T | null;
    annots: ODataEntityAnnotations<T>;
};
type ODataEntities<T> = {
    entities: T[] | null;
    annots: ODataEntitiesAnnotations<T>;
};
type ODataProperty<T> = {
    property: T | null;
    annots: ODataPropertyAnnotations<T>;
};
type ODataResponseJson<T> = {
    body: T | null;
    headers: {
        [name: string]: string | string[];
    };
    status: number;
    statusText: string;
    url: string | null;
};
/**
 * OData Response
 */
declare class ODataResponse<T> extends HttpResponse<T> {
    readonly api: ODataApi;
    readonly resource: ODataResource<T>;
    constructor(init: {
        api: ODataApi;
        resource: ODataResource<T>;
        body: T | null;
        headers: HttpHeaders;
        status: number;
        statusText: string;
        url?: string;
    });
    static fromHttpResponse<T>(req: ODataRequest<T>, res: HttpResponse<T>): ODataResponse<T>;
    static fromJson<T>(req: ODataRequest<T>, json: ODataResponseJson<T>): ODataResponse<T>;
    toJson(): ODataResponseJson<T>;
    private _options?;
    get options(): ODataResponseOptions;
    private _payload?;
    get payload(): any;
    private _context?;
    get context(): ODataContext;
    private _annotations?;
    get annotations(): Map<string, any>;
    /**
     * Handle the response body as an entity
     * @returns
     */
    entity(): ODataEntity<T>;
    /**
     * Handle the response body as entities
     * @returns
     */
    entities(): ODataEntities<T>;
    /**
     * Handle the response body as a property
     * @returns
     */
    property(): ODataProperty<T>;
    /**
     * Handle the response body as a value
     * @returns
     */
    value(): T | null;
}

declare class ODataActionResource<P, R> extends ODataResource<R> {
    static factory<P, R>(api: ODataApi, { path, outgoingType, incomingType, bindingType, segments, }: {
        path: string;
        outgoingType?: string;
        incomingType?: string;
        bindingType?: string;
        segments?: ODataPathSegments;
    }): ODataActionResource<P, R>;
    static fromResource<P, R>(resource: ODataResource<any>, path: string): ODataActionResource<P, R>;
    clone(): ODataActionResource<P, R>;
    protected post(params: P | null, options?: ODataEntityOptions & ODataEntitiesOptions & ODataPropertyOptions): Observable<any>;
    /**
     * Execute the action
     * @param params Parameters to be sent to the action
     * @param options Options for the request
     */
    call(params: P | null, options?: ODataEntityOptions): Observable<ODataEntity<R>>;
    call(params: P | null, options?: ODataEntitiesOptions): Observable<ODataEntities<R>>;
    call(params: P | null, options?: ODataPropertyOptions): Observable<ODataProperty<R>>;
    call(params: P | null, options?: {
        alias?: boolean;
        responseType?: 'blob';
    } & ODataOptions): Observable<Blob>;
    call(params: P | null, options?: {
        alias?: boolean;
        responseType?: 'arraybuffer';
    } & ODataOptions): Observable<ArrayBuffer>;
    call(params: P | null, options?: {
        alias?: boolean;
        responseType?: 'none';
    } & ODataOptions): Observable<null>;
    /**
     * Execute the action and return the result as a property
     * @param params Parameters for the action
     * @param options Options for the request
     * @returns Observable of the result of the action
     */
    callProperty(params: P | null, options?: ODataOptions): Observable<R | null>;
    /**
     * Execute the action and return the result as a entity
     * @param params Parameters for the action
     * @param options Options for the request
     * @returns Observable of the result of the action
     */
    callEntity(params: P | null, options?: ODataOptions): Observable<R | null>;
    /**
     * Execute the action and return the result as a model
     * @param params Parameters for the action
     * @param options Options for the request
     * @returns Observable of the result of the action
     */
    callModel(params: P | null, options?: ODataOptions & {
        ModelType?: typeof ODataModel;
    }): Observable<(ODataModel<R> & angular_odata.ModelInterface<R>) | null>;
    /**
     * Execute the action and return the result as a entities
     * @param params Parameters for the action
     * @param options Options for the request
     * @returns Observable of the result of the action
     */
    callEntities(params: P | null, options?: ODataOptions): Observable<R[] | null>;
    /**
     * Execute the action and return the result as a collection
     * @param params Parameters for the action
     * @param options Options for the request
     * @returns Observable of the result of the action
     */
    callCollection(params: P | null, options?: ODataOptions & {
        CollectionType?: typeof ODataCollection;
    }): Observable<ODataCollection<R, ODataModel<R> & angular_odata.ModelInterface<R>> | null>;
    callArraybuffer(params: P | null, { alias, ...options }?: {
        alias?: boolean;
    } & ODataOptions): Observable<ArrayBuffer>;
    callBlob(params: P | null, { alias, ...options }?: {
        alias?: boolean;
    } & ODataOptions): Observable<Blob>;
}

declare class ODataApiOptions implements ODataApiConfigOptions {
    /**
     * Default OData version
     */
    version: ODataVersion;
    /**
     * Send enum as string in the request
     */
    stringAsEnum: boolean;
    /**
     * Delete reference by path or by id
     */
    deleteRefBy: 'path' | 'id';
    /**
     * No use parenthesis for empty parameters functions
     */
    nonParenthesisForEmptyParameterFunction: boolean;
    /**
     * Strip metadata from the response
     */
    stripMetadata: ODataMetadataType;
    /**
     * Use JSON Batch Format
     */
    jsonBatchFormat: boolean;
    /**
     * Relative urls
     * http://docs.oasis-open.org/odata/odata-json-format/v4.0/cs01/odata-json-format-v4.0-cs01.html#_Toc365464682
     */
    relativeUrls: boolean;
    /**
     * Cache fetch policy
     */
    fetchPolicy: FetchPolicy;
    /**
     * Extra params to be sent in the request
     */
    params: {
        [param: string]: string | string[];
    };
    /**
     * Extra headers to be sent in the request
     */
    headers: {
        [param: string]: string | string[];
    };
    /**
     * Http request with credentials
     */
    withCredentials?: boolean;
    /**
     * Send query options in the request body
     */
    bodyQueryOptions: QueryOption[];
    /**
     * Customize accept header with OData options
     * @link http://docs.oasis-open.org/odata/odata-json-format/v4.01/odata-json-format-v4.01.html#sec_RequestingtheJSONFormat
     */
    accept?: {
        exponentialDecimals?: boolean;
        ieee754Compatible?: boolean;
        metadata?: ODataMetadataType;
        streaming?: boolean;
    };
    etag: {
        /**
         * @link http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part1-protocol/odata-v4.0-errata02-os-part1-protocol-complete.html#_Toc406398229
         */
        ifMatch: boolean;
        /**
         * @link http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part1-protocol/odata-v4.0-errata02-os-part1-protocol-complete.html#_Toc406398230
         */
        ifNoneMatch: boolean;
    };
    prefer?: {
        /**
         * @link http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part1-protocol/odata-v4.0-errata02-os-part1-protocol-complete.html#_Toc406398238
         */
        maxPageSize?: number;
        /**
         * @link http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part1-protocol/odata-v4.0-errata02-os-part1-protocol-complete.html#_Toc406398240
         */
        return?: 'representation' | 'minimal';
        /**
         * @link http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part1-protocol/odata-v4.0-errata02-os-part1-protocol-complete.html#_Toc406398236
         */
        continueOnError?: boolean;
        /**
         * @link http://docs.oasis-open.org/odata/odata/v4.0/errata02/os/complete/part1-protocol/odata-v4.0-errata02-os-part1-protocol-complete.html#_Toc406398237
         */
        includeAnnotations?: string;
        /**
         * @link https://devblogs.microsoft.com/odata/extension-omit-null-value-properties-in-asp-net-core-odata/
         */
        omitNullValues?: boolean;
    };
    constructor(config: ODataApiConfigOptions);
    get parserOptions(): ParserOptions;
    get helper(): ODataVersionHelper;
}

declare class ODataBatchRequest<T> extends Subject<HttpResponseBase> {
    request: ODataRequest<any>;
    id: string;
    group: string;
    constructor(request: ODataRequest<any>);
    toString(): string;
    toLegacy({ relativeUrls }?: {
        relativeUrls?: boolean;
    }): string;
    toJson({ relativeUrls }?: {
        relativeUrls?: boolean;
    }): {
        [name: string]: any;
    };
    onLoad(response: HttpResponseBase): void;
    onError(response: HttpErrorResponse): void;
}
/**
 * OData Batch Resource
 * https://www.odata.org/getting-started/advanced-tutorial/#batch
 */
declare class ODataBatchResource extends ODataResource<any> {
    private _requests;
    requests(): ODataRequest<any>[];
    private _responses;
    responses(): HttpResponseBase[] | null;
    static factory(api: ODataApi): ODataBatchResource;
    clone(): ODataBatchResource;
    private storeRequester;
    private restoreRequester;
    /**
     * Add to batch request
     * @param ctx The context for the request
     * @returns The result of execute the context
     */
    add<R>(ctx: (batch: this) => R): R;
    send(options?: ODataOptions): Observable<ODataResponse<any>>;
    private sendJson;
    private sendLegacy;
    /**
     * Execute the batch request
     * @param ctx The context for the request
     * @param options The options of the batch request
     * @returns The result of execute the context
     */
    exec<R>(ctx: (batch: this) => R, options?: ODataOptions): Observable<[R, ODataResponse<string>]>;
    body(): string;
    json(): Object;
    static buildLegacyBody(batchBoundary: string, requests: ODataBatchRequest<any>[], options: ODataApiOptions): string;
    static buildJsonBody(requests: ODataBatchRequest<any>[], options: ODataApiOptions): Object;
    static parseLegacyResponse(requests: ODataBatchRequest<any>[], response: ODataResponse<string>): HttpResponseBase[];
    static parseJsonResponse(requests: ODataBatchRequest<any>[], response: ODataResponse<any>): HttpResponseBase[];
}

declare class ODataCountResource<T> extends ODataResource<T> {
    static factory<T>(api: ODataApi, { segments, query, }: {
        segments: ODataPathSegments;
        query?: ODataQueryOptions<T>;
    }): ODataCountResource<T>;
    clone(): ODataCountResource<T>;
    protected get(options?: ODataOptions): Observable<any>;
    /**
     * Fetch the count of the set.
     * @param options Options for the request
     * @returns The count of the set
     */
    fetch(options?: ODataOptions): Observable<number>;
}

declare class ODataFunctionResource<P, R> extends ODataResource<R> {
    static factory<P, R>(api: ODataApi, { path, outgoingType, incomingType, bindingType, segments, }: {
        path: string;
        outgoingType?: string;
        incomingType?: string;
        bindingType?: string;
        segments?: ODataPathSegments;
    }): ODataFunctionResource<P, R>;
    static fromResource<P, R>(resource: ODataResource<any>, path: string): ODataFunctionResource<P, R>;
    clone(): ODataFunctionResource<P, R>;
    parameters(params: P | null, { alias }?: {
        alias?: boolean;
    }): ODataFunctionResource<P, R>;
    protected get(options?: ODataEntityOptions & ODataEntitiesOptions & ODataPropertyOptions): Observable<any>;
    /**
     * Execute the function
     * @param params Parameters to be sent to the function
     * @param alias If true, the parameters will be send using aliases
     * @param options Options for the request
     */
    call(params: P | null, options?: {
        alias?: boolean;
    } & ODataEntityOptions): Observable<ODataEntity<R>>;
    call(params: P | null, options?: {
        alias?: boolean;
    } & ODataEntitiesOptions): Observable<ODataEntities<R>>;
    call(params: P | null, options?: {
        alias?: boolean;
    } & ODataPropertyOptions): Observable<ODataProperty<R>>;
    call(params: P | null, options?: {
        alias?: boolean;
        responseType?: 'blob';
    } & ODataOptions): Observable<Blob>;
    call(params: P | null, options?: {
        alias?: boolean;
        responseType?: 'arraybuffer';
    } & ODataOptions): Observable<ArrayBuffer>;
    call(params: P | null, options?: {
        alias?: boolean;
        responseType?: 'none';
    } & ODataOptions): Observable<null>;
    /**
     * Execute the function with the given parameters and return the result as a property
     * @param params Parameters to be sent to the function
     * @param alias If true, the parameters will be send using aliases
     * @param options Options for the request
     * @returns Observable of the result of the function
     */
    callProperty(params: P | null, { alias, ...options }?: {
        alias?: boolean;
    } & ODataOptions): Observable<R | null>;
    /**
     * Execute the function with the given parameters and return the result as a entity
     * @param params Parameters to be sent to the function
     * @param alias If true, the parameters will be send using aliases
     * @param options Options for the request
     * @returns Observable of the result of the function
     */
    callEntity(params: P | null, { alias, ...options }?: {
        alias?: boolean;
    } & ODataOptions): Observable<R | null>;
    /**
     * Execute the function with the given parameters and return the result as a model
     * @param params Parameters to be sent to the function
     * @param alias If true, the parameters will be send using aliases
     * @param options Options for the request
     * @returns Observable of the result of the function
     */
    callModel(params: P | null, { alias, ModelType, ...options }?: ODataOptions & {
        alias?: boolean;
        ModelType?: typeof ODataModel;
    }): Observable<(ODataModel<R> & angular_odata.ModelInterface<R>) | null>;
    /**
     * Execute the function with the given parameters and return the result as a entities
     * @param params Parameters to be sent to the function
     * @param alias If true, the parameters will be send using aliases
     * @param options Options for the request
     * @returns Observable of the result of the function
     */
    callEntities(params: P | null, { alias, ...options }?: {
        alias?: boolean;
    } & ODataOptions): Observable<R[] | null>;
    /**
     * Execute the function with the given parameters and return the result as a collection
     * @param params Parameters to be sent to the function
     * @param alias If true, the parameters will be send using aliases
     * @param options Options for the request
     * @returns Observable of the result of the function
     */
    callCollection(params: P | null, { alias, CollectionType, ...options }?: {
        alias?: boolean;
        CollectionType?: typeof ODataCollection;
    } & ODataOptions): Observable<ODataCollection<R, ODataModel<R> & angular_odata.ModelInterface<R>> | null>;
    callArraybuffer(params: P | null, { alias, ...options }?: {
        alias?: boolean;
    } & ODataOptions): Observable<ArrayBuffer>;
    callBlob(params: P | null, { alias, ...options }?: {
        alias?: boolean;
    } & ODataOptions): Observable<Blob>;
}

declare class ODataMediaResource extends ODataResource<any> {
    static factory<V>(api: ODataApi, { segments, query, }: {
        segments: ODataPathSegments;
        query?: ODataQueryOptions<V>;
    }): ODataMediaResource;
    clone(): ODataMediaResource;
    protected get(options: {
        responseType: 'arraybuffer' | 'blob';
    } & ODataOptions): Observable<any>;
    protected put(data: ArrayBuffer | Blob, options?: ODataOptions): Observable<any>;
    fetch(options: {
        responseType: 'arraybuffer';
    } & ODataOptions): Observable<ArrayBuffer>;
    fetch(options: {
        responseType: 'blob';
    } & ODataOptions): Observable<Blob>;
    fetchArraybuffer(options?: ODataOptions): Observable<ArrayBuffer>;
    fetchBlob(options?: ODataOptions): Observable<Blob>;
    upload(data: ArrayBuffer | Blob, options?: ODataOptions): Observable<any>;
    uploadArrayBuffer(data: ArrayBuffer, contentType: string, options?: ODataOptions): Observable<any>;
    uploadBlob(data: Blob, options?: ODataOptions): Observable<any>;
}

declare class ODataValueResource<T> extends ODataResource<T> {
    static factory<V>(api: ODataApi, { segments, }: {
        segments: ODataPathSegments;
    }): ODataValueResource<V>;
    static fromResource<V>(resource: ODataResource<any>): ODataValueResource<V>;
    clone(): ODataValueResource<T>;
    protected get(options?: ODataOptions): Observable<T>;
    /**
     * Fetch the value of the resource.
     * @param options OData options.
     * @returns Observable of the value.
     */
    fetch(options?: ODataOptions): Observable<T>;
}

declare class ODataPropertyResource<T> extends ODataResource<T> {
    static factory<P>(api: ODataApi, { path, type, segments, }: {
        path: string;
        type?: string;
        segments: ODataPathSegments;
    }): ODataPropertyResource<P>;
    static fromResource<N>(resource: ODataResource<any>, path: string): ODataPropertyResource<N>;
    clone(): ODataPropertyResource<T>;
    transform<R>(opts: (builder: ApplyExpressionBuilder<T>, current?: ApplyExpression<T>) => ApplyExpression<T>, { type, fields, }?: {
        type?: string;
        fields?: {
            [name: string]: ODataStructuredTypeFieldConfig;
        };
    }): ODataPropertyResource<R>;
    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>;
    /**
     * Fetch the property
     * @param options Options for the request
     * @return The entity / entities / property value
     */
    fetch(options?: ODataEntityOptions): Observable<ODataEntity<T>>;
    fetch(options?: ODataEntitiesOptions): Observable<ODataEntities<T>>;
    fetch(options?: ODataPropertyOptions): Observable<ODataProperty<T>>;
    /**
     * Fetch the property value
     * @param options Options for the request
     * @returns The property value
     */
    fetchProperty(options?: ODataOptions): Observable<T | null>;
    /**
     * Fetch the entity
     * @param options Options for the request
     * @returns The entity
     */
    fetchEntity(options?: ODataOptions): Observable<T | null>;
    /**
     * Fetch the entity and return as model
     * @param options Options for the request
     * @returns The model
     */
    fetchModel(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
        ModelType?: typeof ODataModel;
    }): Observable<(ODataModel<T> & ModelInterface<T>) | null>;
    fetchModel<M extends ODataModel<T>>(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
        ModelType?: typeof ODataModel;
    }): Observable<M | null>;
    /**
     * Fetch the entities
     * @param options Options for the request
     * @returns The entities
     */
    fetchEntities(options?: ODataOptions & {
        withCount?: boolean;
    }): Observable<T[] | null>;
    /**
     * Fetch the entities and return as collection
     * @param options Options for the request
     * @returns The collection
     */
    fetchCollection(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
        CollectionType?: typeof ODataCollection;
    }): Observable<ODataCollection<T, ODataModel<T> & ModelInterface<T>> | null>;
    fetchCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
        CollectionType?: typeof ODataCollection;
    }): Observable<C | null>;
    fetchOne(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): Observable<{
        entity: T | null;
        annots: ODataEntitiesAnnotations<T>;
    }>;
    fetchMany(top: number, options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): Observable<{
        entities: T[];
        annots: ODataEntitiesAnnotations<T>;
    }>;
    /**
     * Fetch all entities
     * @param options Options for the request
     * @returns All entities
     */
    fetchAll(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): Observable<{
        entities: T[];
        annots: ODataEntitiesAnnotations<T>;
    }>;
}

declare class ODataReferenceResource<T> extends ODataResource<T> {
    static factory<P>(api: ODataApi, { segments }: {
        segments: ODataPathSegments;
    }): ODataReferenceResource<P>;
    clone(): ODataReferenceResource<T>;
    protected post(target: ODataEntityResource<any>, options?: ODataOptions): Observable<any>;
    protected put(target: ODataEntityResource<any>, options?: ODataOptions): Observable<any>;
    protected delete({ etag, target, ...options }?: {
        etag?: string;
        target?: ODataEntityResource<any>;
    } & ODataOptions): Observable<any>;
    /**
     * Add the given target to the collection.
     * @param target The target resource
     * @param options Options for the request
     * @returns Observable of the response
     */
    add(target: ODataEntityResource<any>, options?: ODataOptions): Observable<any>;
    /**
     * Remove the given target from the collection.
     * @param target The target resource
     * @param options Options for the request
     * @returns Observable of the response
     */
    remove(target?: ODataEntityResource<any>, options?: ODataOptions): Observable<any>;
    /**
     * Set the reference to the given target.
     * @param target The target resource
     * @param options Options for the request
     * @returns Observable of the response
     */
    set(target: ODataEntityResource<any>, options?: ODataOptions): Observable<any>;
    /**
     * Unset the reference to the given target.
     * @param options Options for the request.
     * @returns Observable of the response
     */
    unset(options?: ODataOptions): Observable<any>;
    /**
     * Fetch entity / entities
     * @param options Options for the request
     * @return An observable of the entity or entities with annotations
     */
    fetch(options?: ODataEntityOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<ODataEntity<T>>;
    fetch(options?: ODataEntitiesOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<ODataEntities<T>>;
    /**
     * Fetch the entity
     * @param options Options for the request
     * @returns The entity
     */
    fetchEntity(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<T | null>;
    /**
     * Fetch entities
     * @param options Options for the request
     * @returns The entities
     */
    fetchEntities(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<T[] | null>;
}

/**
 * OData Navigation Property Resource
 * https://www.odata.org/getting-started/advanced-tutorial/#containment
 * https://www.odata.org/getting-started/advanced-tutorial/#derived
 */
declare class ODataNavigationPropertyResource<T> extends ODataResource<T> {
    static factory<N>(api: ODataApi, { path, type, segments, }: {
        path: string;
        type?: string;
        segments: ODataPathSegments;
    }): ODataNavigationPropertyResource<N>;
    static fromResource<N>(resource: ODataResource<any>, path: string): ODataNavigationPropertyResource<N>;
    clone(): ODataNavigationPropertyResource<T>;
    transform<R>(opts: (builder: ApplyExpressionBuilder<T>, current?: ApplyExpression<T>) => ApplyExpression<T>, { type, fields, }?: {
        type?: string;
        fields?: {
            [name: string]: ODataStructuredTypeFieldConfig;
        };
    }): ODataNavigationPropertyResource<R>;
    key(value: any): ODataNavigationPropertyResource<T>;
    keys(values: any[]): ODataNavigationPropertyResource<T>;
    media(): ODataMediaResource;
    reference(): ODataReferenceResource<T>;
    navigationProperty<N>(path: string): ODataNavigationPropertyResource<N>;
    property<P>(path: string): ODataPropertyResource<P>;
    count(): ODataCountResource<T>;
    cast<C>(type: string): ODataNavigationPropertyResource<C>;
    protected post(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
    protected put(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
    protected patch(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
    protected delete(options?: ODataOptions): Observable<any>;
    protected get(options?: ODataEntityOptions & ODataEntitiesOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<any>;
    /**
     * Create a new entity
     * @param attrs The entity attributes
     * @param options Options for the request
     * @returns The created entity with the annotations
     */
    create(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
    /**
     * Update an existing entity
     * @param attrs The entity attributes
     * @param options Options for the request
     * @returns The updated entity with the annotations
     */
    update(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
    /**
     * Modify an existing entity
     * @param attrs The entity attributes
     * @param options Options for the request
     * @returns The modified entity with the annotations
     */
    modify(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
    /**
     * Delete an existing entity
     * @param options Options for the request
     * @returns An observable of the destroy
     */
    destroy(options?: ODataOptions): Observable<any>;
    /**
     * Fetch entity / entities
     * @param options Options for the request
     * @return An observable of the entity or entities with annotations
     */
    fetch(options?: ODataEntityOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<ODataEntity<T>>;
    fetch(options?: ODataEntitiesOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<ODataEntities<T>>;
    /**
     * Fetch the entity
     * @param options Options for the request
     * @returns The entity
     */
    fetchEntity(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<T | null>;
    /**
     * Fetch the entity and return as model
     * @param options Options for the request
     * @returns The model
     */
    fetchModel(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
        ModelType?: typeof ODataModel;
    }): Observable<(ODataModel<T> & ModelInterface<T>) | null>;
    fetchModel<M extends ODataModel<T>>(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
        ModelType?: typeof ODataModel;
    }): Observable<M | null>;
    /**
     * Fetch entities
     * @param options Options for the request
     * @returns The entities
     */
    fetchEntities(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<T[] | null>;
    /**
     * Fetch entities and return as collection
     * @param options Options for the request
     * @returns The collection
     */
    fetchCollection(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
        CollectionType?: typeof ODataCollection;
    }): Observable<ODataCollection<T, ODataModel<T> & ModelInterface<T>> | null>;
    fetchCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
        CollectionType?: typeof ODataCollection;
    }): Observable<C | null>;
    /**
     * Fetch all entities
     * @param options Options for the request
     * @returns All entities
     */
    fetchAll(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): Observable<{
        entities: T[];
        annots: ODataEntitiesAnnotations<T>;
    }>;
    fetchMany(top: number, options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): Observable<{
        entities: T[];
        annots: ODataEntitiesAnnotations<T>;
    }>;
    fetchOne(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): Observable<{
        entity: T | null;
        annots: ODataEntitiesAnnotations<T>;
    }>;
}

declare class ODataEntityResource<T> extends ODataResource<T> {
    static factory<E>(api: ODataApi, { segments, query, }: {
        segments: ODataPathSegments;
        query?: ODataQueryOptions<E>;
    }): ODataEntityResource<E>;
    clone(): ODataEntityResource<T>;
    key(value: any): ODataEntityResource<T>;
    keys(values: any[]): ODataEntityResource<T>;
    media(): ODataMediaResource;
    navigationProperty<N>(path: string): ODataNavigationPropertyResource<N>;
    property<P>(path: string): ODataPropertyResource<P>;
    action<P, R>(path: string): ODataActionResource<P, R>;
    function<P, R>(path: string): ODataFunctionResource<P, R>;
    cast<C>(type: string): ODataEntityResource<C>;
    protected post(attrs: Partial<T>, options?: ODataOptions): Observable<any>;
    protected put(attrs: Partial<T>, options?: ODataOptions): Observable<any>;
    protected patch(attrs: Partial<T>, options?: ODataOptions): Observable<any>;
    protected delete(options?: ODataOptions): Observable<any>;
    protected get(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<any>;
    create(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
    update(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
    modify(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
    destroy(options?: ODataOptions): Observable<any>;
    fetch(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<ODataEntity<T>>;
    fetchEntity(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<T | null>;
    fetchModel(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
        ModelType?: typeof ODataModel;
    }): Observable<(ODataModel<T> & ModelInterface<T>) | null>;
    fetchModel<M extends ODataModel<T>>(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
        ModelType?: typeof ODataModel;
    }): Observable<M | null>;
}

declare class ODataEntitySetResource<T> extends ODataResource<T> {
    static factory<E>(api: ODataApi, { path, type, query, }: {
        path: string;
        type?: string;
        query?: ODataQueryOptions<E>;
    }): ODataEntitySetResource<E>;
    clone(): ODataEntitySetResource<T>;
    transform<R>(opts: (builder: ApplyExpressionBuilder<T>, current?: ApplyExpression<T>) => ApplyExpression<T>, { type, fields, }?: {
        type?: string;
        fields?: {
            [name: string]: ODataStructuredTypeFieldConfig;
        };
    }): ODataEntitySetResource<R>;
    entity(key?: any): ODataEntityResource<T>;
    action<P, R>(path: string): ODataActionResource<P, R>;
    function<P, R>(path: string): ODataFunctionResource<P, R>;
    count(): ODataCountResource<T>;
    cast<C>(type: string): ODataEntitySetResource<C>;
    protected post(attrs: Partial<T>, options?: ODataOptions): Observable<any>;
    protected get(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): Observable<any>;
    create(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
    fetch(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): Observable<ODataEntities<T>>;
    fetchAll(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): Observable<{
        entities: any[];
        annots: angular_odata.ODataEntitiesAnnotations<any>;
    }>;
    fetchMany(top: number, options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): Observable<{
        entities: T[];
        annots: angular_odata.ODataEntitiesAnnotations<T>;
    } | {
        entities: T[];
        annots: angular_odata.ODataEntitiesAnnotations<any>;
    }>;
    fetchOne(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): Observable<{
        entity: T | null;
        annots: angular_odata.ODataEntitiesAnnotations<T>;
    }>;
    fetchEntities(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): Observable<T[] | null>;
    fetchCollection(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
        CollectionType?: typeof ODataCollection;
    }): Observable<ODataCollection<T, ODataModel<T> & ModelInterface<T>> | null>;
    fetchCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(options?: ODataOptions & {
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
        CollectionType?: typeof ODataCollection;
    }): Observable<C | null>;
}

declare class CsdlTypeDefinition extends CsdlAnnotable {
    private schema;
    Name: string;
    UnderlayingType: string;
    MaxLength?: number;
    Precision?: number;
    Scale?: number;
    Unicode?: boolean;
    SRID?: string;
    constructor(schema: CsdlSchema, { Name, UnderlayingType, MaxLength, Precision, Scale, Unicode, SRID, Annotation, }: {
        Name: string;
        UnderlayingType: string;
        MaxLength?: number;
        Precision?: number;
        Scale?: number;
        Unicode?: boolean;
        SRID?: string;
        Annotation?: CsdlAnnotation[];
    });
    toJson(): {
        [key: string]: any;
    };
}

declare class CsdlEnumType extends CsdlAnnotable {
    private schema;
    Name: string;
    Member: CsdlMember[];
    UnderlyingType?: string;
    IsFlags?: boolean;
    constructor(schema: CsdlSchema, { Name, Member, UnderlyingType, IsFlags, Annotation, }: {
        Name: string;
        Member: any[];
        UnderlyingType?: string;
        IsFlags?: boolean;
        Annotation?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    name(): string;
    namespace(): string;
    fullName(): string;
    toConfig(base?: Partial<ODataEnumTypeConfig>): ODataEnumTypeConfig;
}
declare class CsdlMember extends CsdlAnnotable {
    Name: string;
    Value?: number;
    constructor({ Name, Value, Annotation }: {
        Name: string;
        Value?: number;
        Annotation?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    toConfig(base?: Partial<ODataEnumTypeFieldConfig>): ODataEnumTypeFieldConfig;
}

declare abstract class CsdlStructuralProperty extends CsdlAnnotable {
    Name: string;
    Type: string;
    Collection: boolean;
    Nullable?: boolean;
    constructor({ Name, Type, Nullable, Annotation, }: {
        Name: string;
        Type: string;
        Nullable?: boolean;
        Annotation?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
}
declare class CsdlProperty extends CsdlStructuralProperty {
    MaxLength?: number;
    Precision?: number;
    Scale?: number;
    Unicode?: boolean;
    SRID?: string;
    DefaultValue?: string;
    constructor({ Name, Type, Nullable, MaxLength, Precision, Scale, Unicode, SRID, DefaultValue, Annotation, }: {
        Name: string;
        Type: string;
        Nullable?: boolean;
        MaxLength?: number;
        Precision?: number;
        Scale?: number;
        Unicode?: boolean;
        SRID?: string;
        DefaultValue?: string;
        Annotation?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    toConfig(): ODataStructuredTypeFieldConfig & {
        name: string;
    };
}
declare class CsdlNavigationProperty extends CsdlStructuralProperty {
    Partner?: string;
    ContainsTarget?: boolean;
    ReferentialConstraints?: CsdlReferentialConstraint[];
    OnDelete?: CsdlOnDelete;
    constructor({ Name, Type, Nullable, Partner, ContainsTarget, ReferentialConstraints, OnDelete, Annotation, }: {
        Name: string;
        Type: string;
        Nullable?: boolean;
        Partner?: string;
        ContainsTarget?: boolean;
        ReferentialConstraints?: any[];
        OnDelete?: any;
        Annotation?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    toConfig(): ODataStructuredTypeFieldConfig & {
        name: string;
    };
}
declare class CsdlReferentialConstraint {
    Property: string;
    ReferencedProperty: string;
    constructor({ Property, ReferencedProperty }: {
        Property: string;
        ReferencedProperty: string;
    });
    toJson(): {
        Property: string;
        ReferencedProperty: string;
    };
}
declare class CsdlOnDelete {
    Action: string;
    constructor({ Action }: {
        Action: string;
    });
    toJson(): {
        Action: string;
    };
}

declare class CsdlStructuredType extends CsdlAnnotable {
    private schema;
    Name: string;
    Property?: CsdlProperty[];
    NavigationProperty?: CsdlNavigationProperty[];
    BaseType?: string;
    OpenType?: boolean;
    Abstract?: boolean;
    constructor(schema: CsdlSchema, { Name, Property, NavigationProperty, BaseType, OpenType, Abstract, Annotation, }: {
        Name: string;
        Property?: any[];
        NavigationProperty?: any[];
        BaseType?: string;
        OpenType?: boolean;
        Abstract?: boolean;
        Annotation?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    name(): string;
    namespace(): string;
    fullName(): string;
}
declare class CsdlComplexType extends CsdlStructuredType {
    constructor(schema: CsdlSchema, { Name, Property, NavigationProperty, BaseType, OpenType, Abstract, Annotation, }: {
        Name: string;
        Property?: any[];
        NavigationProperty?: any[];
        BaseType?: string;
        OpenType?: boolean;
        Abstract?: boolean;
        Annotation?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    toConfig(base?: Partial<ODataStructuredTypeConfig>): ODataStructuredTypeConfig;
}
declare class CsdlEntityType extends CsdlStructuredType {
    Key?: CsdlKey;
    HasStream?: boolean;
    constructor(schema: CsdlSchema, { Name, Key, Property, NavigationProperty, BaseType, OpenType, Abstract, HasStream, Annotation, }: {
        Name: string;
        Key?: any;
        Property?: any[];
        NavigationProperty?: any[];
        BaseType?: string;
        OpenType?: boolean;
        Abstract?: boolean;
        HasStream?: boolean;
        Annotation?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    toConfig(base?: Partial<ODataStructuredTypeConfig>): ODataStructuredTypeConfig;
}
declare class CsdlKey {
    PropertyRef: CsdlPropertyRef[];
    constructor({ PropertyRef }: {
        PropertyRef: any[];
    });
    toJson(): {
        PropertyRef: {
            Name: string;
            Alias: string | undefined;
        }[];
    };
    toConfig(): {
        name: string;
        alias?: string;
    }[];
}
declare class CsdlPropertyRef {
    Name: string;
    Alias?: string;
    constructor({ Name, Alias }: {
        Name: string;
        Alias?: string;
    });
    toJson(): {
        Name: string;
        Alias: string | undefined;
    };
    toConfig(): {
        name: string;
        alias?: string;
    };
}

declare class CsdlNavigationPropertyBinding {
    Path: string;
    Target: string;
    constructor({ Path, Target }: {
        Path: string;
        Target: string;
    });
    toJson(): {
        Path: string;
        Target: string;
    };
}

declare class CsdlEntitySet extends CsdlAnnotable {
    private container;
    Name: string;
    EntityType: string;
    NavigationPropertyBinding?: CsdlNavigationPropertyBinding[];
    IncludeInServiceDocument?: boolean;
    constructor(container: CsdlEntityContainer, { Name, EntityType, NavigationPropertyBinding, IncludeInServiceDocument, Annotation, }: {
        Name: string;
        EntityType: string;
        NavigationPropertyBinding?: any[];
        IncludeInServiceDocument?: boolean;
        Annotation?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    name(): string;
    namespace(): string;
    fullName(): string;
    toConfig(): ODataEntitySetConfig;
}

declare class CsdlSingleton extends CsdlAnnotable {
    private container;
    Name: string;
    Type: string;
    NavigationPropertyBindings?: CsdlNavigationPropertyBinding[];
    constructor(container: CsdlEntityContainer, { Name, Type, NavigationPropertyBindings, Annotation, }: {
        Name: string;
        Type: string;
        NavigationPropertyBindings?: any[];
        Annotation?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    name(): string;
    namespace(): string;
    fullName(): string;
}

declare class CsdlEntityContainer extends CsdlAnnotable {
    private schema;
    Name: string;
    Extend?: string;
    EntitySet?: CsdlEntitySet[];
    Singleton?: CsdlSingleton[];
    FunctionImport?: CsdlFunctionImport[];
    ActionImport?: CsdlActionImport[];
    constructor(schema: CsdlSchema, { Name, Extend, EntitySet, Singleton, FunctionImport, ActionImport, Annotation, }: {
        Name: string;
        Extend?: string;
        EntitySet?: any[];
        Singleton?: any[];
        FunctionImport?: any[];
        ActionImport?: any[];
        Annotation?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    name(): string;
    namespace(): string;
    fullName(): string;
    toConfig(base?: Partial<ODataEntityContainerConfig>): ODataEntityContainerConfig;
}

declare class CsdlSchema {
    Namespace: string;
    Alias?: string;
    EnumType?: CsdlEnumType[];
    ComplexType?: CsdlComplexType[];
    EntityType?: CsdlEntityType[];
    Function?: CsdlFunction[];
    Action?: CsdlAction[];
    EntityContainer?: CsdlEntityContainer[];
    TypeDefinition?: CsdlTypeDefinition[];
    Term?: CsdlTerm[];
    Annotations?: CsdlAnnotations[];
    constructor({ Namespace, Alias, EnumType, ComplexType, EntityType, Function, Action, EntityContainer, TypeDefinition, Term, Annotations, }: {
        Namespace: string;
        Alias?: string;
        EnumType?: any[];
        ComplexType?: any[];
        EntityType?: any[];
        Function?: any[];
        Action?: any[];
        EntityContainer?: any[];
        TypeDefinition?: any[];
        Term?: any[];
        Annotations?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    toConfig(base?: Partial<ODataSchemaConfig>): ODataSchemaConfig;
}

declare class CsdlAnnotable {
    Annotation?: CsdlAnnotation[];
    constructor({ Annotation }: {
        Annotation?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    toConfig(): {
        [key: string]: any;
    };
}
declare class CsdlAnnotations extends CsdlAnnotable {
    private schema;
    Target: string;
    Qualifier?: string;
    constructor(schema: CsdlSchema, { Target, Qualifier, Annotation, }: {
        Target: string;
        Qualifier?: string;
        Annotation: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    toConfig(): ODataAnnotationConfig[];
}
declare class CsdlAnnotation {
    Term: string;
    String?: string;
    Bool?: boolean;
    Int?: number;
    Collection?: CsdlCollection[];
    Record?: CsdlRecord[];
    EnumMember?: CsdlEnumMember[];
    constructor({ Term, String, Bool, Int, Collection, Record, EnumMember, }: {
        Term: string;
        String?: string;
        Bool?: boolean;
        Int?: number;
        Collection?: any[];
        Record?: any[];
        EnumMember?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    toConfig(): ODataAnnotationConfig;
}
declare class CsdlTerm {
    private schema;
    Name: string;
    Type: string;
    BaseTerm?: string;
    DefaultValue?: string;
    AppliesTo?: string;
    Nullable?: boolean;
    MaxLength?: number;
    Precision?: number;
    Scale?: number;
    SRID?: string;
    String?: string;
    Bool?: boolean;
    Int?: number;
    constructor(schema: CsdlSchema, { Name, Type, BaseTerm, DefaultValue, AppliesTo, Nullable, MaxLength, Precision, Scale, SRID, String, Bool, Int, }: {
        Name: string;
        Type: string;
        BaseTerm?: string;
        DefaultValue?: string;
        AppliesTo?: string;
        Nullable?: boolean;
        MaxLength?: number;
        Precision?: number;
        Scale?: number;
        SRID?: string;
        String?: string;
        Bool?: boolean;
        Int?: number;
    });
    toJson(): {
        [key: string]: any;
    };
}
declare class CsdlCollection {
    String: CsdlString[];
    Record: CsdlRecord[];
    PropertyPath: CsdlPropertyPath[];
    NavigationPropertyPath: CsdlNavigationPropertyPath[];
    constructor({ String, Record, PropertyPath, NavigationPropertyPath, }: {
        String: any[];
        Record: any[];
        PropertyPath: any[];
        NavigationPropertyPath: any[];
    });
    toJson(): {
        [key: string]: any;
    };
}
declare class CsdlRecord {
    PropertyValue: CsdlPropertyValue[];
    constructor({ PropertyValue }: {
        PropertyValue: any[];
    });
    toJson(): {
        [key: string]: any;
    };
}
declare class CsdlPropertyValue {
    Name: string;
    String?: string;
    Date?: Date;
    EnumMember?: CsdlEnumMember[];
    constructor({ Name, String, Date, EnumMember, }: {
        Name: string;
        String?: string;
        Date?: Date;
        EnumMember?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
}
declare class CsdlEnumMember {
    TextContent: string;
    constructor({ TextContent }: {
        TextContent: string;
    });
    toJson(): {
        TextContent: string;
    };
}
declare class CsdlString {
    TextContent: string;
    constructor({ TextContent }: {
        TextContent: string;
    });
    toJson(): {
        TextContent: string;
    };
}
declare class CsdlPropertyPath {
    TextContent: string;
    constructor({ TextContent }: {
        TextContent: string;
    });
    toJson(): {
        TextContent: string;
    };
}
declare class CsdlNavigationPropertyPath {
    TextContent: string;
    constructor({ TextContent }: {
        TextContent: string;
    });
    toJson(): {
        TextContent: string;
    };
}

declare class CsdlCallable {
    private schema;
    Name: string;
    ReturnType?: CsdlReturnType;
    IsBound?: boolean;
    EntitySetPath?: string;
    Parameter?: CsdlParameter[];
    constructor(schema: CsdlSchema, { Name, ReturnType, IsBound, EntitySetPath, Parameter, }: {
        Name: string;
        ReturnType?: any;
        IsBound?: boolean;
        EntitySetPath?: string;
        Parameter?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    name(): string;
    namespace(): string;
    fullName(): string;
}
declare class CsdlFunction extends CsdlCallable {
    IsComposable?: boolean;
    constructor(schema: CsdlSchema, { Name, ReturnType, IsBound, EntitySetPath, IsComposable, Parameter, }: {
        Name: string;
        ReturnType: any;
        IsBound?: boolean;
        EntitySetPath?: string;
        IsComposable?: boolean;
        Parameter?: any[];
    });
    toJson(): {
        IsComposable: boolean | undefined;
    };
    toConfig(base?: Partial<ODataCallableConfig>): ODataCallableConfig;
}
declare class CsdlAction extends CsdlCallable {
    constructor(schema: CsdlSchema, { Name, ReturnType, IsBound, EntitySetPath, Parameter, }: {
        Name: string;
        ReturnType?: any;
        IsBound?: boolean;
        EntitySetPath?: string;
        Parameter?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    toConfig(base?: Partial<ODataCallableConfig>): ODataCallableConfig;
}
declare class CsdlFunctionImport {
    private container;
    Name: string;
    FunctionName: string;
    EntitySet?: string;
    IncludeInServiceDocument?: boolean;
    constructor(container: CsdlEntityContainer, { Name, FunctionName, EntitySet, IncludeInServiceDocument, }: {
        Name: string;
        FunctionName: string;
        EntitySet?: string;
        IncludeInServiceDocument?: boolean;
    });
    toJson(): {
        Name: string;
        FunctionName: string;
        EntitySet: string | undefined;
        IncludeInServiceDocument: boolean | undefined;
    };
}
declare class CsdlActionImport {
    private container;
    Name: string;
    Action: string;
    EntitySet?: string;
    constructor(container: CsdlEntityContainer, { Name, Action, EntitySet, }: {
        Name: string;
        Action: string;
        EntitySet?: string;
    });
    toJson(): {
        Name: string;
        Action: string;
        EntitySet: string | undefined;
    };
}
declare class CsdlParameter extends CsdlAnnotable {
    Name: string;
    Type: string;
    Collection: boolean;
    Nullable?: boolean;
    MaxLength?: number;
    Precision?: number;
    Scale?: number;
    SRID?: string;
    constructor({ Name, Type, Nullable, MaxLength, Precision, Scale, SRID, Annotation, }: {
        Name: string;
        Type: string;
        Nullable?: boolean;
        MaxLength?: number;
        Precision?: number;
        Scale?: number;
        SRID?: string;
        Annotation?: any[];
    });
    toJson(): {
        Name: string;
        Type: string;
        Nullable: boolean | undefined;
        MaxLength: number | undefined;
        Precision: number | undefined;
        Scale: number | undefined;
        SRID: string | undefined;
    };
    toConfig(): ODataParameterConfig;
}
declare class CsdlReturnType {
    Type: string;
    Collection: boolean;
    Nullable?: boolean;
    MaxLength?: number;
    Precision?: number;
    Scale?: number;
    SRID?: string;
    constructor({ Type, Nullable, MaxLength, Precision, Scale, SRID, }: {
        Type: string;
        Nullable?: boolean;
        MaxLength?: number;
        Precision?: number;
        Scale?: number;
        SRID?: string;
    });
    toJson(): {
        Type: string;
        Nullable: boolean | undefined;
        MaxLength: number | undefined;
        Precision: number | undefined;
        Scale: number | undefined;
        SRID: string | undefined;
    };
    toConfig(): {
        type: string;
        collection?: boolean | undefined;
    } | undefined;
}

declare class CsdlReference extends CsdlAnnotable {
    Uri: string;
    Include?: CsdlInclude[];
    IncludeAnnotations?: CsdlIncludeAnnotations[];
    constructor({ Uri, Include, IncludeAnnotations, Annotation, }: {
        Uri: string;
        Include?: any[];
        IncludeAnnotations?: any[];
        Annotation?: any[];
    });
    toJson(): {
        [key: string]: any;
    };
    toConfig(base?: Partial<ODataReferenceConfig>): ODataReferenceConfig;
}
declare class CsdlInclude {
    Namespace: string;
    Alias?: string;
    constructor({ Namespace, Alias }: {
        Namespace: string;
        Alias?: string;
    });
    toJson(): {
        Namespace: string;
        Alias: string | undefined;
    };
    toConfig(): {
        namespace: string;
        alias: string | undefined;
    };
}
declare class CsdlIncludeAnnotations {
    TermNamespace: string;
    Qualifier?: string;
    TargetNamespace?: string;
    constructor({ TermNamespace, Qualifier, TargetNamespace, }: {
        TermNamespace: string;
        Qualifier?: string;
        TargetNamespace?: string;
    });
    toJson(): {
        TermNamespace: string;
        Qualifier: string | undefined;
        TargetNamespace: string | undefined;
    };
    toConfig(): {
        termNamespace: string;
        qualifier: string | undefined;
        targetNamespace: string | undefined;
    };
}

declare class ODataMetadata {
    Version: string;
    References: CsdlReference[];
    Schemas: CsdlSchema[];
    constructor(Version: string, References: any[], Schemas: any[]);
    toConfig(base?: Partial<ODataApiConfig>): ODataApiConfig;
    toJson(): {
        Version: string;
        References: {
            [key: string]: any;
        }[];
        Schemas: {
            [key: string]: any;
        }[];
    };
    functions(): CsdlFunction[];
    actions(): CsdlAction[];
    static fromJson(json: any): ODataMetadata;
}

declare class ODataMetadataResource extends ODataResource<any> {
    constructor(api: ODataApi, segments?: ODataPathSegments);
    static factory(api: ODataApi): ODataMetadataResource;
    clone(): ODataMetadataResource;
    protected get(options?: ODataOptions): Observable<any>;
    fetch(options?: ODataOptions): Observable<ODataMetadata>;
}

declare class ODataSingletonResource<T> extends ODataResource<T> {
    static factory<S>(api: ODataApi, { path, type, }: {
        path: string;
        type?: string;
    }): ODataSingletonResource<S>;
    clone(): ODataSingletonResource<T>;
    key(value: any): ODataSingletonResource<T>;
    keys(values: any[]): ODataSingletonResource<T>;
    navigationProperty<N>(path: string): ODataNavigationPropertyResource<N>;
    property<P>(path: string): ODataPropertyResource<P>;
    action<P, R>(path: string): ODataActionResource<P, R>;
    function<P, R>(path: string): ODataFunctionResource<P, R>;
    protected post(attrs: Partial<T>, options?: ODataOptions): Observable<any>;
    protected put(attrs: Partial<T>, options?: ODataOptions): Observable<any>;
    protected patch(attrs: Partial<T>, options?: ODataOptions): Observable<any>;
    protected delete(options?: ODataOptions): Observable<any>;
    protected get(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<any>;
    /**
     * Creates a new entity.
     * @param attrs The entity attributes to create.
     * @param options The options for the request.
     * @returns The created entity with the annotations.
     */
    create(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
    /**
     * Updates an existing entity.
     * @param attrs The entity attributes to update.
     * @param options The options for the request.
     * @returns The updated entity with the annotations.
     */
    update(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
    /**
     * Modifies an existing entity.
     * @param attrs The entity attributes to modify.
     * @param options The options for the request.
     * @returns The modified entity with the annotations.
     */
    modify(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
    /**
     * Delete an existing entity.
     * @param options The options for the request.
     * @returns Observable of the deleted entity.
     */
    destroy(options?: ODataOptions): Observable<any>;
    /**
     * Fetch an existing entity.
     * @param options The options for the request.
     * @returns Observable of the entity with the annotations.
     */
    fetch(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<ODataEntity<T>>;
    /**
     * Fetch an existing entity.
     * @param options The options for the request.
     * @returns Observable of the entity.
     */
    fetchEntity(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
    }): Observable<T | null>;
    /**
     * Fetch an existing entity and return a model.
     * @param options The options for the request.
     * @returns Observable of the entity.
     */
    fetchModel(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
        ModelType?: typeof ODataModel;
    }): Observable<(ODataModel<T> & ModelInterface<T>) | null>;
    fetchModel<M extends ODataModel<T>>(options?: ODataOptions & {
        bodyQueryOptions?: QueryOption[];
        ModelType?: typeof ODataModel;
    }): Observable<M | null>;
}

type EntityKey<T> = {
    readonly [P in keyof T]?: T[P];
} | QueryCustomType | string | number;
declare class ODataResource<T> {
    api: ODataApi;
    protected pathSegments: ODataPathSegments;
    protected queryOptions: ODataQueryOptions<T>;
    constructor(api: ODataApi, { segments, query, }?: {
        segments?: ODataPathSegments;
        query?: ODataQueryOptions<T>;
    });
    /**
     * @returns string The outgoing type of the resource
     */
    outgoingType(): string | undefined;
    /**
     * @returns string The incoming type of the resource
     */
    incomingType(): string | undefined;
    /**
     * @returns string The binding type of the resource
     */
    bindingType(): string | undefined;
    /**
     * @returns string All covered types of the resource
     */
    types(): string[];
    callable(): angular_odata.ODataCallable<any> | undefined;
    enumType(): angular_odata.ODataEnumType<any> | undefined;
    structuredType(): ODataStructuredType<any> | ODataStructuredType<T> | undefined;
    /**
     * @returns boolean The resource has key ?
     */
    hasKey(): boolean;
    hasEntityKey(): boolean;
    clearKey(): void | undefined;
    asModel(entity?: Partial<T> | {
        [name: string]: any;
    }): ODataModel<T> & ModelInterface<T>;
    asModel(entity: Partial<T> | {
        [name: string]: any;
    }, { reset, annots, ModelType, }: {
        reset?: boolean;
        annots?: ODataEntityAnnotations<T>;
        ModelType?: typeof ODataModel<any>;
    }): ODataModel<T> & ModelInterface<T>;
    asModel<M extends ODataModel<T>>(entity?: Partial<T> | {
        [name: string]: any;
    }): M;
    asModel<M extends ODataModel<T>>(entity: Partial<T> | {
        [name: string]: any;
    }, { reset, annots, ModelType, }: {
        reset?: boolean;
        annots?: ODataEntityAnnotations<T>;
        ModelType?: typeof ODataModel<any>;
    }): M;
    asCollection(entities?: Partial<T>[] | {
        [name: string]: any;
    }[]): ODataCollection<T, ODataModel<T> & ModelInterface<T>>;
    asCollection(entities: Partial<T>[] | {
        [name: string]: any;
    }[], { reset, annots, CollectionType, }: {
        reset?: boolean;
        annots?: ODataEntitiesAnnotations<T>;
        CollectionType?: typeof ODataCollection<any, ODataModel<any>>;
    }): ODataCollection<T, ODataModel<T> & ModelInterface<T>>;
    asCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(entities?: Partial<T>[] | {
        [name: string]: any;
    }[]): C;
    asCollection<M extends ODataModel<T>, C extends ODataCollection<T, M>>(entities: Partial<T>[] | {
        [name: string]: any;
    }[], { reset, annots, CollectionType, }: {
        reset?: boolean;
        annots?: ODataEntitiesAnnotations<T>;
        CollectionType?: typeof ODataCollection<any, ODataModel<any>>;
    }): C;
    isTypeOf(other: ODataResource<any>): boolean;
    isSubtypeOf(other: ODataResource<any>): boolean;
    isSupertypeOf(other: ODataResource<any>): boolean;
    isEqualTo(other: ODataResource<any>, test?: 'path' | 'params'): boolean;
    pathAndParams({ escape, ...options }?: ParserOptions & {
        escape?: boolean;
    }): [string, {
        [name: string]: any;
    }];
    endpointUrl({ escape, params, ...options }?: ParserOptions & {
        escape?: boolean;
        params?: boolean;
    }): string;
    toString({ escape, ...options }?: ParserOptions & {
        escape?: boolean;
    }): string;
    clone(): ODataResource<T>;
    private __parser;
    deserialize(value: any, options?: ParserOptions): any;
    serialize(value: any, options?: ParserOptions): any;
    encode(value: any, options?: ParserOptions): any;
    toJson(): {
        segments: any[];
        options: {};
    };
    cloneSegments(): ODataPathSegments;
    clearQuery(): this;
    cloneQuery<P>(): ODataQueryOptions<P>;
    /**
     * Handle the path segments of the resource
     * Create an object handler for mutate the path segments of the resource
     * @param f Function context for handle the segments
     * @returns ODataActionResource
     */
    segment(f: (q: ODataPathSegmentsHandler<T>, s?: ODataStructuredType<T>) => void): this;
    /**
     * Handle the query options of the resource
     * Create an object handler for mutate the query options of the resource
     * @param f Function context for handle the query options
     */
    query(f: (q: ODataQueryOptionsHandler<T>, s?: ODataStructuredType<T>) => void): this;
    transform<R>(opts: (builder: ApplyExpressionBuilder<T>, current?: ApplyExpression<T>) => ApplyExpression<T>, { type, fields, }?: {
        type?: string;
        fields?: {
            [name: string]: ODataStructuredTypeFieldConfig;
        };
    }): ODataResource<R>;
    static resolveKey<T>(value: any, schema?: ODataStructuredType<T>): EntityKey<T> | undefined;
    protected resolveKey(value: any): EntityKey<T> | undefined;
    protected get(options?: ODataOptions & {
        etag?: string;
        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): Observable<any>;
    protected post(body: any, options?: ODataOptions & {
        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
        withCount?: boolean;
    }): Observable<any>;
    protected put(body: any, options?: ODataOptions & {
        etag?: string;
        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
        withCount?: boolean;
    }): Observable<any>;
    protected patch(body: any, options?: ODataOptions & {
        etag?: string;
        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
        withCount?: boolean;
    }): Observable<any>;
    protected delete(options?: ODataOptions & {
        etag?: string;
        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
        withCount?: boolean;
    }): Observable<any>;
}

declare class SegmentHandler {
    private segment;
    constructor(segment: ODataSegment);
    get name(): PathSegment;
    outgoingType(value?: string): string | undefined;
    incomingType(value?: string): string | undefined;
    bindingType(value?: string): string | undefined;
    path(value?: string): string;
    key<T>(value?: EntityKey<T>): EntityKey<T>;
    hasKey(): boolean;
    clearKey(): void;
    parameters<T>(value?: T): T;
    hasParameters(): boolean;
    clearParameters(): void;
}
declare class ODataPathSegmentsHandler<T> {
    protected segments: ODataPathSegments;
    constructor(segments: ODataPathSegments);
    entitySet(): SegmentHandler;
    singleton(): SegmentHandler;
    action(): SegmentHandler;
    function(): SegmentHandler;
    keys(values?: (EntityKey<T> | undefined)[]): (EntityKey<any> | undefined)[];
    property(): SegmentHandler;
    navigationProperty(): SegmentHandler;
}

type ODataSegment = {
    name: PathSegment;
    path: string;
    outgoingType?: string;
    incomingType?: string;
    bindingType?: string;
    key?: any;
    parameters?: any;
};
declare const pathAndParamsFromSegments: (segments: ODataSegment[], { escape, parser, options, }?: {
    escape?: boolean;
    parser?: Parser<any>;
    options?: ParserOptions;
}) => [string, {
    [name: string]: any;
}];
declare class ODataPathSegments {
    private _segments;
    constructor(segments?: ODataSegment[]);
    pathAndParams({ escape, parser, options, }?: {
        escape?: boolean;
        parser?: Parser<any>;
        options?: ParserOptions;
    }): [string, {
        [name: string]: any;
    }];
    types({ key }?: {
        key?: boolean;
    }): string[];
    keys(values?: (EntityKey<any> | undefined)[]): (EntityKey<any> | undefined)[];
    toString({ escape }?: {
        escape?: boolean;
    }): string;
    toJson(): any[];
    static fromJson(json: {
        [name: string]: any;
    }[]): ODataPathSegments;
    clone(): ODataPathSegments;
    find(predicate: (segment: ODataSegment) => boolean): ODataSegment | undefined;
    segments({ key }?: {
        key?: boolean;
    }): SegmentHandler[];
    first({ key }?: {
        key?: boolean;
    }): SegmentHandler | undefined;
    last({ key }?: {
        key?: boolean;
    }): SegmentHandler | undefined;
    add(name: string, path: string): SegmentHandler;
    get(name: string): SegmentHandler;
}

declare enum ODataModelEventType {
    Change = "change",
    Reset = "reset",
    Update = "update",
    Sort = "sort",
    Destroy = "destroy",
    Add = "add",
    Remove = "remove",
    Invalid = "invalid",
    Request = "request",
    Sync = "sync",
    Attach = "attach"
}
declare class ODataModelEvent<T> {
    type: ODataModelEventType | string;
    value?: any;
    previous?: any;
    options?: any;
    constructor(type: ODataModelEventType | string, { model, collection, previous, value, attr, options, bubbles, chain, }?: {
        model?: ODataModel<T>;
        collection?: ODataCollection<T, ODataModel<T>>;
        attr?: ODataModelAttribute<any> | number;
        previous?: any;
        value?: any;
        options?: any;
        bubbles?: boolean;
        chain?: [
            ODataModel<any> | ODataCollection<any, ODataModel<any>>,
            ODataModelAttribute<any> | number | null
        ][];
    });
    chain: [
        ODataModel<any> | ODataCollection<any, ODataModel<any>>,
        ODataModelAttribute<any> | number | null
    ][];
    push(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>, attr: ODataModelAttribute<any> | number): ODataModelEvent<any>;
    bubbles: boolean;
    stopPropagation(): void;
    visited(model: ODataModel<any> | ODataCollection<any, ODataModel<any>>): boolean;
    canContinueWith(self: ODataModel<T> | ODataCollection<T, ODataModel<T>>): boolean;
    get path(): string;
    model?: ODataModel<T>;
    get currentModel(): ODataModel<any> | undefined;
    collection?: ODataCollection<T, ODataModel<T>>;
    get currentCollection(): ODataCollection<any, ODataModel<any>> | undefined;
}
declare class ODataModelEventEmitter<T> extends EventEmitter<ODataModelEvent<T>> {
    model?: ODataModel<T>;
    collection?: ODataCollection<T, ODataModel<T>>;
    constructor({ model, collection, }?: {
        model?: ODataModel<T>;
        collection?: ODataCollection<T, ODataModel<T>>;
    });
    trigger(type: ODataModelEventType | string, { collection, previous, value, attr, options, bubbles, }?: {
        collection?: ODataCollection<T, ODataModel<T>>;
        attr?: ODataModelAttribute<any> | number;
        previous?: any;
        value?: any;
        options?: any;
        bubbles?: boolean;
    }): void;
}
declare const BUBBLES: (ODataModelEventType | string)[];
declare const INCLUDE_SHALLOW: {
    include_concurrency: boolean;
    include_computed: boolean;
    include_key: boolean;
    include_id: boolean;
};
declare const INCLUDE_DEEP: {
    include_concurrency: boolean;
    include_computed: boolean;
    include_key: boolean;
    include_id: boolean;
    include_navigation: boolean;
    include_non_field: boolean;
};
declare enum ODataModelState {
    Added = 0,
    Removed = 1,
    Changed = 2,
    Unchanged = 3
}
type ModelInterface<T> = {
    [P in keyof T]: T[P] extends (infer U)[] ? ODataCollection<U, ODataModel<U> & ModelInterface<U>> : T[P] extends object ? ODataModel<T[P]> & ModelInterface<T[P]> : T[P];
};
type ModelOptions = {
    cid?: string;
    fields: Map<string, ModelFieldOptions>;
};
type ModelFieldOptions = {
    field?: string;
    parser?: ODataStructuredTypeFieldParser<any>;
    default?: any;
    required?: boolean;
    concurrency?: boolean;
    maxLength?: number;
    minLength?: number;
    min?: number;
    max?: number;
    pattern?: RegExp;
};
declare function Model({ cid }?: {
    cid?: string;
}): <T extends {
    new (...args: any[]): {};
}>(constructor: T) => T;
declare function ModelField({ name, ...options }?: {
    name?: string;
} & ModelFieldOptions): (target: any, key: string) => void;
type ODataModelFieldOptions<F> = ModelFieldOptions & {
    name: string;
    field: string;
    parser: ODataStructuredTypeFieldParser<F>;
};
declare class ODataModelField<F> {
    name: string;
    field: string;
    parser: ODataStructuredTypeFieldParser<F>;
    options: ODataModelOptions<any>;
    optionsForType?: (type: string) => ODataModelOptions<any> | undefined;
    modelForType?: (t: string) => typeof ODataModel<any> | undefined;
    collectionForType?: (t: string) => typeof ODataCollection<any, ODataModel<any>> | undefined;
    enumForType?: (t: string) => ODataEnumType<F> | undefined;
    structuredForType?: (t: string) => ODataStructuredType<F> | undefined;
    default?: any;
    required: boolean;
    concurrency: boolean;
    maxLength?: number;
    minLength?: number;
    min?: number;
    max?: number;
    pattern?: RegExp;
    parserOptions?: ParserOptions;
    constructor(options: ODataModelOptions<any>, { name, field, parser, ...opts }: ODataModelFieldOptions<F>);
    get type(): string;
    get navigation(): boolean;
    get collection(): boolean;
    annotatedValue<T>(term: string | RegExp): T | undefined;
    configure({ optionsForType, modelForType, collectionForType, enumForType, structuredForType, concurrency, options, }: {
        optionsForType: (type: string) => ODataModelOptions<any> | undefined;
        modelForType: (t: string) => typeof ODataModel<any> | undefined;
        collectionForType: (t: string) => typeof ODataCollection<any, any> | undefined;
        enumForType: (t: string) => ODataEnumType<any> | undefined;
        structuredForType: (t: string) => ODataStructuredType<any> | undefined;
        concurrency: boolean;
        options: ParserOptions;
    }): void;
    isKey(): boolean;
    hasReferentials(): boolean;
    get referentials(): angular_odata.ODataReferential[];
    isStructuredType(): boolean;
    structuredType(): ODataStructuredType<F>;
    isEnumType(): boolean;
    enumType(): ODataEnumType<F>;
    validate(value: any, { method, navigation, }?: {
        method?: 'create' | 'update' | 'modify';
        navigation?: boolean;
    }): any;
    defaults(): any;
    deserialize(value: any, options?: ParserOptions): F | F[];
    serialize(value: F, options?: ParserOptions): any;
    encode(value: F, options?: ParserOptions): any;
    resourceFactory<T, F>(base: ODataResource<T>): ODataNavigationPropertyResource<F> | ODataPropertyResource<F>;
    annotationsFactory<T, F>(base: ODataEntityAnnotations<T>): ODataEntityAnnotations<F> | ODataEntitiesAnnotations<F>;
    modelFactory<F>({ parent, value, reset, }: {
        parent: ODataModel<any>;
        value?: Partial<F> | {
            [name: string]: any;
        };
        reset?: boolean;
    }): ODataModel<F>;
    collectionFactory<F>({ parent, value, reset, }: {
        parent: ODataModel<any>;
        value?: Partial<F>[] | {
            [name: string]: any;
        }[];
        reset?: boolean;
    }): ODataCollection<F, ODataModel<F>>;
}
declare class ODataModelAttribute<T> {
    private _model;
    private _field;
    private state;
    private value?;
    private change?;
    private subscription?;
    events$: ODataModelEventEmitter<T>;
    constructor(_model: ODataModel<any>, _field: ODataModelField<T>);
    get type(): string;
    get navigation(): boolean;
    get computed(): boolean | undefined;
    get concurrency(): boolean;
    get referentials(): angular_odata.ODataReferential[];
    get options(): ODataModelOptions<any>;
    get name(): string;
    get fieldName(): string;
    get(): T | ODataModel<T> | ODataCollection<T, ODataModel<T>> | null | undefined;
    set(value: T | ODataModel<T> | ODataCollection<T, ODataModel<T>> | null | undefined, reset?: boolean, reparent?: boolean): boolean;
    isChanged({ include_navigation }?: {
        include_navigation?: boolean;
    }): boolean;
    reset(): void;
    private link;
    private unlink;
}
type ODataModelEntry<T, M extends ODataModel<T>> = {
    state: ODataModelState;
    model: M;
    key?: EntityKey<T> | {
        [name: string]: any;
    };
    subscription?: Subscription;
};
declare class ODataModelOptions<T> {
    name: string;
    cid: string;
    base?: string;
    private _fields;
    structuredType: ODataStructuredType<T>;
    entitySet?: ODataEntitySet;
    parent?: ODataModelOptions<any>;
    children: ODataModelOptions<any>[];
    events$: ODataModelEventEmitter<T>;
    constructor({ config, structuredType, }: {
        config: ModelOptions;
        structuredType: ODataStructuredType<T>;
    });
    get api(): angular_odata.ODataApi;
    type({ alias }?: {
        alias?: boolean;
    }): string;
    isOpenType(): boolean;
    isEntityType(): boolean;
    isComplexType(): boolean;
    isTypeOf(type: string): boolean;
    isModelFor(entity: T | {
        [name: string]: any;
    }): boolean;
    findChildOptions(predicate: (options: ODataModelOptions<any>) => boolean): ODataModelOptions<any> | undefined;
    configure({ options }: {
        options: ParserOptions;
    }): void;
    fields({ include_navigation, include_parents, }: {
        include_parents: boolean;
        include_navigation: boolean;
    }): ODataModelField<any>[];
    field<F>(name: keyof T | string): ODataModelField<F>;
    findField<F>(name: keyof T | string, { reset }?: {
        reset?: boolean;
    }): ODataModelField<F> | undefined;
    addField<F>(name: string, options: ModelFieldOptions): ODataModelField<F>;
    tsToEdm: Record<string, EdmType>;
    private modelFieldFactory;
    attach(self: ODataModel<T>, resource: ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T>): void;
    static chain(child: ODataModel<any> | ODataCollection<any, ODataModel<any>>): [ODataModel<any> | ODataCollection<any, ODataModel<any>>, ODataModelField<any> | null][];
    static resource<T>(child: ODataModel<T> | ODataCollection<T, ODataModel<T>>): ODataResource<T> | null;
    collectionResourceFactory(query?: ODataQueryOptions<T>): ODataEntitySetResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | null;
    modelResourceFactory(query?: ODataQueryOptions<T>): ODataEntityResource<T> | ODataNavigationPropertyResource<T> | ODataPropertyResource<T> | ODataSingletonResource<T> | null;
    bind(self: ODataModel<T>, { parent, resource, annots, }?: {
        parent?: [
            ODataModel<any> | ODataCollection<any, ODataModel<any>>,
            ODataModelField<any> | null
        ];
        resource?: ODataResource<T> | null;
        annots?: ODataEntityAnnotations<T>;
    }): void;
    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, single, }?: {
        field_mapping?: boolean;
        resolve?: boolean;
        single?: boolean;
    }): EntityKey<T> | {
        [name: string]: any;
    } | undefined;
    resolveReferential(value: ODataModel<T> | T | {
        [name: string]: any;
    } | null, attr: ODataModelAttribute<any> | 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, attr: ODataModelAttribute<any> | ODataModelField<any>, { field_mapping, resolve, single, }?: {
        field_mapping?: boolean;
        resolve?: boolean;
        single?: boolean;
    }): {
        [name: string]: any;
    } | null | undefined;
    validate(self: ODataModel<T>, { method, navigation, }?: {
        method?: 'create' | 'update' | 'modify';
        navigation?: boolean;
    }): {
        [name: string]: string[];
    } | undefined;
    defaults(): T | {
        [name: string]: any;
    } | undefined;
    hasChanged(self: ODataModel<T>, { include_navigation }?: {
        include_navigation?: boolean;
    }): boolean;
    hasKey(self: ODataModel<T>): boolean;
    withResource<R, M extends ODataModel<T>>(self: M, resource: ODataEntityResource<T> | ODataPropertyResource<T> | ODataNavigationPropertyResource<T> | ODataSingletonResource<T> | null, ctx: (model: M) => R): R;
    asEntity<R, M extends ODataModel<T>>(self: M, ctx: (model: M) => R): R;
    toEntity(self: ODataModel<T>, { client_id, include_navigation, include_concurrency, include_computed, include_key, include_id, include_non_field, changes_only, field_mapping, chain, }?: {
        client_id?: boolean;
        include_navigation?: boolean;
        include_concurrency?: boolean;
        include_computed?: boolean;
        include_key?: boolean;
        include_id?: boolean;
        include_non_field?: boolean;
        changes_only?: boolean;
        field_mapping?: boolean;
        chain?: (ODataModel<any> | ODataCollection<any, ODataModel<any>>)[];
    }): T | {
        [name: string]: any;
    };
    reset(self: ODataModel<T>, { name, silent }?: {
        name?: string;
        silent?: boolean;
    }): void;
    assign(self: ODataModel<T>, entity: Partial<T> | {
        [name: string]: any;
    }, { add, merge, remove, reset, reparent, silent, }?: {
        add?: boolean;
        merge?: boolean;
        remove?: boolean;
        reset?: boolean;
        reparent?: boolean;
        silent?: boolean;
    }): ODataModel<T>;
    static isModel(obj: any): boolean;
    static isCollection(obj: any): boolean;
    get<F>(self: ODataModel<T>, field: ODataModelField<F> | string): F | ODataModel<F> | ODataCollection<F, ODataModel<F>> | null | undefined;
    set<F>(self: ODataModel<T>, field: ODataModelField<F> | string, value: F | F[] | {
        [name: string]: any;
    } | {
        [name: string]: any;
    }[] | ODataModel<F> | ODataCollection<F, ODataModel<F>> | null, { add, merge, remove, reset, reparent, silent, type, }?: {
        add?: boolean;
        merge?: boolean;
        remove?: boolean;
        reset?: boolean;
        reparent?: boolean;
        silent?: boolean;
        type?: EdmType | string;
    }): boolean;
    private _link;
}

/**
 * Api abstraction for consuming OData services.
 */
declare class ODataApi {
    requester?: (request: ODataRequest<any>) => Observable<any>;
    serviceRootUrl: string;
    metadataUrl: string;
    name?: string;
    version: ODataVersion;
    default: boolean;
    creation: Date;
    options: ODataApiOptions;
    cache?: ODataCache;
    errorHandler?: (error: any, caught: Observable<any>) => Observable<never>;
    parsers: Map<string, Parser<any>>;
    schemas: ODataSchema[];
    models: {
        [type: string]: typeof ODataModel<any>;
    };
    collections: {
        [type: string]: typeof ODataCollection<any, ODataModel<any>>;
    };
    constructor(config: ODataApiConfig);
    configure(settings?: {
        requester?: (request: ODataRequest<any>) => Observable<any>;
    }): void;
    populate(metadata: ODataMetadata): void;
    fromJson<P, R>(json: {
        segments: ODataSegment[];
        options: {
            [name: string]: any;
        };
    }): ODataActionResource<P, R> | ODataFunctionResource<P, R>;
    fromJson<E>(json: {
        segments: ODataSegment[];
        options: {
            [name: string]: any;
        };
    }): ODataEntityResource<E> | ODataEntitySetResource<E> | ODataNavigationPropertyResource<E> | ODataSingletonResource<E>;
    /**
     * Build a metadata resource.
     * @returns ODataMetadataResource
     */
    metadata(): ODataMetadataResource;
    /**
     * Build a batch resource.
     * @returns ODataBatchResource
     */
    batch(): ODataBatchResource;
    /**
     * Build a singleton resource.
     * @param path Name of the singleton
     * @returns
     */
    singleton<T>(name: string): ODataSingletonResource<T>;
    /**
     * Build an entity set resource.
     * @param path Name of the entity set
     * @returns
     */
    entitySet<T>(name: string): ODataEntitySetResource<T>;
    /**
     * Unbound Action
     * @param  {string} path?
     * @returns ODataActionResource
     */
    action<P, R>(path: string): ODataActionResource<P, R>;
    /**
     * Unbound Function
     * @param  {string} path?
     * @returns ODataFunctionResource
     */
    function<P, R>(path: string): ODataFunctionResource<P, R>;
    callable<T>(type: string): ODataCallable<any> | undefined;
    enumType<T>(type: string): ODataEnumType<any> | undefined;
    structuredType<T>(type: string): ODataStructuredType<any> | ODataStructuredType<T> | undefined;
    request<T>(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body?: any;
        etag?: string;
        responseType?: 'arraybuffer' | 'blob' | 'json' | 'text' | 'value' | 'property' | 'entity' | 'entities';
        observe?: 'body' | 'events' | 'response';
        withCount?: boolean;
        bodyQueryOptions?: QueryOption[];
    }): Observable<any>;
    private memo;
    createSchema(config: ODataSchemaConfig): ODataSchema;
    findSchema(type: string): ODataSchema | undefined;
    findEnumType<T>(value: string): ODataEnumType<any> | undefined;
    findStructuredType<T>(value: string): ODataStructuredType<any> | ODataStructuredType<T> | undefined;
    findCallable<R>(value: string, bindingType?: string): ODataCallable<any> | undefined;
    findEntitySet(value: string): ODataEntitySet | undefined;
    findSingleton(value: string): ODataSingleton | undefined;
    configureModel<T>(structured: ODataStructuredType<T>, model: typeof ODataModel<T>): void;
    findModel<T>(type: string): typeof ODataModel<T> | undefined;
    createModel<T>(structured: ODataStructuredType<T>): typeof ODataModel<any> | typeof ODataModel<T>;
    modelForType<T>(type: string): {
        new (data?: {
            [name: string]: any;
        } | Partial<T>, { parent, resource, annots, reset, }?: {
            parent?: [ODataModel<any> | ODataCollection<any, ODataModel<any>>, angular_odata.ODataModelField<any> | null];
            resource?: ODataResource<T> | null | undefined;
            annots?: angular_odata.ODataEntityAnnotations<T> | undefined;
            reset?: boolean;
        }): ODataModel<T>;
        options: ModelOptions;
        meta: ODataModelOptions<any>;
        buildMetaOptions<T_1>({ config, structuredType, }: {
            config?: ModelOptions;
            structuredType: ODataStructuredType<T_1>;
        }): ODataModelOptions<T_1>;
    };
    findCollection<T>(type: string): typeof ODataCollection<T, ODataModel<T>> | undefined;
    createCollection<T>(structured: ODataStructuredType<T>, model?: typeof ODataModel<T>): typeof ODataCollection<any, ODataModel<any>> | typeof ODataCollection<T, ODataModel<T>>;
    collectionForType<T>(type: string): {
        new (entities?: {
            [name: string]: any;
        }[] | Partial<T>[], { parent, resource, annots, model, reset, }?: {
            parent?: [ODataModel<any>, angular_odata.ODataModelField<any>];
            resource?: ODataResource<T> | null | undefined;
            annots?: angular_odata.ODataEntitiesAnnotations<T> | undefined;
            model?: typeof ODataModel;
            reset?: boolean;
        }): ODataCollection<T, ODataModel<T>>;
        model: typeof ODataModel<any> | null;
    };
    findEntitySetForEntityType(entityType: string): ODataEntitySet | undefined;
    parserForType<T>(type: string | EdmType, bindingType?: string): Parser<T>;
    optionsForType<T>(type: string, { structuredType, config, }?: {
        structuredType?: ODataStructuredType<T>;
        config?: ModelOptions;
    }): ODataModelOptions<T> | undefined;
}

declare class ODataSettings {
    apis: ODataApi[];
    constructor(configs: ODataApiConfig[]);
    configure(settings: {
        requester?: (request: ODataRequest<any>) => Observable<any>;
    }): void;
    defaultApi(): ODataApi;
    findApiByName(name: string): ODataApi | undefined;
    apiByName(name: string): ODataApi;
    findApiForTypes(types: string[]): ODataApi | undefined;
    findApiForType(type: string): ODataApi | undefined;
    apiForType(type: string): ODataApi;
    enumTypeForType<T>(type: string): ODataEnumType<T>;
    structuredTypeForType<T>(type: string): ODataStructuredType<T>;
    callableForType<T>(type: string, bindingType?: string): ODataCallable<T>;
    entitySetForType(type: string): ODataEntitySet;
    parserForType<T>(type: string | EdmType): Parser<T>;
    modelForType(type: string): typeof ODataModel;
    collectionForType(type: string): typeof ODataCollection;
}

declare abstract class ODataConfigLoader {
    abstract loadConfigs(): Observable<ODataApiConfig[]>;
}
declare class ODataConfigSyncLoader implements ODataConfigLoader {
    private readonly passedConfigs;
    constructor(passedConfigs: ODataApiConfig | ODataApiConfig[]);
    loadConfigs(): Observable<ODataApiConfig[]>;
}
declare class ODataConfigAsyncLoader implements ODataConfigLoader {
    private readonly configs$;
    constructor(configs$: Observable<ODataApiConfig>[] | Observable<ODataApiConfig | ODataApiConfig[]>);
    loadConfigs(): Observable<ODataApiConfig[]>;
}
declare class ODataMetadataLoader implements ODataConfigLoader {
    private readonly sources$;
    private readonly baseConfigs;
    constructor(sources$: Observable<string | string[]>, baseConfigs: ODataApiConfig | ODataApiConfig[]);
    loadConfigs(): Observable<ODataApiConfig[]>;
}

declare class ODataClient {
    private http;
    private loader;
    settings?: ODataSettings;
    constructor(http: HttpClient, loader: ODataConfigLoader);
    /**
     * Resolve the api for the given value.
     * Where value is: string type or an string name or an instance of resource.
     * @param value The value to resolve.
     * @returns The api for the value.
     */
    apiFor(value?: ODataResource<any> | string): ODataApi;
    defaultApi(): ODataApi;
    /**
     * Resolve the parser for the given string type.
     * @param type The string type of the parser.
     * @returns The parser for the given type.
     */
    parserForType<T>(type: string): angular_odata.Parser<T>;
    /**
     * Resolve the enum type for the given string type.
     * @param type The string type of the enum type.
     * @returns The enum type for the given type.
     */
    enumTypeForType<T>(type: string): angular_odata.ODataEnumType<T>;
    /**
     * Resolve the structured type for the given string type.
     * @param type The string type of the structured type.
     * @returns The structured type for the given type.
     */
    structuredTypeForType<T>(type: string): angular_odata.ODataStructuredType<T>;
    /**
     * Resolve the callable for the given string type.
     * @param type The string type of the callable.
     * @returns The callable for the given type.
     */
    callableForType<T>(type: string): angular_odata.ODataCallable<T>;
    /**
     * Resolve the entity set for the given string type.
     * @param type The string type of the entity set.
     * @returns The entity set for the given type.
     */
    entitySetForType(type: string): angular_odata.ODataEntitySet;
    /**
     * Resolve the model for the given string type.
     * @param type The string type of the model.
     * @returns The model for the given type.
     */
    modelForType(type: string): typeof ODataModel;
    /**
     * Resolve the collection for the given string type.
     * @param type The string type of the collection.
     * @returns The collection for the given type.
     */
    collectionForType(type: string): typeof ODataCollection;
    fromJson<E>(json: {
        segments: ODataSegment[];
        options: {
            [name: string]: any;
        };
    }, apiNameOrType?: string): ODataEntityResource<E> | ODataEntitySetResource<E> | ODataNavigationPropertyResource<E> | ODataSingletonResource<E>;
    /**
     * Build a resource for the metadata.
     * @param apiName The name of the API.
     * @returns The metadata resource.
     */
    metadata(apiName?: string): ODataMetadataResource;
    /**
     * Build a resource for the batch.
     * @param apiName The name of the API.
     * @returns The batch resource.
     */
    batch(apiName?: string): ODataBatchResource;
    /**
     * Build a resource for the singleton.
     * @param path The full path to the singleton.
     * @param apiNameOrType The name of the API or the type of the singleton.
     * @returns The singleton resource.
     */
    singleton<T>(path: string, apiNameOrType?: string): ODataSingletonResource<T>;
    /**
     * Build a resource for the entity set.
     * @param path The full path to the entity set.
     * @param apiNameOrType The name of the API or the type of the entity set.
     * @returns The entity set resource.
     */
    entitySet<T>(path: string, apiNameOrType?: string): ODataEntitySetResource<T>;
    /**
     * Build a resource for unbound action.
     * @param path The full path to the action.
     * @param apiNameOrType The name of the API or the type of the entity.
     * @returns The unbound action resource.
     */
    action<P, R>(path: string, apiNameOrType?: string): ODataActionResource<P, R>;
    /**
     * Build a resource for unbound function.
     * @param path The full path to the function.
     * @param apiNameOrType The name of the API or the type of the callable.
     * @returns The unbound function resource.
     */
    function<P, R>(path: string, apiNameOrType?: string): ODataFunctionResource<P, R>;
    request(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe?: 'body';
        responseType: 'arraybuffer';
    }): Observable<ArrayBuffer>;
    request(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe?: 'body';
        responseType: 'blob';
    }): Observable<Blob>;
    request(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe?: 'body';
        responseType: 'text';
    }): Observable<string>;
    request(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe: 'events';
        responseType: 'arraybuffer';
    }): Observable<HttpEvent<ArrayBuffer>>;
    request(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe: 'events';
        responseType: 'blob';
    }): Observable<HttpEvent<Blob>>;
    request(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe: 'events';
        responseType: 'text';
    }): Observable<HttpEvent<string>>;
    request(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<any>>;
    request<R>(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<R>>;
    request(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe: 'response';
        responseType: 'arraybuffer';
    }): Observable<ODataResponse<ArrayBuffer>>;
    request(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe: 'response';
        responseType: 'blob';
    }): Observable<ODataResponse<Blob>>;
    request(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe: 'response';
        responseType: 'text';
    }): Observable<ODataResponse<string>>;
    request(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<Object>>;
    request<R>(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<R>>;
    request(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe?: 'body';
        responseType?: 'json';
    }): Observable<Object>;
    request<R>(method: string, resource: ODataResource<any>, options: ODataOptions & {
        body: any | null;
        observe?: 'body';
        responseType?: 'json';
    }): Observable<R>;
    delete(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType: 'arraybuffer';
    }): Observable<ArrayBuffer>;
    delete(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType: 'blob';
    }): Observable<Blob>;
    delete(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType: 'text';
    }): Observable<string>;
    delete(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType: 'arraybuffer';
    }): Observable<HttpEvent<ArrayBuffer>>;
    delete(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType: 'blob';
    }): Observable<HttpEvent<Blob>>;
    delete(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType: 'text';
    }): Observable<HttpEvent<string>>;
    delete(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<Object>>;
    delete<T>(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<T>>;
    delete(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType: 'arraybuffer';
    }): Observable<ODataResponse<ArrayBuffer>>;
    delete(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType: 'blob';
    }): Observable<ODataResponse<Blob>>;
    delete(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType: 'text';
    }): Observable<ODataResponse<string>>;
    delete(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<Object>>;
    delete<T>(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<T>>;
    delete(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType?: 'json';
    }): Observable<Object>;
    delete<T>(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType?: 'json';
    }): Observable<T>;
    get(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType: 'arraybuffer';
    }): Observable<ArrayBuffer>;
    get(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType: 'blob';
    }): Observable<Blob>;
    get(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType: 'text';
    }): Observable<string>;
    get(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType: 'arraybuffer';
    }): Observable<HttpEvent<ArrayBuffer>>;
    get(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType: 'blob';
    }): Observable<HttpEvent<Blob>>;
    get(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType: 'text';
    }): Observable<HttpEvent<string>>;
    get(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<Object>>;
    get<T>(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<T>>;
    get(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType: 'arraybuffer';
    }): Observable<ODataResponse<ArrayBuffer>>;
    get(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType: 'blob';
    }): Observable<ODataResponse<Blob>>;
    get(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType: 'text';
    }): Observable<ODataResponse<string>>;
    get(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<Object>>;
    get<T>(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<T>>;
    get(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType?: 'json';
    }): Observable<Object>;
    get<T>(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType?: 'json';
    }): Observable<T>;
    head(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType: 'arraybuffer';
    }): Observable<ArrayBuffer>;
    head(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType: 'blob';
    }): Observable<Blob>;
    head(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType: 'text';
    }): Observable<string>;
    head(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType: 'arraybuffer';
    }): Observable<HttpEvent<ArrayBuffer>>;
    head(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType: 'blob';
    }): Observable<HttpEvent<Blob>>;
    head(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType: 'text';
    }): Observable<HttpEvent<string>>;
    head(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<Object>>;
    head<T>(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<T>>;
    head(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType: 'arraybuffer';
    }): Observable<ODataResponse<ArrayBuffer>>;
    head(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType: 'blob';
    }): Observable<ODataResponse<Blob>>;
    head(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType: 'text';
    }): Observable<ODataResponse<string>>;
    head(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<Object>>;
    head<T>(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<T>>;
    head(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType?: 'json';
    }): Observable<Object>;
    head<T>(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType?: 'json';
    }): Observable<T>;
    jsonp(resource: ODataResource<any>, callbackParam: string): Observable<Object>;
    jsonp<T>(resource: ODataResource<any>, callbackParam: string): Observable<T>;
    options(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType: 'arraybuffer';
    }): Observable<ArrayBuffer>;
    options(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType: 'blob';
    }): Observable<Blob>;
    options(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType: 'text';
    }): Observable<string>;
    options(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType: 'arraybuffer';
    }): Observable<HttpEvent<ArrayBuffer>>;
    options(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType: 'blob';
    }): Observable<HttpEvent<Blob>>;
    options(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType: 'text';
    }): Observable<HttpEvent<string>>;
    options(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<Object>>;
    options(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<Object>>;
    options<T>(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<T>>;
    options(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType: 'arraybuffer';
    }): Observable<ODataResponse<ArrayBuffer>>;
    options(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType: 'blob';
    }): Observable<ODataResponse<Blob>>;
    options(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType: 'text';
    }): Observable<ODataResponse<string>>;
    options(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<Object>>;
    options<T>(resource: ODataResource<any>, options: ODataOptions & {
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<T>>;
    options(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType?: 'json';
    }): Observable<Object>;
    options<T>(resource: ODataResource<any>, options: ODataOptions & {
        observe?: 'body';
        responseType?: 'json';
    }): Observable<T>;
    patch(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType: 'arraybuffer';
    }): Observable<ArrayBuffer>;
    patch(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType: 'blob';
    }): Observable<Blob>;
    patch(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType: 'text';
    }): Observable<string>;
    patch(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType: 'arraybuffer';
    }): Observable<HttpEvent<ArrayBuffer>>;
    patch(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType: 'blob';
    }): Observable<HttpEvent<Blob>>;
    patch(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType: 'text';
    }): Observable<HttpEvent<string>>;
    patch(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<Object>>;
    patch<T>(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<T>>;
    patch(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType: 'arraybuffer';
    }): Observable<ODataResponse<ArrayBuffer>>;
    patch(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType: 'blob';
    }): Observable<ODataResponse<Blob>>;
    patch(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType: 'text';
    }): Observable<ODataResponse<string>>;
    patch(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<Object>>;
    patch<T>(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<T>>;
    patch(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType?: 'json';
    }): Observable<Object>;
    patch<T>(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType?: 'json';
    }): Observable<T>;
    post(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType: 'arraybuffer';
    }): Observable<ArrayBuffer>;
    post(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType: 'blob';
    }): Observable<Blob>;
    post(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType: 'text';
    }): Observable<string>;
    post(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType: 'arraybuffer';
    }): Observable<HttpEvent<ArrayBuffer>>;
    post(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType: 'blob';
    }): Observable<HttpEvent<Blob>>;
    post(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType: 'text';
    }): Observable<HttpEvent<string>>;
    post(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<Object>>;
    post<T>(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<T>>;
    post(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType: 'arraybuffer';
    }): Observable<ODataResponse<ArrayBuffer>>;
    post(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType: 'blob';
    }): Observable<ODataResponse<Blob>>;
    post(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType: 'text';
    }): Observable<ODataResponse<string>>;
    post(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<Object>>;
    post<T>(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<T>>;
    post(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType?: 'json';
    }): Observable<Object>;
    post<T>(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType?: 'json';
    }): Observable<T>;
    put(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType: 'arraybuffer';
    }): Observable<ArrayBuffer>;
    put(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType: 'blob';
    }): Observable<Blob>;
    put(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType: 'text';
    }): Observable<string>;
    put(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType: 'arraybuffer';
    }): Observable<HttpEvent<ArrayBuffer>>;
    put(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType: 'blob';
    }): Observable<HttpEvent<Blob>>;
    put(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType: 'text';
    }): Observable<HttpEvent<string>>;
    put(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<Object>>;
    put<T>(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'events';
        responseType?: 'json';
    }): Observable<HttpEvent<T>>;
    put(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType: 'arraybuffer';
    }): Observable<ODataResponse<ArrayBuffer>>;
    put(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType: 'blob';
    }): Observable<ODataResponse<Blob>>;
    put(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType: 'text';
    }): Observable<ODataResponse<string>>;
    put(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<Object>>;
    put<T>(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe: 'response';
        responseType?: 'json';
    }): Observable<ODataResponse<T>>;
    put(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType?: 'json';
    }): Observable<Object>;
    put<T>(resource: ODataResource<any>, body: any | null, options: ODataOptions & {
        observe?: 'body';
        responseType?: 'json';
    }): Observable<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ODataClient, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ODataClient>;
}

interface PassedInitialConfig {
    config?: ODataApiConfig | ODataApiConfig[];
    loader?: Provider;
}
declare const ODATA_CONFIG: InjectionToken<ODataApiConfig>;
declare function createSyncLoader(passedConfig: PassedInitialConfig): ODataConfigSyncLoader;
declare function provideODataClient(passedConfig: PassedInitialConfig): EnvironmentProviders;
declare class ODataModule {
    static forRoot(passedConfig: PassedInitialConfig): ModuleWithProviders<ODataModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ODataModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ODataModule, never, [typeof i1.CommonModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ODataModule>;
}

declare const Dates: {
    isoStringToDate(value: any): any;
};

type Duration = {
    sign?: 1 | -1;
    years?: number;
    months?: number;
    weeks?: number;
    days?: number;
    hours?: number;
    minutes?: number;
    seconds?: number;
};
declare const Durations: {
    toDuration(v: string): Duration;
    toString(v: Duration): string;
};

declare const Enums: {
    names<E extends {
        [name: string]: any;
    }>(enums: E): string[];
    values<E extends {
        [name: string]: any;
    }>(enums: E): number[];
    toValue<E extends {
        [name: string]: any;
    }>(enums: E, value: any): number | undefined;
    toValues<E extends {
        [name: string]: any;
    }>(enums: E, value: any): number[];
    toName<E extends {
        [name: string]: any;
    }>(enums: E, value: any): string | undefined;
    toNames<E extends {
        [name: string]: any;
    }>(enums: E, value: any): string[];
    toFlags<E extends {
        [name: string]: any;
    }>(enums: E, value: any): string[];
};

declare const Http: {
    mergeHttpHeaders(...values: (HttpHeaders | {
        [header: string]: string | string[];
    })[]): HttpHeaders;
    mergeHttpParams(...values: (HttpParams | {
        [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
    })[]): HttpParams;
    splitHttpParams(params: HttpParams, keys: string[]): [HttpParams, HttpParams];
    withoutHttpParams(params: HttpParams, keys: string[]): HttpParams;
    resolveHeaderKey(headers: HttpHeaders | {
        [param: string]: string | string[];
    }, options: string[]): string | undefined;
    headerValue(header: string): string;
    parseResponseStatus(line: string): {
        status: string;
        code: number;
        message: string;
    };
    boundaryDelimiter(contentType: string): string;
    boundaryEnd(boundaryDelimiter: string): string;
};

declare const Objects: {
    set(obj: {
        [attr: string]: any;
    }, path: string, value: any): void;
    get(obj: {
        [attr: string]: any;
    }, path: string, def?: any): any;
    unset(obj: {
        [attr: string]: any;
    }, path: string): void;
    has(obj: {
        [attr: string]: any;
    }, path: string): boolean;
    merge(target: {
        [attr: string]: any;
    }, source: {
        [attr: string]: any;
    }): {
        [attr: string]: any;
    };
    equal(object1: {
        [attr: string]: any;
    }, object2: {
        [attr: string]: any;
    }): boolean;
    difference(object1: {
        [attr: string]: any;
    }, object2: {
        [attr: string]: any;
    }): {
        [attr: string]: any;
    };
    resolveKey(key: any, { single }?: {
        single?: boolean;
    }): any;
    clone(target: any, map?: WeakMap<object, any>): any;
};

declare const OData: {
    mergeCallableParameters(callables: ODataCallableConfig[]): ODataCallableConfig[];
};

declare const Strings: {
    uniqueId({ prefix, suffix }?: {
        prefix?: string;
        suffix?: string;
    }): string;
    titleCase(text: string): string;
    hashCode(text: string): number;
};

declare const Types: {
    rawType(value: any): string;
    isObject(value: any): boolean;
    isPlainObject(value: any): boolean;
    isFunction(value: any): boolean;
    isArray(value: any): boolean;
    isMap(value: any): boolean;
    isEmpty(value: any): boolean;
    isEqual(value1: any, value2: any): boolean;
    clone(target: any): any;
};

declare const Urls: {
    parseQueryString(query: string): {};
    escapeIllegalChars(string: string): string;
};

declare abstract class ODataBaseService {
    protected client: ODataClient;
    protected name: string;
    protected apiNameOrEntityType?: string | undefined;
    constructor(client: ODataClient, name: string, apiNameOrEntityType?: string | undefined);
    get api(): angular_odata.ODataApi;
    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entity', options?: ODataFunctionOptions<R>): Observable<ODataEntity<R>>;
    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'entities', options?: ODataFunctionOptions<R>): Observable<ODataEntities<R>>;
    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'property', options?: ODataFunctionOptions<R>): Observable<ODataProperty<R>>;
    protected callFunction<P, R>(params: P | null, resource: ODataFunctionResource<P, R>, responseType: 'none', options?: ODataFunctionOptions<R>): Observable<null>;
    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entity', options?: ODataActionOptions<R>): Observable<ODataEntity<R>>;
    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'entities', options?: ODataActionOptions<R>): Observable<ODataEntities<R>>;
    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'property', options?: ODataActionOptions<R>): Observable<ODataProperty<R>>;
    protected callAction<P, R>(params: P | null, resource: ODataActionResource<P, R>, responseType: 'none', options?: ODataActionOptions<R>): Observable<null>;
    protected fetchNavigationProperty<S>(resource: ODataNavigationPropertyResource<S>, responseType: 'entity', options?: ODataQueryArgumentsOptions<S>): Observable<ODataEntity<S>>;
    protected fetchNavigationProperty<S>(resource: ODataNavigationPropertyResource<S>, responseType: 'entities', options?: ODataQueryArgumentsOptions<S>): Observable<ODataEntities<S>>;
}

declare abstract class ODataEntityService<T> extends ODataBaseService {
    abstract entity(key?: EntityKey<T>): ODataResource<T>;
    abstract attach<M extends ODataModel<T>>(value: M): void;
    /**
     * The schema for the structured type.
     */
    get structuredTypeSchema(): angular_odata.ODataStructuredType<any> | angular_odata.ODataStructuredType<T> | undefined;
}

declare class ODataEntitySetService<T> extends ODataEntityService<T> {
    static Model?: typeof ODataModel<any>;
    static Collection?: typeof ODataCollection<any, ODataModel<any>>;
    model(entity?: Partial<T>, reset?: boolean): ODataModel<T> & angular_odata.ModelInterface<T>;
    collection(entities?: Partial<T>[], reset?: boolean): ODataCollection<T, ODataModel<T> & angular_odata.ModelInterface<T>>;
    /**
     * Get the entity set resource for this service.
     */
    entities(): ODataEntitySetResource<T>;
    /**
     * Get the entity resource for this service.
     * @param key The entity key.
     */
    entity(key?: EntityKey<T>): ODataEntityResource<T>;
    /**
     * Attach an existing model to this service.
     * @param model The model to attach.
     */
    attach<M extends ODataModel<T>>(model: M): void;
    attach<C extends ODataCollection<T, ODataModel<T>>>(model: C): void;
    /**
     * The schema for the entity set.
     */
    get entitySetSchema(): angular_odata.ODataEntitySet | undefined;
    /**
     * Get all entities from the entity set.
     * @param options The options for the request.
     */
    fetchAll(options?: ODataOptions): Observable<{
        entities: any[];
        annots: angular_odata.ODataEntitiesAnnotations<any>;
    }>;
    /**
     * Get entities from the entity set.
     * @param withCount Get the count of the entities.
     * @param options The options for the request.
     */
    fetchMany(top: number, options?: ODataOptions & {
        withCount?: boolean;
    }): Observable<{
        entities: T[];
        annots: angular_odata.ODataEntitiesAnnotations<T>;
    } | {
        entities: T[];
        annots: angular_odata.ODataEntitiesAnnotations<any>;
    }>;
    /**
     * Get an entity from the entity set.
     * @param key The entity key.
     * @param etag The etag for the entity.
     * @param options The options for the request.
     */
    fetchOne(options?: ODataOptions & {
        etag?: string;
    }): Observable<{
        entity: T | null;
        annots: angular_odata.ODataEntitiesAnnotations<T>;
    }>;
    /**
     * Create an entity in the entity set.
     * @param attrs The attributes for the entity.
     * @param options The options for the request.
     */
    create(attrs: Partial<T>, options?: ODataOptions): Observable<ODataEntity<T>>;
    /**
     * Update an entity in the entity set.
     * @param key The entity key.
     * @param attrs The attributes for the entity.
     * @param etag The etag for the entity.
     * @param options The options for the request.
     */
    update(key: EntityKey<T>, attrs: Partial<T>, options?: ODataOptions & {
        etag?: string;
    }): Observable<ODataEntity<T>>;
    /**
     * Patch an entity in the entity set.
     * @param key The entity key.
     * @param attrs The attributes for the entity.
     * @param etag The etag for the entity.
     * @param options The options for the request.
     */
    modify(key: EntityKey<T>, attrs: Partial<T>, options?: ODataOptions & {
        etag?: string;
    }): Observable<ODataEntity<T>>;
    /**
     * Delete an entity in the entity set.
     * @param key The entity key.
     * @param etag The etag for the entity.
     * @param options The options for the request.
     */
    destroy(key: EntityKey<T>, options?: ODataOptions & {
        etag?: string;
    }): Observable<any>;
    /**
     * Get or create an entity in the entity set.
     * @param key The entity key.
     * @param attrs The attributes for the entity.
     * @param etag The etag for the entity.
     * @param options The options for the request.
     */
    fetchOrCreate(key: EntityKey<T>, attrs: Partial<T>, { etag, ...options }?: {
        etag?: string;
    } & ODataOptions): Observable<ODataEntity<T>>;
    /**
     * Save an entity in the entity set.
     * @param attrs The attributes for the entity.
     * @param method The method to use.
     * @param etag The etag for the entity.
     * @param options The options for the request.
     */
    save(attrs: Partial<T>, { etag, method, ...options }?: {
        etag?: string;
        method?: 'create' | 'update' | 'modify';
    } & ODataOptions): Observable<ODataEntity<T>>;
}

/**
 * OData Singleton Service
 * www.odata.org/getting-started/advanced-tutorial/#singleton
 */
declare class ODataSingletonService<T> extends ODataEntityService<T> {
    static Model?: typeof ODataModel;
    model(entity?: Partial<T>): ODataModel<T> & angular_odata.ModelInterface<T>;
    /**
     * Get the entity resource for this service.
     * @param key The entity key.
     */
    entity(): ODataSingletonResource<T>;
    /**
     * Attach an existing model to this service.
     * @param model The model to attach.
     */
    attach<M extends ODataModel<T>>(model: M): void;
    /**
     * The schema for the singleton.
     */
    get singletonSchema(): angular_odata.ODataEntitySet | undefined;
    /**
     * Update the singleton entity
     * @param attrs The attributes for the entity.
     * @param etag The etag for the entity.
     * @param options The options for the request.
     */
    update(attrs: Partial<T>, options?: ODataOptions & {
        etag?: string;
    }): Observable<ODataEntity<T>>;
    /**
     * Patch the singleton entity
     * @param attrs The attributes for the entity.
     * @param etag The etag for the entity.
     * @param options The options for the request.
     */
    patch(attrs: Partial<T>, options?: ODataOptions & {
        etag?: string;
    }): Observable<ODataEntity<T>>;
}

declare class ODataServiceFactory {
    protected client: ODataClient;
    constructor(client: ODataClient);
    /**
     * Factory method to create an entity set service.
     * @param entitySetName Name of the entity set.
     * @param apiNameOrEntityType Name of the API or the type of the entity.
     */
    entitySet<T>(entitySetName: string, apiNameOrEntityType?: string, options?: {
        Model?: {
            new (...params: any[]): ODataModel<T>;
        };
        Collection?: {
            new (...params: any[]): ODataCollection<T, ODataModel<T>>;
        };
    }): ODataEntitySetService<T>;
    /** Factory method to create a singleton service.
     * @param singletonName Name of the singleton.
     * @param apiNameOrEntityType Name of the API or the type of the entity.
     */
    singleton<T>(singletonName: string, apiNameOrEntityType?: string, options?: {
        Model?: {
            new (...params: any[]): ODataModel<T>;
        };
    }): ODataSingletonService<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ODataServiceFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ODataServiceFactory>;
}

/**
 * A cache entry that holds a payload, a last read time, and a timeout for the entry.
 * @param payload The payload to cache.
 * @param lastRead The last read time.
 * @param timeout The timeout.
 * @param tags Some tags to identify the entry.
 */
interface ODataCacheEntry<T> {
    payload: T;
    lastRead: number;
    timeout: number;
    tags: string[];
}
declare abstract class ODataBaseCache implements ODataCache {
    timeout: number;
    entries: Map<string, ODataCacheEntry<any>>;
    constructor({ timeout }: {
        timeout?: number;
    });
    abstract getResponse(req: ODataRequest<any>): ODataResponse<any> | undefined;
    abstract putResponse(req: ODataRequest<any>, res: ODataResponse<any>): void;
    /**
     * Using the resource on the request build an array of string to identify the scope of the request
     * @param req The request with the resource to build the scope
     * @returns Array of string to identify the scope of the request
     */
    scope(req: ODataRequest<any>): string[];
    /**
     * Using the odata context on the response build an array of string to identify the tags of the response
     * @param res The response to build the tags
     * @returns Array of string to identify the tags of the response
     */
    tags(res: ODataResponse<any>): string[];
    /**
     * Build an entry from a payload and some options
     * @param payload The payload to store in the cache
     * @param timeout The timeout for the entry
     * @param tags The tags for the entry
     * @returns The entry to store in the cache
     */
    buildEntry<T>(payload: T, { timeout, tags }: {
        timeout?: number;
        tags?: string[];
    }): ODataCacheEntry<T>;
    /**
     * Build a key from store an entry in the cache
     * @param names The names of the entry
     * @returns The key for the entry
     */
    buildKey(names: string[]): string;
    /**
     * Put some payload in the cache
     * @param name The name for the entry
     * @param payload The payload to store in the cache
     * @param timeout The timeout for the entry
     * @param scope The scope for the entry
     * @param tags The tags for the entry
     */
    put<T>(name: string, payload: T, { timeout, scope, tags }?: {
        timeout?: number;
        scope?: string[];
        tags?: string[];
    }): void;
    /**
     * Return the payload from the cache if it exists and is not expired
     * @param name The name of the entry
     * @param scope The scope of the entry
     * @returns The payload of the entry
     */
    get<T>(name: string, { scope }?: {
        scope?: string[];
    }): T | undefined;
    /**
     * Remove all cache entries that are matching with the given options
     * @param options The options to forget
     */
    forget({ name, scope, tags, }?: {
        name?: string;
        scope?: string[];
        tags?: string[];
    }): void;
    /**
     * Remove all cache entries
     */
    flush(): void;
    /**
     * Check if the entry is expired
     * @param entry The cache entry
     * @returns Boolean indicating if the entry is expired
     */
    isExpired(entry: ODataCacheEntry<any>): boolean;
    /**
     * Using the request, handle the fetching of the response
     * @param req The request to fetch
     * @param res$ Observable of the response
     * @returns
     */
    handleRequest(req: ODataRequest<any>, res$: Observable<ODataResponse<any>>): Observable<ODataResponse<any>>;
    private handleFetch;
    private handleMutate;
}

declare class ODataInMemoryCache extends ODataBaseCache {
    constructor({ timeout }?: {
        timeout?: number;
    });
    /**
     * Store the response in the cache
     * @param req The request with the resource to store the response
     * @param res The response to store in the cache
     */
    putResponse(req: ODataRequest<any>, res: ODataResponse<any>): void;
    /**
     * Restore the response from the cache
     * @param req The request with the resource to get the response
     * @returns The response from the cache
     */
    getResponse(req: ODataRequest<any>): ODataResponse<any> | undefined;
}

declare class ODataInStorageCache extends ODataBaseCache {
    name: string;
    storage: Storage;
    constructor({ name, storage, timeout, }: {
        timeout?: number;
        name: string;
        storage?: Storage;
    });
    /**
     * Store the cache in the storage
     */
    store(): void;
    /**
     * Restore the cache from the storage
     */
    restore(): void;
    /**
     * Flush the cache and clean the storage
     */
    flush(): void;
    /**
     * Store the response in the cache
     * @param req The request with the resource to store the response
     * @param res The response to store in the cache
     */
    putResponse(req: ODataRequest<any>, res: ODataResponse<any>): void;
    /**
     * Restore the response from the cache
     * @param req The request with the resource to get the response
     * @returns The response from the cache
     */
    getResponse(req: ODataRequest<any>): ODataResponse<any> | undefined;
}

declare enum FieldType {
    ATTRIBUTE = 0,
    TAG = 1
}
declare class Field {
    name: string;
    fieldType: FieldType;
    constructor(name: string, fieldType: FieldType);
}
declare class ODataMetadataParser {
    private static readonly TAG_EDMX;
    private static readonly TAG_DATA_SERVICES;
    private static readonly TAG_REFERENCE;
    private static readonly TAG_INCLUDE;
    private static readonly TAG_INCLUDE_ANNOTATIONS;
    private static readonly TAG_TERM;
    private static readonly TAG_ANNOTATIONS;
    private static readonly TAG_ANNOTATION;
    private static readonly TAG_SCHEMA;
    private static readonly TAG_ENUM_TYPE;
    private static readonly TAG_MEMBER;
    private static readonly TAG_COMPLEX_TYPE;
    private static readonly TAG_ENTITY_TYPE;
    private static readonly TAG_PROPERTY;
    private static readonly TAG_KEY;
    private static readonly TAG_PROPERTY_REF;
    private static readonly TAG_NAVIGATION_PROPERTY;
    private static readonly TAG_REFERENTIAL_CONSTRAINT;
    private static readonly TAG_ON_DELETE;
    private static readonly TAG_FUNCTION;
    private static readonly TAG_RETURN_TYPE;
    private static readonly TAG_PARAMETER;
    private static readonly TAG_ACTION;
    private static readonly TAG_ENTITY_CONTAINER;
    private static readonly TAG_ENTITY_SET;
    private static readonly TAG_SINGLETON;
    private static readonly TAG_COLLECTION;
    private static readonly TAG_RECORD;
    private static readonly TAG_STRING;
    private static readonly TAG_ENUM_MEMBER;
    private static readonly TAG_PROPERTY_VALUE;
    private static readonly TAG_PROPERTY_PATH;
    private static readonly TAG_NAVIGATION_PROPERTY_PATH;
    private static readonly TAG_FUNCTION_IMPORT;
    private static readonly TAG_ACTION_IMPORT;
    private static readonly TAG_NAVIGATION_PROPERTY_BINDING;
    private static readonly TAG_TYPE_DEFINITION;
    private static readonly ATTRIBUTE_VERSION;
    private static readonly ATTRIBUTE_URI;
    private static readonly ATTRIBUTE_ALIAS;
    private static readonly ATTRIBUTE_NAMESPACE;
    private static readonly ATTRIBUTE_TERM_NAMESPACE;
    private static readonly ATTRIBUTE_QUALIFIER;
    private static readonly ATTRIBUTE_STRING;
    private static readonly ATTRIBUTE_DATE;
    private static readonly ATTRIBUTE_BOOL;
    private static readonly ATTRIBUTE_INT;
    private static readonly ATTRIBUTE_TARGET_NAMESPACE;
    private static readonly ATTRIBUTE_TERM;
    private static readonly ATTRIBUTE_NAME;
    private static readonly ATTRIBUTE_VALUE;
    private static readonly ATTRIBUTE_BASE_TYPE;
    private static readonly ATTRIBUTE_OPEN_TYPE;
    private static readonly ATTRIBUTE_TYPE;
    private static readonly ATTRIBUTE_NULLABLE;
    private static readonly ATTRIBUTE_MAX_LENGTH;
    private static readonly ATTRIBUTE_PRECISION;
    private static readonly ATTRIBUTE_SCALE;
    private static readonly ATTRIBUTE_UNICODE;
    private static readonly ATTRIBUTE_SRID;
    private static readonly ATTRIBUTE_DEFAULT_VALUE;
    private static readonly ATTRIBUTE_PARTNER;
    private static readonly ATTRIBUTE_PROPERTY;
    private static readonly ATTRIBUTE_REFERENCED_PROPERTY;
    private static readonly ATTRIBUTE_HAS_STREAM;
    private static readonly ATTRIBUTE_CONTAINS_TARGET;
    private static readonly ATTRIBUTE_IS_BOUND;
    private static readonly ATTRIBUTE_ENTITY_SET_PATH;
    private static readonly ATTRIBUTE_IS_COMPOSABLE;
    private static readonly ATTRIBUTE_ENTITY_TYPE;
    private static readonly ATTRIBUTE_PATH;
    private static readonly ATTRIBUTE_TARGET;
    private static readonly ATTRIBUTE_FUNCTION;
    private static readonly ATTRIBUTE_ACTION;
    private static readonly ATTRIBUTE_ENTITY_SET;
    private static readonly ATTRIBUTE_INCLUDE_IN_SERVICE_DOCUMENT;
    private static readonly ATTRIBUTE_ABSTRACT;
    private static readonly ATTRIBUTE_UNDERLYING_TYPE;
    private static readonly ATTRIBUTE_IS_FLAGS;
    private static readonly ATTRIBUTE_EXTENDS;
    private static readonly ATTRIBUTE_BASE_TERM;
    private static readonly ATTRIBUTE_APPLIES_TO;
    readonly document: Document;
    constructor(xml: string);
    metadata(): ODataMetadata;
    protected checkVersion(doc: Document): void;
    protected getObjects(parentElement: Element, tag: string, fieldNames: Field[]): any[];
    protected getObject(parentElement: Element, tag: string, fieldNames: Field[]): any;
    protected getFieldValues(fields: Field[], attributes: NamedNodeMap, element: Element): {
        [name: string]: any;
    };
    protected getFieldValueByAttribute(field: Field, attributes: NamedNodeMap): any;
    protected getFieldValueByTag(field: Field, element: Element): any[];
    protected getAttributeValue(attributes: NamedNodeMap, attributeName: string): string | undefined;
    protected propertyValueToNumber(attributeValue?: string): number | undefined;
    protected propertyValueToBoolean(attributeValue?: string): boolean;
    protected propertyValueToDate(attributeValue?: string): Date | undefined;
}

export { Aggregate, ApplyExpression, ArithmeticFunctions, ArithmeticOperators, BUBBLES, CollectionFunctions, ComputeExpression, ConditionalFunctions, DateAndTimeFunctions, Dates, Durations, EDM_PARSERS, EdmType, Enums, ExpandExpression, ExpandField, Expression, FieldFactory, FilterExpression, Function, GeoFunctions, GroupBy, GroupByTransformations, Grouping, GroupingOperators, Http, INCLUDE_DEEP, INCLUDE_SHALLOW, ITEM_ROOT, JsonType, Lambda, LambdaOperators, LogicalOperators, Model, ModelField, NONE_PARSER, ODATA_CONFIG, OData, ODataActionResource, ODataAnnotations, ODataApi, ODataBaseCache, ODataBaseService, ODataBatchRequest, ODataBatchResource, ODataCallable, ODataCallableParser, ODataClient, ODataCollection, ODataConfigAsyncLoader, ODataConfigLoader, ODataConfigSyncLoader, ODataCountResource, ODataEntitiesAnnotations, ODataEntityAnnotations, ODataEntityContainer, ODataEntityResource, ODataEntitySet, ODataEntitySetResource, ODataEntitySetService, ODataEntityTypeKey, ODataEnumType, ODataEnumTypeFieldParser, ODataEnumTypeParser, ODataFunctionResource, ODataFunctions, ODataInMemoryCache, ODataInStorageCache, ODataMediaResource, ODataMetadata, ODataMetadataLoader, ODataMetadataParser, ODataMetadataResource, ODataModel, ODataModelAttribute, ODataModelEvent, ODataModelEventEmitter, ODataModelEventType, ODataModelField, ODataModelOptions, ODataModelState, ODataModule, ODataNavigationPropertyResource, ODataOperators, ODataParameterParser, ODataPathSegments, ODataPathSegmentsHandler, ODataPropertyAnnotations, ODataPropertyResource, ODataQueryOptionHandler, ODataQueryOptions, ODataQueryOptionsHandler, ODataReferenceResource, ODataReferential, ODataRequest, ODataResource, ODataResponse, ODataSchema, ODataServiceFactory, ODataSettings, ODataSingleton, ODataSingletonResource, ODataSingletonService, ODataStructuredType, ODataStructuredTypeFieldParser, ODataStructuredTypeParser, ODataSyntax, ODataTransformations, ODataValueResource, Objects, Operator, OrderByExpression, OrderByField, PathSegment, QueryCustomTypes, QueryOption, RenderableFactory, SearchExpression, SearchTerm, SegmentHandler, SelectExpression, StandardAggregateMethods, StringAndCollectionFunctions, StringFunctions, Strings, Transformations, Type, TypeFunctions, Types, Urls, alias, binary, buildPathAndQuery, createSyncLoader, duration, encode, functions, isQueryCustomType, isRawType, normalizeValue, operators, pathAndParamsFromQueryOptions, pathAndParamsFromSegments, provideODataClient, raw, render, resolve, syntax, transformations };
export type { AggregateMethod, AggregateType, ApplyExpressionBuilder, CacheCacheability, ComputeExpressionBuilder, Duration, EntityKey, Expand, ExpandExpressionBuilder, ExpandObject, ExpandOptions, ExpandType, FetchPolicy, FieldParser, Filter, FilterConnector, FilterExpressionBuilder, FilterType, GroupByType, JsonSchemaOptions, LooseUnion, ModelFieldOptions, ModelInterface, ModelOptions, NestedExpandOptions, NestedOrderBy, Normalize, ODataActionOptions, ODataAnnotationConfig, ODataApiConfig, ODataApiConfigOptions, ODataCache, ODataCacheEntry, ODataCallableConfig, ODataEntities, ODataEntitiesOptions, ODataEntity, ODataEntityContainerConfig, ODataEntityOptions, ODataEntitySetConfig, ODataEnumTypeConfig, ODataEnumTypeFieldConfig, ODataFunctionOptions, ODataMetadataType, ODataModelEntry, ODataModelFieldOptions, ODataOptions, ODataParameterConfig, ODataProperty, ODataPropertyOptions, ODataQueryArguments, ODataQueryArgumentsOptions, ODataReferenceConfig, ODataResponseJson, ODataSchemaConfig, ODataSegment, ODataSingletonConfig, ODataStructuredTypeConfig, ODataStructuredTypeFieldConfig, ODataVersion, ObjectValues, OrderAttribute, OrderBy, OrderByExpressionBuilder, OrderByObject, OrderByType, Parser, ParserOptions, PassedInitialConfig, QueryCustomType, QueryOptions, Renderable, ResponseOptions, SearchConnector, SearchExpressionBuilder, Select, SelectExpressionBuilder, SelectType, StructuredTypeFieldOptions, Transform, Unpacked, Value };