angular-odata 0.80.0 → 0.99.0

package/lib/options.d.ts

@@ -1,17 +1,45 @@
 import { ApiOptions, FetchPolicy, ODataMetadataType, ODataVersion, Options, OptionsHelper, QueryOptionNames } from './types';
 export declare class ODataApiOptions implements ApiOptions, OptionsHelper {
+    /**
+     * Default OData version
+     */
     version: ODataVersion;
+    /**
+     * Send enum as string in the request
+     */
     stringAsEnum?: boolean;
+    /**
+     * Strip metadata from the response
+     */
     stripMetadata: ODataMetadataType;
+    /**
+     * 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: QueryOptionNames[];
+    /**
+     * 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;
@@ -19,15 +47,34 @@ export declare class ODataApiOptions implements ApiOptions, OptionsHelper {
         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;
     };
+    deleteRefBy: 'path' | 'id';
     constructor(config: ApiOptions);
     get helper(): import("./helper").ODataVersionHelper;
 }

package/lib/resources/index.d.ts

@@ -1,6 +1,5 @@
-export * from './builder';
-export * from './query-options';
-export * from './path-segments';
+export * from './query';
+export * from './path';
 export * from './request';
 export * from './resource';
 export * from './types';

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

@@ -0,0 +1,27 @@
+import { PathSegmentNames } from '../../types';
+import { EntityKey } from '../resource';
+import type { ODataPathSegments, ODataSegment } from './segments';
+export declare class SegmentHandler {
+    private segment;
+    constructor(segment: ODataSegment);
+    get name(): PathSegmentNames;
+    type(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;
+}
+export 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;
+}

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

@@ -0,0 +1,2 @@
+export * from './segments';
+export * from './handlers';

package/lib/resources/{path-segments.d.ts → path/segments.d.ts}

@@ -1,5 +1,6 @@
-import { EntityKey } from './resource';
-import { PathSegmentNames } from '../types';
+import { PathSegmentNames } from '../../types';
+import { EntityKey } from '../resource';
+import { SegmentHandler } from './handlers';
 export declare type ODataSegment = {
     name: PathSegmentNames;
     path: string;
@@ -10,7 +11,7 @@ export declare type ODataSegment = {
 export declare class ODataPathSegments {
     private _segments;
     constructor(segments?: ODataSegment[]);
-    pathAndParams(): [string, {
+    pathAndParams(escape?: boolean): [string, {
         [name: string]: any;
     }];
     types({ key }?: {
@@ -33,16 +34,3 @@ export declare class ODataPathSegments {
     add(name: string, path: string): SegmentHandler;
     get(name: string): SegmentHandler;
 }
-export declare class SegmentHandler {
-    private segment;
-    constructor(segment: ODataSegment);
-    get name(): PathSegmentNames;
-    type(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;
-}

package/lib/resources/{builder.d.ts → query/builder.d.ts}

@@ -1,7 +1,7 @@
 export declare type Unpacked<T> = T extends (infer U)[] ? U : T;
 export declare type Select<T> = SelectType<T> | SelectType<T>[];
 export declare type SelectType<T> = string | keyof T;
-export declare type Filter = FilterType | FilterType[];
+export declare type Filter<T> = FilterType | FilterType[];
 export declare type FilterType = string | {
     [name: string]: any;
 };
@@ -29,16 +29,16 @@ export declare type NestedExpandOptions<T> = {
 };
 export declare type ExpandOptions<T> = {
     select?: Select<T>;
-    filter?: Filter;
+    filter?: Filter<T>;
     orderBy?: OrderBy<T>;
     top?: number;
     levels?: number | 'max';
-    count?: boolean | Filter;
+    count?: boolean | Filter<T>;
     expand?: Expand<T>;
 };
 export declare type Transform<T> = {
     aggregate?: Aggregate | Array<Aggregate>;
-    filter?: Filter;
+    filter?: Filter<T>;
     groupBy?: GroupBy<T>;
 };
 export declare type GroupBy<T> = {
@@ -74,7 +74,7 @@ export declare type QueryOptions<T> = ExpandOptions<T> & {
     key: string | number | {
         [name: string]: any;
     };
-    count: boolean | Filter;
+    count: boolean | Filter<T>;
     action: string;
     func: string | {
         [functionName: string]: {
@@ -83,9 +83,14 @@ export declare type QueryOptions<T> = ExpandOptions<T> & {
     };
     format: string;
     aliases: QueryCustomType[];
+    escape: boolean;
 };
 export declare const ITEM_ROOT = "";
-export default function <T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, }?: Partial<QueryOptions<T>>): string;
-export declare function buildPathAndQuery<T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, }?: Partial<QueryOptions<T>>): [string, {
+export default function <T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): string;
+export declare function buildPathAndQuery<T>({ select, search, skiptoken, format, top, skip, filter, transform, orderBy, key, count, expand, action, func, aliases, escape, }?: Partial<QueryOptions<T>>): [string, {
     [name: string]: any;
 }];
+export declare function normalizeValue(value: Value, { aliases, escape }: {
+    aliases?: QueryCustomType[];
+    escape?: boolean;
+}): any;

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

@@ -0,0 +1,19 @@
+import type { QueryCustomType } from '../builder';
+import { Renderable } from './syntax';
+export declare abstract class Expression<T> implements Renderable {
+    protected _children: Renderable[];
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    get [Symbol.toStringTag](): string;
+    abstract render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    children(): Renderable[];
+    length(): number;
+    toJSON(): {
+        children: any[];
+    };
+}

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

@@ -0,0 +1,26 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { ODataFunctions, ODataOperators, Renderable } from './syntax';
+export declare class ComputeExpression<T> extends Expression<T> {
+    names: string[];
+    constructor({ children, names, }?: {
+        children?: Renderable[];
+        names?: string[];
+    });
+    static e<T>(): ComputeExpression<T>;
+    static s<T extends object>(): T;
+    static compute<T extends object>(opts: (e: {
+        s: T;
+        e: () => ComputeExpression<T>;
+    }) => ComputeExpression<T>): ComputeExpression<T>;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    private _add;
+    field<T extends object>(name: string, opts: (e: {
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => Renderable): ComputeExpression<T>;
+}

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

@@ -0,0 +1,40 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { Renderable } from './syntax';
+export declare class ExpandField<T> implements Renderable {
+    protected field: Renderable;
+    constructor(field: Renderable);
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        field: any;
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+    select(): void;
+    filter(): void;
+    levels(): void;
+    orderBy(): void;
+    top(): void;
+    skip(): void;
+}
+export declare class ExpandExpression<T> extends Expression<T> {
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    static e<T>(): ExpandExpression<T>;
+    static s<T extends object>(): T;
+    static expand<T extends object>(opts: (e: {
+        s: T;
+        e: () => ExpandExpression<T>;
+    }) => ExpandExpression<T>): ExpandExpression<T>;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    private _add;
+    field<T extends object>(field: any, opts?: (e: ExpandField<keyof T>) => void): ExpandExpression<T>;
+}

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

@@ -0,0 +1,58 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { ODataFunctions, ODataOperators, Renderable } from './syntax';
+export declare type FilterConnector = 'and' | 'or';
+export declare class FilterExpression<T> extends Expression<T> {
+    private _connector;
+    private _negated;
+    constructor({ children, connector, negated, }?: {
+        children?: Renderable[];
+        connector?: FilterConnector;
+        negated?: boolean;
+    });
+    static s<T extends object>(): T;
+    static e<T>(connector?: FilterConnector): FilterExpression<T>;
+    static filter<T extends object>(opts: (e: {
+        s: T;
+        e: (connector?: FilterConnector) => FilterExpression<T>;
+        o: ODataOperators<T>;
+        f: ODataFunctions<T>;
+    }) => FilterExpression<T>): FilterExpression<T>;
+    toJSON(): {
+        children: any[];
+        connector: FilterConnector;
+        negated: boolean;
+    };
+    connector(): FilterConnector;
+    negated(): boolean;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+    private _add;
+    or(exp: FilterExpression<T>): FilterExpression<T>;
+    and(exp: FilterExpression<T>): FilterExpression<T>;
+    not(exp: FilterExpression<T>): FilterExpression<T>;
+    eq(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    ne(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    gt(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    ge(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    lt(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    le(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    has(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    in(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    contains(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    startsWith(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    endsWith(left: any, right: any, normalize?: boolean): FilterExpression<T>;
+    any<N extends object>(left: N[], opts: (e: {
+        s: N;
+        e: (connector?: FilterConnector) => FilterExpression<N>;
+    }) => FilterExpression<N>, alias?: string): FilterExpression<T>;
+    all<N extends object>(left: N[], opts: (e: {
+        s: N;
+        e: (connector?: FilterConnector) => FilterExpression<N>;
+    }) => FilterExpression<N>, alias?: string): FilterExpression<T>;
+    isof(type: string): FilterExpression<T>;
+    isof(left: T, type: string): FilterExpression<T>;
+}

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

@@ -0,0 +1,6 @@
+export * from './base';
+export * from './compute';
+export * from './filter';
+export * from './orderby';
+export * from './search';
+export * from './syntax';

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

@@ -0,0 +1,37 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { Renderable } from './syntax';
+export declare class OrderByField implements Renderable {
+    protected field: Renderable;
+    protected order: 'asc' | 'desc';
+    constructor(field: Renderable, order: 'asc' | 'desc');
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        field: any;
+        order: "desc" | "asc";
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+}
+export declare class OrderByExpression<T> extends Expression<T> {
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    static e<T>(): OrderByExpression<T>;
+    static s<T extends object>(): T;
+    static orderBy<T extends object>(opts: (e: {
+        s: T;
+        e: () => OrderByExpression<T>;
+    }) => OrderByExpression<T>): OrderByExpression<T>;
+    private _add;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    ascending(field: any): OrderByExpression<T>;
+    descending(field: any): OrderByExpression<T>;
+}

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

@@ -0,0 +1,47 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { Renderable } from './syntax';
+export declare type SearchConnector = 'AND' | 'OR';
+export declare class SearchTerm implements Renderable {
+    protected value: string;
+    constructor(value: string);
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        value: string;
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+}
+export declare class SearchExpression<T> extends Expression<T> {
+    private _connector;
+    private _negated;
+    constructor({ children, connector, negated, }?: {
+        children?: Renderable[];
+        connector?: SearchConnector;
+        negated?: boolean;
+    });
+    static e<T>(connector?: SearchConnector): SearchExpression<T>;
+    static search<T extends object>(opts: (e: {
+        e: (connector?: SearchConnector) => SearchExpression<T>;
+    }) => SearchExpression<T>): SearchExpression<T>;
+    private _add;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    toJSON(): {
+        children: any[];
+        connector: SearchConnector;
+        negated: boolean;
+    };
+    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>;
+}

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

@@ -0,0 +1,21 @@
+import type { QueryCustomType } from '../builder';
+import { Expression } from './base';
+import { Renderable } from './syntax';
+export declare class SelectExpression<T> extends Expression<T> {
+    constructor({ children, }?: {
+        children?: Renderable[];
+    });
+    static e<T>(): SelectExpression<T>;
+    static s<T extends object>(): T;
+    static select<T extends object>(opts: (e: {
+        s: T;
+        e: () => SelectExpression<T>;
+    }) => SelectExpression<T>): SelectExpression<T>;
+    render({ aliases, escape, prefix, }?: {
+        aliases?: QueryCustomType[] | undefined;
+        escape?: boolean | undefined;
+        prefix?: string | undefined;
+    }): string;
+    private _add;
+    field(field: any): SelectExpression<T>;
+}

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

@@ -0,0 +1,177 @@
+import type { QueryCustomType } from '../builder';
+export interface Renderable {
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+    toString(): string;
+    toJSON(): any;
+}
+export declare class Field<T extends object> implements ProxyHandler<T> {
+    name: string;
+    constructor(name?: string);
+    static factory<T extends object>(): T;
+    get(target: T, p: string | symbol): any;
+}
+export declare function render(value: any, { aliases, normalize, escape, prefix, }?: {
+    aliases?: QueryCustomType[];
+    normalize?: boolean;
+    escape?: boolean;
+    prefix?: string;
+}): string | number | boolean | null;
+export declare class Function<T> implements Renderable {
+    protected name: string;
+    protected values: any[];
+    protected normalize: boolean;
+    protected escape: boolean;
+    constructor(name: string, values: any[], normalize?: boolean, escape?: boolean);
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        name: string;
+        values: any[];
+        normalize: boolean;
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+}
+export declare class StringAndCollectionFunctions<T> {
+    concat(field: any, value: any, normalize?: boolean): Function<T>;
+    contains(field: any, value: any, normalize?: boolean): Function<T>;
+    endsWith(field: any, value: any, normalize?: boolean): Function<T>;
+    indexOf(field: any, value: any, normalize?: boolean): Function<T>;
+    length(value: any, normalize?: boolean): Function<T>;
+    startsWith(field: any, value: any, normalize?: boolean): Function<T>;
+    subString(field: any, start: number, length?: number): Function<T>;
+}
+export declare class CollectionFunctions<T> {
+    hasSubset(s1: T, s2: any): Function<T>;
+    hasSubsequence(s1: T, s2: any): Function<T>;
+}
+export declare class StringFunctions<T> {
+    matchesPattern(value: T | string, pattern: string): Function<T>;
+    toLower(value: T): Function<T>;
+    toUpper(value: T): Function<T>;
+    trim(value: T): Function<T>;
+}
+export declare class DateAndTimeFunctions<T> {
+    date(value: any): Function<T>;
+    day(value: any): Function<T>;
+    fractionalseconds(value: any): Function<T>;
+    hour(value: any): Function<T>;
+    maxdatetime(value: any): Function<T>;
+    mindatetime(value: any): Function<T>;
+    minute(value: any): Function<T>;
+    month(value: any): Function<T>;
+    now(): Function<T>;
+    second(value: any): Function<T>;
+    time(value: any): Function<T>;
+    totaloffsetminutes(value: any): Function<T>;
+    totalseconds(value: any): Function<T>;
+    year(value: any): Function<T>;
+}
+export declare class ArithmeticFunctions<T> {
+    ceiling(value: T | string): Function<T>;
+    floor(value: T | string): Function<T>;
+    round(value: T | string): Function<T>;
+}
+export declare class TypeFunctions<T> {
+    cast(value: T | string, type?: string): Function<T>;
+    isof(value: T | string, type?: string): Function<T>;
+}
+export declare class GeoFunctions<T> {
+    geoDistance(value: T, point: string, normalize?: boolean): Function<T>;
+    geoIntersects(value: T, polygon: string, normalize?: boolean): Function<T>;
+    geoLength(line: T, normalize?: boolean): Function<T>;
+}
+export declare class ConditionalFunctions<T> {
+    case(condition: T | string, value: any): Function<T>;
+}
+export declare class Operator<T> implements Renderable {
+    protected op: string;
+    protected values: any[];
+    protected normalize: boolean;
+    constructor(op: string, values: any[], normalize?: boolean);
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        op: string;
+        values: any[];
+        normalize: boolean;
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+}
+export declare class LogicalOperators<T> {
+    eq(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    ne(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    gt(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    ge(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    lt(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    le(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    not(value: any, normalize?: boolean): Operator<T>;
+    has(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    in(left: any, right: any, normalize?: boolean): Operator<unknown>;
+}
+export declare class ArithmeticOperators<T> {
+    add(left: any, right: any, normalize?: boolean): Operator<T>;
+    sub(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    mul(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    div(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    mod(left: any, right: any, normalize?: boolean): Operator<unknown>;
+    neg(value: any, normalize?: boolean): Operator<unknown>;
+}
+export declare class Grouping<T> implements Renderable {
+    protected group: Renderable;
+    constructor(group: Renderable);
+    get [Symbol.toStringTag](): string;
+    toJSON(): {
+        group: any;
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+}
+export 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(): {
+        op: string;
+        values: any[];
+        alias: string | undefined;
+    };
+    render({ aliases, escape, prefix, }: {
+        aliases?: QueryCustomType[];
+        escape?: boolean;
+        prefix?: string;
+    }): string;
+}
+export declare class LambdaOperators<T> {
+    any(field: T, value: any, alias?: string): Lambda<unknown>;
+    all(field: T, value: any, alias?: string): Lambda<unknown>;
+}
+export declare class ODataOperators<T> {
+}
+export interface ODataOperators<T> extends LogicalOperators<T>, ArithmeticOperators<T>, LambdaOperators<T> {
+}
+export declare const operators: ODataOperators<any>;
+export declare class ODataFunctions<T> {
+}
+export interface ODataFunctions<T> extends StringAndCollectionFunctions<T>, CollectionFunctions<T>, StringFunctions<T>, DateAndTimeFunctions<T>, ArithmeticFunctions<T>, TypeFunctions<T>, GeoFunctions<T>, ConditionalFunctions<T> {
+}
+export declare const functions: ODataFunctions<any>;
+export declare class ODataSyntax<T> {
+}
+export interface ODataSyntax<T> extends ODataOperators<T>, ODataFunctions<T> {
+}
+export declare const syntax: ODataSyntax<any>;