angular-odata 0.131.0 → 0.140.0

package/lib/resources/options.d.ts

@@ -1,18 +0,0 @@
-import { ODataMetadataType, ODataVersion, ParserOptions, ResponseOptions } from '../types';
-export 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(): import("../helper").ODataVersionHelper;
-    clone(): ODataResponseOptions;
-    setFeatures(features: string): void;
-    setVersion(version: string): void;
-    setLocation(location: string): void;
-    setPreferenceApplied(preference: string): void;
-    setCache(cacheControl: string): void;
-}

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

@@ -1,29 +0,0 @@
-import { PathSegment } from '../../types';
-import { EntityKey } from '../resource';
-import { ODataPathSegments, ODataSegment } from './segments';
-export 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;
-}
-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

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

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

@@ -1,54 +0,0 @@
-import { Parser, ParserOptions, PathSegment } from '../../types';
-import { EntityKey } from '../resource';
-import { SegmentHandler } from './handlers';
-export type ODataSegment = {
-    name: PathSegment;
-    path: string;
-    outgoingType?: string;
-    incomingType?: string;
-    bindingType?: string;
-    key?: any;
-    parameters?: any;
-};
-export declare const pathAndParamsFromSegments: (segments: ODataSegment[], { escape, parser, options, }?: {
-    escape?: boolean;
-    parser?: Parser<any>;
-    options?: ParserOptions;
-}) => [string, {
-    [name: string]: any;
-}];
-export 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;
-}

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

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

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

@@ -1,125 +0,0 @@
-import { Parser, ParserOptions } from '../../../types';
-import { QueryCustomType } from '../builder';
-import { Expression } from './base';
-import { FilterConnector, FilterExpression } from './filter';
-import { SearchConnector, SearchExpression } from './search';
-import { ODataFunctions, ODataOperators, Renderable, AggregateMethod } from './syntax';
-export 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>;
-}
-export type ApplyExpressionBuilder<T> = {
-    t: Required<T>;
-    e: () => ApplyExpression<T>;
-};
-export 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>;
-}

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

@@ -1,25 +0,0 @@
-import { Parser, ParserOptions } from '../../../types';
-import { 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, 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;
-}

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

@@ -1,39 +0,0 @@
-import { Parser, ParserOptions } from '../../../types';
-import { QueryCustomType } from '../builder';
-import { Expression } from './base';
-import { ODataFunctions, ODataOperators, Renderable } from './syntax';
-export type ComputeExpressionBuilder<T> = {
-    t: Required<T>;
-    e: () => ComputeExpression<T>;
-};
-export 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>;
-}

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

@@ -1,58 +0,0 @@
-import { Parser, ParserOptions } from '../../../types';
-import { QueryCustomType } from '../builder';
-import { Expression } from './base';
-import { FilterExpression, FilterExpressionBuilder } from './filter';
-import { Renderable } from './syntax';
-export 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;
-}
-export type CountExpressionBuilder<T> = {
-    t: Required<T>;
-    e: () => CountExpression<T>;
-};
-export 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>;
-}

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

@@ -1,69 +0,0 @@
-import { Parser, ParserOptions } from '../../../types';
-import { QueryCustomType, Unpacked } from '../builder';
-import { Expression } from './base';
-import { ComputeExpression, ComputeExpressionBuilder } from './compute';
-import { FilterExpression, FilterExpressionBuilder } from './filter';
-import { OrderByExpression, OrderByExpressionBuilder } from './orderby';
-import { SearchExpression, SearchExpressionBuilder } from './search';
-import { SelectExpression, SelectExpressionBuilder } from './select';
-import { Renderable } from './syntax';
-export 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>) => 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;
-}
-export type ExpandExpressionBuilder<T> = {
-    t: Required<T>;
-    e: () => ExpandExpression<T>;
-};
-export 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>;
-}

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

@@ -1,77 +0,0 @@
-import { Parser, ParserOptions } from '../../../types';
-import { QueryCustomType } from '../builder';
-import { Expression } from './base';
-import { CountExpression, CountField } from './count';
-import { Normalize, ODataFunctions, ODataOperators, Renderable } from './syntax';
-export type FilterConnector = 'and' | 'or';
-export type FilterExpressionBuilder<T> = {
-    t: Required<T>;
-    e: (connector?: FilterConnector) => FilterExpression<T>;
-    o: ODataOperators<T>;
-    f: ODataFunctions<T>;
-};
-export 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>;
-}

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

@@ -1,9 +0,0 @@
-export * from './base';
-export * from './compute';
-export * from './apply';
-export * from './filter';
-export * from './orderby';
-export * from './search';
-export * from './select';
-export * from './syntax';
-export * from './expand';

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

@@ -1,55 +0,0 @@
-import { Parser, ParserOptions } from '../../../types';
-import { QueryCustomType } from '../builder';
-import { Expression } from './base';
-import { Renderable } from './syntax';
-export type OrderAttribute = 'asc' | 'desc';
-export 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;
-}
-export type OrderByExpressionBuilder<T> = {
-    t: Required<T>;
-    e: () => OrderByExpression<T>;
-};
-export 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>;
-}