angular-odata/lib/resources/query/expressions/syntax.d.ts

Client side OData typescript library for Angular

import { Parser, ParserOptions } from '../../../types';
import { QueryCustomType } from '../builder';
export type Normalize = 'all' | 'right' | 'left' | 'none';
export 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;
}
export declare const FieldFactory: <T extends object>(names?: (string | Renderable)[]) => any;
export declare const RenderableFactory: (value: any) => Renderable;
export declare function render(value: any, { aliases, normalize, escape, prefix, parser, options, }?: {
    aliases?: QueryCustomType[];
    normalize?: boolean;
    escape?: boolean;
    prefix?: string;
    parser?: Parser<any>;
    options?: ParserOptions;
}): string | number | boolean | null;
export declare function resolve(values: any, parser?: Parser<any>): any;
export declare function encode(values: any, parser?: Parser<any>, options?: ParserOptions): any;
export 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;
}
export 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>;
}
export declare class CollectionFunctions<T> {
    hasSubset(left: T, right: any, normalize?: Normalize): Function<T>;
    hasSubsequence(left: T, right: any, normalize?: Normalize): Function<T>;
}
export 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>;
}
export 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>;
}
export 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>;
}
export declare class TypeFunctions<T> {
    cast<N>(left: T | string, type?: string): N;
    isof(left: T | string, type?: string): Type<T>;
}
export declare class GeoFunctions<T> {
    geoDistance(left: T, right: string, normalize?: Normalize): Function<T>;
    geoIntersects(left: T, right: string, normalize?: Normalize): Function<T>;
    geoLength(left: T, normalize?: Normalize): Function<T>;
}
export declare class ConditionalFunctions<T> {
    case(left: T | string, right: any, normalize?: Normalize): Function<T>;
}
export 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;
}
export 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>;
}
export 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>;
}
export 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;
}
export declare class GroupingOperators<T> {
    group(value: any): Grouping<T>;
    rollup(...values: any): Function<T>;
}
export type AggregateMethod = 'sum' | 'min' | 'max' | 'average' | 'countdistinct';
export 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;
}
export 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;
}
export 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>;
}
export 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;
}
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(): {
        $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;
}
export declare class LambdaOperators<T> {
    any(left: T, right: any, alias?: string): Lambda<unknown>;
    all(left: T, right: any, alias?: string): Lambda<unknown>;
}
export declare class ODataOperators<T> {
}
export interface ODataOperators<T> extends LogicalOperators<T>, ArithmeticOperators<T>, GroupingOperators<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 ODataTransformations<T> {
}
export interface ODataTransformations<T> extends Transformations<T> {
}
export declare const transformations: ODataTransformations<any>;
export declare class ODataSyntax<T> {
}
export interface ODataSyntax<T> extends ODataOperators<T>, ODataFunctions<T>, ODataTransformations<T> {
}
export declare const syntax: ODataSyntax<any>;