angular-odata 0.92.0 → 0.95.0

package/esm2020/lib/resources/query/syntax.mjs

@@ -0,0 +1,406 @@
+import { normalizeValue } from './builder';
+//export type Field<T> = keyof T | Funcs<keyof T>;
+export class Field {
+    constructor(name = '') {
+        this.name = name;
+    }
+    static factory() {
+        const h = new Field();
+        return new Proxy({ _name: '' }, h);
+    }
+    get(target, p) {
+        let name = target['_name'];
+        if (p === 'render') {
+            return ({ prefix }) => prefix ? `${prefix}/${name}` : name;
+        }
+        name = name ? `${name}/${p}` : p;
+        return new Proxy({ _name: name }, this);
+    }
+}
+function applyMixins(derivedCtor, constructors) {
+    constructors.forEach((baseCtor) => {
+        Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+            Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) ||
+                Object.create(null));
+        });
+    });
+}
+function render(value, { aliases, normalize, escape, prefix, } = {}) {
+    if (typeof value === 'function') {
+        return render(value(syntax), { aliases, normalize, prefix });
+    }
+    if (typeof value === 'object' &&
+        value !== null &&
+        value.render !== undefined) {
+        return render(value.render({ aliases, escape, prefix }), {
+            aliases,
+            normalize,
+            escape,
+            prefix,
+        });
+    }
+    return normalize ? normalizeValue(value, { aliases, escape }) : value;
+}
+export class Function {
+    constructor(name, values, normalize = true, escape = false) {
+        this.name = name;
+        this.values = values;
+        this.normalize = normalize;
+        this.escape = escape;
+    }
+    get [Symbol.toStringTag]() {
+        return 'Function';
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            values: this.values,
+            normalize: this.normalize,
+        };
+    }
+    render({ aliases, escape, prefix, }) {
+        let [field, ...values] = this.values;
+        field = render(field, { aliases, escape, prefix });
+        let params = [
+            field,
+            ...values.map((v) => render(v, { aliases, escape, prefix, normalize: this.normalize })),
+        ];
+        return `${this.name}(${params.join(', ')})`;
+    }
+}
+export class StringAndCollectionFunctions {
+    concat(field, value, normalize) {
+        return new Function('concat', [field, value], normalize);
+    }
+    contains(field, value, normalize) {
+        return new Function('contains', [field, value], normalize);
+    }
+    endsWith(field, value, normalize) {
+        return new Function('endswith', [field, value], normalize);
+    }
+    indexOf(field, value, normalize) {
+        return new Function('indexof', [field, value], normalize);
+    }
+    length(value, normalize) {
+        return new Function('length', [value], normalize);
+    }
+    startsWith(field, value, normalize) {
+        return new Function('startswith', [field, value], normalize);
+    }
+    subString(field, start, length) {
+        let values = [field, start];
+        if (length !== undefined) {
+            values.push(length);
+        }
+        return new Function('substring', values);
+    }
+}
+export class CollectionFunctions {
+    hasSubset(s1, s2) {
+        return new Function('hassubset', [s1, s2]);
+    }
+    hasSubsequence(s1, s2) {
+        return new Function('hassubsequence', [s1, s2]);
+    }
+}
+export class StringFunctions {
+    matchesPattern(value, pattern) {
+        return new Function('matchesPattern', [value, pattern]);
+    }
+    toLower(value) {
+        return new Function('tolower', [value]);
+    }
+    toUpper(value) {
+        return new Function('toupper', [value]);
+    }
+    trim(value) {
+        return new Function('trim', [value]);
+    }
+}
+export class DateAndTimeFunctions {
+    date(value) {
+        return new Function('date', [value]);
+    }
+    day(value) {
+        return new Function('day', [value]);
+    }
+    fractionalseconds(value) {
+        return new Function('fractionalseconds', [value]);
+    }
+    hour(value) {
+        return new Function('hour', [value]);
+    }
+    maxdatetime(value) {
+        return new Function('maxdatetime', [value]);
+    }
+    mindatetime(value) {
+        return new Function('mindatetime', [value]);
+    }
+    minute(value) {
+        return new Function('minute', [value]);
+    }
+    month(value) {
+        return new Function('month', [value]);
+    }
+    now() {
+        return new Function('now', []);
+    }
+    second(value) {
+        return new Function('second', [value]);
+    }
+    time(value) {
+        return new Function('time', [value]);
+    }
+    totaloffsetminutes(value) {
+        return new Function('totaloffsetminutes', [value]);
+    }
+    totalseconds(value) {
+        return new Function('totalseconds', [value]);
+    }
+    year(value) {
+        return new Function('year', [value]);
+    }
+}
+export class ArithmeticFunctions {
+    ceiling(value) {
+        return new Function('ceiling', [value]);
+    }
+    floor(value) {
+        return new Function('floor', [value]);
+    }
+    round(value) {
+        return new Function('round', [value]);
+    }
+}
+export class TypeFunctions {
+    cast(value, type) {
+        return new Function('cast', [value, type]);
+    }
+    isof(value, type) {
+        return new Function('isof', [value, type]);
+    }
+}
+export class GeoFunctions {
+    geoDistance(value, point, normalize) {
+        return new Function('geo.distance', [value, point], normalize);
+    }
+    geoIntersects(value, polygon, normalize) {
+        return new Function('geo.intersects', [value, polygon], normalize);
+    }
+    geoLength(line, normalize) {
+        return new Function('geo.length', [line], normalize);
+    }
+}
+export class ConditionalFunctions {
+    case(condition, value) {
+        return new Function('case', [condition, value]);
+    }
+}
+export class Operator {
+    constructor(op, values, normalize = true) {
+        this.op = op;
+        this.values = values;
+        this.normalize = normalize;
+    }
+    get [Symbol.toStringTag]() {
+        return 'Operator';
+    }
+    toJSON() {
+        return {
+            op: this.op,
+            values: this.values,
+            normalize: this.normalize,
+        };
+    }
+    render({ aliases, escape, prefix, }) {
+        let [left, right] = this.values;
+        left = render(left, { aliases, escape, prefix });
+        if (right !== undefined) {
+            right = Array.isArray(right)
+                ? `(${right
+                    .map((v) => render(v, {
+                    aliases,
+                    escape,
+                    prefix,
+                    normalize: this.normalize,
+                }))
+                    .join(',')})`
+                : render(right, {
+                    aliases,
+                    escape,
+                    prefix,
+                    normalize: this.normalize,
+                });
+            return `${left} ${this.op} ${right}`;
+        }
+        return `${this.op}(${left})`;
+    }
+}
+export class LogicalOperators {
+    eq(left, right, normalize) {
+        return new Operator('eq', [left, right], normalize);
+    }
+    ne(left, right, normalize) {
+        return new Operator('ne', [left, right], normalize);
+    }
+    gt(left, right, normalize) {
+        return new Operator('gt', [left, right], normalize);
+    }
+    ge(left, right, normalize) {
+        return new Operator('ge', [left, right], normalize);
+    }
+    lt(left, right, normalize) {
+        return new Operator('lt', [left, right], normalize);
+    }
+    le(left, right, normalize) {
+        return new Operator('le', [left, right], normalize);
+    }
+    /*
+    and(left: any, right: any, normalize?: boolean) {
+      return new Operator('and', [left, right], normalize);
+    }
+    or(left: any, right: any, normalize?: boolean) {
+      return new Operator('or', [left, right], normalize);
+    }
+    */
+    not(value, normalize) {
+        return new Operator('not', [value], normalize);
+    }
+    has(left, right, normalize) {
+        return new Operator('has', [left, right], normalize);
+    }
+    in(left, right, normalize) {
+        return new Operator('in', [left, right], normalize);
+    }
+}
+export class ArithmeticOperators {
+    add(left, right, normalize) {
+        return new Operator('add', [left, right], normalize);
+    }
+    sub(left, right, normalize) {
+        return new Operator('sub', [left, right], normalize);
+    }
+    mul(left, right, normalize) {
+        return new Operator('mul', [left, right], normalize);
+    }
+    div(left, right, normalize) {
+        return new Operator('div', [left, right], normalize);
+    }
+    mod(left, right, normalize) {
+        return new Operator('mod', [left, right], normalize);
+    }
+    neg(value, normalize) {
+        return new Operator('-', [value], normalize);
+    }
+}
+export class Grouping {
+    constructor(group) {
+        this.group = group;
+    }
+    get [Symbol.toStringTag]() {
+        return 'Grouping';
+    }
+    toJSON() {
+        return {
+            group: this.group.toJSON(),
+        };
+    }
+    render({ aliases, escape, prefix, }) {
+        return `(${render(this.group, { aliases, escape, prefix })})`;
+    }
+}
+/*
+export class Navigation<T, N> implements Renderable {
+  constructor(protected field: T, protected value: Field<N>) {}
+
+  get [Symbol.toStringTag]() {
+    return 'Navigation';
+  }
+
+  toJSON() {
+    return {
+      field: this.field,
+      value: this.value,
+    };
+  }
+
+  render({
+    aliases,
+    escape,
+    prefix,
+  }: {
+    aliases?: QueryCustomType[];
+    escape?: boolean;
+    prefix?: string;
+  }): string {
+    return `${this.field}/${render(this.value, { aliases, escape, prefix })}`;
+  }
+}
+*/
+export class GroupingOperators {
+    grouping(value) {
+        return new Grouping(value);
+    }
+}
+export class Lambda {
+    constructor(op, values, alias) {
+        this.op = op;
+        this.values = values;
+        this.alias = alias;
+    }
+    get [Symbol.toStringTag]() {
+        return 'Lambda';
+    }
+    toJSON() {
+        return {
+            op: this.op,
+            values: this.values,
+            alias: this.alias,
+        };
+    }
+    render({ aliases, escape, prefix, }) {
+        let [left, right] = this.values;
+        left = render(left, { aliases, escape, prefix });
+        let alias = this.alias || left.split('/').pop().toLowerCase()[0];
+        return `${left}/${this.op}(${alias}:${render(right, {
+            aliases,
+            escape,
+            prefix: alias,
+        })})`;
+    }
+}
+export class LambdaOperators {
+    any(field, value, alias) {
+        return new Lambda('any', [field, value], alias);
+    }
+    all(field, value, alias) {
+        return new Lambda('all', [field, value], alias);
+    }
+}
+export class ODataOperators {
+}
+applyMixins(ODataOperators, [
+    LogicalOperators,
+    ArithmeticOperators,
+    GroupingOperators,
+    LambdaOperators,
+]);
+export const operators = new ODataOperators();
+export class ODataFunctions {
+}
+applyMixins(ODataFunctions, [
+    StringAndCollectionFunctions,
+    CollectionFunctions,
+    StringFunctions,
+    DateAndTimeFunctions,
+    ArithmeticFunctions,
+    TypeFunctions,
+    GeoFunctions,
+    ConditionalFunctions,
+]);
+export const functions = new ODataFunctions();
+export class ODataSyntax {
+}
+applyMixins(ODataSyntax, [ODataOperators, ODataFunctions]);
+export const syntax = new ODataSyntax();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"syntax.js","sourceRoot":"","sources":["../../../../../../projects/angular-odata/src/lib/resources/query/syntax.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAmB3C,kDAAkD;AAElD,MAAM,OAAO,KAAK;IAChB,YAAmB,OAAe,EAAE;QAAjB,SAAI,GAAJ,IAAI,CAAa;IAAG,CAAC;IAExC,MAAM,CAAC,OAAO;QACZ,MAAM,CAAC,GAAG,IAAI,KAAK,EAAK,CAAC;QACzB,OAAO,IAAI,KAAK,CAAC,EAAE,KAAK,EAAE,EAAE,EAAO,EAAE,CAAC,CAAC,CAAC;IAC1C,CAAC;IAED,GAAG,CAAC,MAAS,EAAE,CAAkB;QAC/B,IAAI,IAAI,GAAI,MAAc,CAAC,OAAO,CAAC,CAAC;QACpC,IAAI,CAAC,KAAK,QAAQ,EAAE;YAClB,OAAO,CAAC,EAAE,MAAM,EAAuB,EAAE,EAAE,CACzC,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;SACvC;QACD,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,CAAW,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3C,OAAO,IAAI,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,EAAS,EAAE,IAAI,CAAC,CAAC;IACjD,CAAC;CACF;AAED,SAAS,WAAW,CAAC,WAAgB,EAAE,YAAmB;IACxD,YAAY,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;QAChC,MAAM,CAAC,mBAAmB,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YAC9D,MAAM,CAAC,cAAc,CACnB,WAAW,CAAC,SAAS,EACrB,IAAI,EACJ,MAAM,CAAC,wBAAwB,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;gBACvD,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CACtB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED,SAAS,MAAM,CACb,KAAU,EACV,EACE,OAAO,EACP,SAAS,EACT,MAAM,EACN,MAAM,MAMJ,EAAE;IAEN,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE;QAC/B,OAAO,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;KAC9D;IACD,IACE,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,KAAK,CAAC,MAAM,KAAK,SAAS,EAC1B;QACA,OAAO,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE;YACvD,OAAO;YACP,SAAS;YACT,MAAM;YACN,MAAM;SACP,CAAC,CAAC;KACJ;IACD,OAAO,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;AACxE,CAAC;AAED,MAAM,OAAO,QAAQ;IACnB,YACY,IAAY,EACZ,MAAa,EACb,YAAqB,IAAI,EACzB,SAAkB,KAAK;QAHvB,SAAI,GAAJ,IAAI,CAAQ;QACZ,WAAM,GAAN,MAAM,CAAO;QACb,cAAS,GAAT,SAAS,CAAgB;QACzB,WAAM,GAAN,MAAM,CAAiB;IAChC,CAAC;IAEJ,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;QACtB,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,MAAM;QACJ,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,SAAS,EAAE,IAAI,CAAC,SAAS;SAC1B,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,EACL,OAAO,EACP,MAAM,EACN,MAAM,GAKP;QACC,IAAI,CAAC,KAAK,EAAE,GAAG,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QAErC,KAAK,GAAG,MAAM,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACnD,IAAI,MAAM,GAAG;YACX,KAAK;YACL,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAClB,MAAM,CAAC,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAClE;SACF,CAAC;QACF,OAAO,GAAG,IAAI,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;IAC9C,CAAC;CACF;AAED,MAAM,OAAO,4BAA4B;IACvC,MAAM,CAAC,KAAU,EAAE,KAAU,EAAE,SAAmB;QAChD,OAAO,IAAI,QAAQ,CAAI,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IAC9D,CAAC;IAED,QAAQ,CAAC,KAAU,EAAE,KAAU,EAAE,SAAmB;QAClD,OAAO,IAAI,QAAQ,CAAI,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IAChE,CAAC;IAED,QAAQ,CAAC,KAAU,EAAE,KAAU,EAAE,SAAmB;QAClD,OAAO,IAAI,QAAQ,CAAI,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IAChE,CAAC;IAED,OAAO,CAAC,KAAU,EAAE,KAAU,EAAE,SAAmB;QACjD,OAAO,IAAI,QAAQ,CAAI,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IAC/D,CAAC;IAED,MAAM,CAAC,KAAU,EAAE,SAAmB;QACpC,OAAO,IAAI,QAAQ,CAAI,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACvD,CAAC;IAED,UAAU,CAAC,KAAU,EAAE,KAAU,EAAE,SAAmB;QACpD,OAAO,IAAI,QAAQ,CAAI,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IAClE,CAAC;IAED,SAAS,CAAC,KAAU,EAAE,KAAa,EAAE,MAAe;QAClD,IAAI,MAAM,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC5B,IAAI,MAAM,KAAK,SAAS,EAAE;YACxB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SACrB;QACD,OAAO,IAAI,QAAQ,CAAI,WAAW,EAAE,MAAM,CAAC,CAAC;IAC9C,CAAC;CACF;AAED,MAAM,OAAO,mBAAmB;IAC9B,SAAS,CAAC,EAAK,EAAE,EAAO;QACtB,OAAO,IAAI,QAAQ,CAAI,WAAW,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IAChD,CAAC;IACD,cAAc,CAAC,EAAK,EAAE,EAAO;QAC3B,OAAO,IAAI,QAAQ,CAAI,gBAAgB,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACrD,CAAC;CACF;AAED,MAAM,OAAO,eAAe;IAC1B,cAAc,CAAC,KAAiB,EAAE,OAAe;QAC/C,OAAO,IAAI,QAAQ,CAAI,gBAAgB,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7D,CAAC;IACD,OAAO,CAAC,KAAQ;QACd,OAAO,IAAI,QAAQ,CAAI,SAAS,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7C,CAAC;IACD,OAAO,CAAC,KAAQ;QACd,OAAO,IAAI,QAAQ,CAAI,SAAS,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7C,CAAC;IACD,IAAI,CAAC,KAAQ;QACX,OAAO,IAAI,QAAQ,CAAI,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAC1C,CAAC;CACF;AAED,MAAM,OAAO,oBAAoB;IAC/B,IAAI,CAAC,KAAU;QACb,OAAO,IAAI,QAAQ,CAAI,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAC1C,CAAC;IACD,GAAG,CAAC,KAAU;QACZ,OAAO,IAAI,QAAQ,CAAI,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IACzC,CAAC;IACD,iBAAiB,CAAC,KAAU;QAC1B,OAAO,IAAI,QAAQ,CAAI,mBAAmB,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IACvD,CAAC;IACD,IAAI,CAAC,KAAU;QACb,OAAO,IAAI,QAAQ,CAAI,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAC1C,CAAC;IACD,WAAW,CAAC,KAAU;QACpB,OAAO,IAAI,QAAQ,CAAI,aAAa,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IACjD,CAAC;IACD,WAAW,CAAC,KAAU;QACpB,OAAO,IAAI,QAAQ,CAAI,aAAa,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IACjD,CAAC;IACD,MAAM,CAAC,KAAU;QACf,OAAO,IAAI,QAAQ,CAAI,QAAQ,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAC5C,CAAC;IACD,KAAK,CAAC,KAAU;QACd,OAAO,IAAI,QAAQ,CAAI,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3C,CAAC;IACD,GAAG;QACD,OAAO,IAAI,QAAQ,CAAI,KAAK,EAAE,EAAE,CAAC,CAAC;IACpC,CAAC;IACD,MAAM,CAAC,KAAU;QACf,OAAO,IAAI,QAAQ,CAAI,QAAQ,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAC5C,CAAC;IACD,IAAI,CAAC,KAAU;QACb,OAAO,IAAI,QAAQ,CAAI,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAC1C,CAAC;IACD,kBAAkB,CAAC,KAAU;QAC3B,OAAO,IAAI,QAAQ,CAAI,oBAAoB,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IACxD,CAAC;IACD,YAAY,CAAC,KAAU;QACrB,OAAO,IAAI,QAAQ,CAAI,cAAc,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAClD,CAAC;IACD,IAAI,CAAC,KAAU;QACb,OAAO,IAAI,QAAQ,CAAI,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAC1C,CAAC;CACF;AAED,MAAM,OAAO,mBAAmB;IAC9B,OAAO,CAAC,KAAiB;QACvB,OAAO,IAAI,QAAQ,CAAI,SAAS,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7C,CAAC;IACD,KAAK,CAAC,KAAiB;QACrB,OAAO,IAAI,QAAQ,CAAI,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3C,CAAC;IACD,KAAK,CAAC,KAAiB;QACrB,OAAO,IAAI,QAAQ,CAAI,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3C,CAAC;CACF;AAED,MAAM,OAAO,aAAa;IACxB,IAAI,CAAC,KAAiB,EAAE,IAAa;QACnC,OAAO,IAAI,QAAQ,CAAI,MAAM,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;IAChD,CAAC;IAED,IAAI,CAAC,KAAiB,EAAE,IAAa;QACnC,OAAO,IAAI,QAAQ,CAAI,MAAM,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;IAChD,CAAC;CACF;AAED,MAAM,OAAO,YAAY;IACvB,WAAW,CAAC,KAAQ,EAAE,KAAa,EAAE,SAAmB;QACtD,OAAO,IAAI,QAAQ,CAAI,cAAc,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACpE,CAAC;IACD,aAAa,CAAC,KAAQ,EAAE,OAAe,EAAE,SAAmB;QAC1D,OAAO,IAAI,QAAQ,CAAI,gBAAgB,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC;IACxE,CAAC;IACD,SAAS,CAAC,IAAO,EAAE,SAAmB;QACpC,OAAO,IAAI,QAAQ,CAAI,YAAY,EAAE,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,CAAC;IAC1D,CAAC;CACF;AAED,MAAM,OAAO,oBAAoB;IAC/B,IAAI,CAAC,SAAqB,EAAE,KAAU;QACpC,OAAO,IAAI,QAAQ,CAAI,MAAM,EAAE,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;IACrD,CAAC;CACF;AAED,MAAM,OAAO,QAAQ;IACnB,YACY,EAAU,EACV,MAAa,EACb,YAAqB,IAAI;QAFzB,OAAE,GAAF,EAAE,CAAQ;QACV,WAAM,GAAN,MAAM,CAAO;QACb,cAAS,GAAT,SAAS,CAAgB;IAClC,CAAC;IAEJ,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;QACtB,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,MAAM;QACJ,OAAO;YACL,EAAE,EAAE,IAAI,CAAC,EAAE;YACX,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,SAAS,EAAE,IAAI,CAAC,SAAS;SAC1B,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,EACL,OAAO,EACP,MAAM,EACN,MAAM,GAKP;QACC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QAEhC,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACjD,IAAI,KAAK,KAAK,SAAS,EAAE;YACvB,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;gBAC1B,CAAC,CAAC,IAAI,KAAK;qBACN,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACT,MAAM,CAAC,CAAC,EAAE;oBACR,OAAO;oBACP,MAAM;oBACN,MAAM;oBACN,SAAS,EAAE,IAAI,CAAC,SAAS;iBAC1B,CAAC,CACH;qBACA,IAAI,CAAC,GAAG,CAAC,GAAG;gBACjB,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE;oBACZ,OAAO;oBACP,MAAM;oBACN,MAAM;oBACN,SAAS,EAAE,IAAI,CAAC,SAAS;iBAC1B,CAAC,CAAC;YACP,OAAO,GAAG,IAAI,IAAI,IAAI,CAAC,EAAE,IAAI,KAAK,EAAE,CAAC;SACtC;QACD,OAAO,GAAG,IAAI,CAAC,EAAE,IAAI,IAAI,GAAG,CAAC;IAC/B,CAAC;CACF;AAED,MAAM,OAAO,gBAAgB;IAC3B,EAAE,CAAC,IAAS,EAAE,KAAU,EAAE,SAAmB;QAC3C,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACtD,CAAC;IACD,EAAE,CAAC,IAAS,EAAE,KAAU,EAAE,SAAmB;QAC3C,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACtD,CAAC;IACD,EAAE,CAAC,IAAS,EAAE,KAAU,EAAE,SAAmB;QAC3C,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACtD,CAAC;IACD,EAAE,CAAC,IAAS,EAAE,KAAU,EAAE,SAAmB;QAC3C,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACtD,CAAC;IACD,EAAE,CAAC,IAAS,EAAE,KAAU,EAAE,SAAmB;QAC3C,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACtD,CAAC;IACD,EAAE,CAAC,IAAS,EAAE,KAAU,EAAE,SAAmB;QAC3C,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACtD,CAAC;IACD;;;;;;;MAOE;IACF,GAAG,CAAC,KAAU,EAAE,SAAmB;QACjC,OAAO,IAAI,QAAQ,CAAI,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACpD,CAAC;IACD,GAAG,CAAC,IAAS,EAAE,KAAU,EAAE,SAAmB;QAC5C,OAAO,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACvD,CAAC;IACD,EAAE,CAAC,IAAS,EAAE,KAAU,EAAE,SAAmB;QAC3C,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACtD,CAAC;CACF;AAED,MAAM,OAAO,mBAAmB;IAC9B,GAAG,CAAC,IAAS,EAAE,KAAU,EAAE,SAAmB;QAC5C,OAAO,IAAI,QAAQ,CAAI,KAAK,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IAC1D,CAAC;IACD,GAAG,CAAC,IAAS,EAAE,KAAU,EAAE,SAAmB;QAC5C,OAAO,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACvD,CAAC;IACD,GAAG,CAAC,IAAS,EAAE,KAAU,EAAE,SAAmB;QAC5C,OAAO,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACvD,CAAC;IACD,GAAG,CAAC,IAAS,EAAE,KAAU,EAAE,SAAmB;QAC5C,OAAO,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACvD,CAAC;IACD,GAAG,CAAC,IAAS,EAAE,KAAU,EAAE,SAAmB;QAC5C,OAAO,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IACvD,CAAC;IACD,GAAG,CAAC,KAAU,EAAE,SAAmB;QACjC,OAAO,IAAI,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC;IAC/C,CAAC;CACF;AAED,MAAM,OAAO,QAAQ;IACnB,YAAsB,KAAiB;QAAjB,UAAK,GAAL,KAAK,CAAY;IAAG,CAAC;IAE3C,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;QACtB,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,MAAM;QACJ,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE;SAC3B,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,EACL,OAAO,EACP,MAAM,EACN,MAAM,GAKP;QACC,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC;IAChE,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BE;AAEF,MAAM,OAAO,iBAAiB;IAC5B,QAAQ,CAAC,KAAU;QACjB,OAAO,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;CAOF;AAED,MAAM,OAAO,MAAM;IACjB,YACY,EAAU,EACV,MAAa,EACb,KAAc;QAFd,OAAE,GAAF,EAAE,CAAQ;QACV,WAAM,GAAN,MAAM,CAAO;QACb,UAAK,GAAL,KAAK,CAAS;IACvB,CAAC;IAEJ,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;QACtB,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,MAAM;QACJ,OAAO;YACL,EAAE,EAAE,IAAI,CAAC,EAAE;YACX,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,EACL,OAAO,EACP,MAAM,EACN,MAAM,GAKP;QACC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QAEhC,IAAI,GAAG,MAAM,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACjD,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC;QACjE,OAAO,GAAG,IAAI,IAAI,IAAI,CAAC,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,KAAK,EAAE;YAClD,OAAO;YACP,MAAM;YACN,MAAM,EAAE,KAAK;SACd,CAAC,GAAG,CAAC;IACR,CAAC;CACF;AAED,MAAM,OAAO,eAAe;IAC1B,GAAG,CAAC,KAAQ,EAAE,KAAU,EAAE,KAAc;QACtC,OAAO,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;IAClD,CAAC;IAED,GAAG,CAAC,KAAQ,EAAE,KAAU,EAAE,KAAc;QACtC,OAAO,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;IAClD,CAAC;CACF;AAED,MAAM,OAAO,cAAc;CAAM;AAOjC,WAAW,CAAC,cAAc,EAAE;IAC1B,gBAAgB;IAChB,mBAAmB;IACnB,iBAAiB;IACjB,eAAe;CAChB,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,SAAS,GAAwB,IAAI,cAAc,EAAO,CAAC;AAExE,MAAM,OAAO,cAAc;CAAM;AAWjC,WAAW,CAAC,cAAc,EAAE;IAC1B,4BAA4B;IAC5B,mBAAmB;IACnB,eAAe;IACf,oBAAoB;IACpB,mBAAmB;IACnB,aAAa;IACb,YAAY;IACZ,oBAAoB;CACrB,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,SAAS,GAAwB,IAAI,cAAc,EAAO,CAAC;AAExE,MAAM,OAAO,WAAW;CAAM;AAE9B,WAAW,CAAC,WAAW,EAAE,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC;AAE3D,MAAM,CAAC,MAAM,MAAM,GAAqB,IAAI,WAAW,EAAO,CAAC","sourcesContent":["import type { QueryCustomType } from './builder';\nimport { normalizeValue } from './builder';\n\nexport interface Renderable {\n  render({\n    aliases,\n    escape,\n    prefix,\n  }: {\n    aliases?: QueryCustomType[];\n    escape?: boolean;\n    prefix?: string;\n  }): string;\n  toString(): string;\n  toJSON(): any;\n}\n\nexport type Funcs<T> = (\n  x: ODataSyntax<T>\n) => Function<T> | Operator<T> | Grouping<T>;\n//export type Field<T> = keyof T | Funcs<keyof T>;\n\nexport class Field<T extends object> implements ProxyHandler<T> {\n  constructor(public name: string = '') {}\n\n  static factory<T extends object>() {\n    const h = new Field<T>();\n    return new Proxy({ _name: '' } as T, h);\n  }\n\n  get(target: T, p: string | symbol): any {\n    let name = (target as any)['_name'];\n    if (p === 'render') {\n      return ({ prefix }: { prefix?: string }) =>\n        prefix ? `${prefix}/${name}` : name;\n    }\n    name = name ? `${name}/${p as string}` : p;\n    return new Proxy({ _name: name } as any, this);\n  }\n}\n\nfunction applyMixins(derivedCtor: any, constructors: any[]) {\n  constructors.forEach((baseCtor) => {\n    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {\n      Object.defineProperty(\n        derivedCtor.prototype,\n        name,\n        Object.getOwnPropertyDescriptor(baseCtor.prototype, name) ||\n          Object.create(null)\n      );\n    });\n  });\n}\n\nfunction render(\n  value: any,\n  {\n    aliases,\n    normalize,\n    escape,\n    prefix,\n  }: {\n    aliases?: QueryCustomType[];\n    normalize?: boolean;\n    escape?: boolean;\n    prefix?: string;\n  } = {}\n): string | number | boolean | null {\n  if (typeof value === 'function') {\n    return render(value(syntax), { aliases, normalize, prefix });\n  }\n  if (\n    typeof value === 'object' &&\n    value !== null &&\n    value.render !== undefined\n  ) {\n    return render(value.render({ aliases, escape, prefix }), {\n      aliases,\n      normalize,\n      escape,\n      prefix,\n    });\n  }\n  return normalize ? normalizeValue(value, { aliases, escape }) : value;\n}\n\nexport class Function<T> implements Renderable {\n  constructor(\n    protected name: string,\n    protected values: any[],\n    protected normalize: boolean = true,\n    protected escape: boolean = false\n  ) {}\n\n  get [Symbol.toStringTag]() {\n    return 'Function';\n  }\n\n  toJSON() {\n    return {\n      name: this.name,\n      values: this.values,\n      normalize: this.normalize,\n    };\n  }\n\n  render({\n    aliases,\n    escape,\n    prefix,\n  }: {\n    aliases?: QueryCustomType[];\n    escape?: boolean;\n    prefix?: string;\n  }): string {\n    let [field, ...values] = this.values;\n\n    field = render(field, { aliases, escape, prefix });\n    let params = [\n      field,\n      ...values.map((v) =>\n        render(v, { aliases, escape, prefix, normalize: this.normalize })\n      ),\n    ];\n    return `${this.name}(${params.join(', ')})`;\n  }\n}\n\nexport class StringAndCollectionFunctions<T> {\n  concat(field: any, value: any, normalize?: boolean) {\n    return new Function<T>('concat', [field, value], normalize);\n  }\n\n  contains(field: any, value: any, normalize?: boolean) {\n    return new Function<T>('contains', [field, value], normalize);\n  }\n\n  endsWith(field: any, value: any, normalize?: boolean) {\n    return new Function<T>('endswith', [field, value], normalize);\n  }\n\n  indexOf(field: any, value: any, normalize?: boolean) {\n    return new Function<T>('indexof', [field, value], normalize);\n  }\n\n  length(value: any, normalize?: boolean) {\n    return new Function<T>('length', [value], normalize);\n  }\n\n  startsWith(field: any, value: any, normalize?: boolean) {\n    return new Function<T>('startswith', [field, value], normalize);\n  }\n\n  subString(field: any, start: number, length?: number) {\n    let values = [field, start];\n    if (length !== undefined) {\n      values.push(length);\n    }\n    return new Function<T>('substring', values);\n  }\n}\n\nexport class CollectionFunctions<T> {\n  hasSubset(s1: T, s2: any) {\n    return new Function<T>('hassubset', [s1, s2]);\n  }\n  hasSubsequence(s1: T, s2: any) {\n    return new Function<T>('hassubsequence', [s1, s2]);\n  }\n}\n\nexport class StringFunctions<T> {\n  matchesPattern(value: T | string, pattern: string) {\n    return new Function<T>('matchesPattern', [value, pattern]);\n  }\n  toLower(value: T) {\n    return new Function<T>('tolower', [value]);\n  }\n  toUpper(value: T) {\n    return new Function<T>('toupper', [value]);\n  }\n  trim(value: T) {\n    return new Function<T>('trim', [value]);\n  }\n}\n\nexport class DateAndTimeFunctions<T> {\n  date(value: any) {\n    return new Function<T>('date', [value]);\n  }\n  day(value: any) {\n    return new Function<T>('day', [value]);\n  }\n  fractionalseconds(value: any) {\n    return new Function<T>('fractionalseconds', [value]);\n  }\n  hour(value: any) {\n    return new Function<T>('hour', [value]);\n  }\n  maxdatetime(value: any) {\n    return new Function<T>('maxdatetime', [value]);\n  }\n  mindatetime(value: any) {\n    return new Function<T>('mindatetime', [value]);\n  }\n  minute(value: any) {\n    return new Function<T>('minute', [value]);\n  }\n  month(value: any) {\n    return new Function<T>('month', [value]);\n  }\n  now() {\n    return new Function<T>('now', []);\n  }\n  second(value: any) {\n    return new Function<T>('second', [value]);\n  }\n  time(value: any) {\n    return new Function<T>('time', [value]);\n  }\n  totaloffsetminutes(value: any) {\n    return new Function<T>('totaloffsetminutes', [value]);\n  }\n  totalseconds(value: any) {\n    return new Function<T>('totalseconds', [value]);\n  }\n  year(value: any) {\n    return new Function<T>('year', [value]);\n  }\n}\n\nexport class ArithmeticFunctions<T> {\n  ceiling(value: T | string) {\n    return new Function<T>('ceiling', [value]);\n  }\n  floor(value: T | string) {\n    return new Function<T>('floor', [value]);\n  }\n  round(value: T | string) {\n    return new Function<T>('round', [value]);\n  }\n}\n\nexport class TypeFunctions<T> {\n  cast(value: T | string, type?: string) {\n    return new Function<T>('cast', [value, type]);\n  }\n\n  isof(value: T | string, type?: string) {\n    return new Function<T>('isof', [value, type]);\n  }\n}\n\nexport class GeoFunctions<T> {\n  geoDistance(value: T, point: string, normalize?: boolean) {\n    return new Function<T>('geo.distance', [value, point], normalize);\n  }\n  geoIntersects(value: T, polygon: string, normalize?: boolean) {\n    return new Function<T>('geo.intersects', [value, polygon], normalize);\n  }\n  geoLength(line: T, normalize?: boolean) {\n    return new Function<T>('geo.length', [line], normalize);\n  }\n}\n\nexport class ConditionalFunctions<T> {\n  case(condition: T | string, value: any) {\n    return new Function<T>('case', [condition, value]);\n  }\n}\n\nexport class Operator<T> implements Renderable {\n  constructor(\n    protected op: string,\n    protected values: any[],\n    protected normalize: boolean = true\n  ) {}\n\n  get [Symbol.toStringTag]() {\n    return 'Operator';\n  }\n\n  toJSON() {\n    return {\n      op: this.op,\n      values: this.values,\n      normalize: this.normalize,\n    };\n  }\n\n  render({\n    aliases,\n    escape,\n    prefix,\n  }: {\n    aliases?: QueryCustomType[];\n    escape?: boolean;\n    prefix?: string;\n  }): string {\n    let [left, right] = this.values;\n\n    left = render(left, { aliases, escape, prefix });\n    if (right !== undefined) {\n      right = Array.isArray(right)\n        ? `(${right\n            .map((v) =>\n              render(v, {\n                aliases,\n                escape,\n                prefix,\n                normalize: this.normalize,\n              })\n            )\n            .join(',')})`\n        : render(right, {\n            aliases,\n            escape,\n            prefix,\n            normalize: this.normalize,\n          });\n      return `${left} ${this.op} ${right}`;\n    }\n    return `${this.op}(${left})`;\n  }\n}\n\nexport class LogicalOperators<T> {\n  eq(left: any, right: any, normalize?: boolean) {\n    return new Operator('eq', [left, right], normalize);\n  }\n  ne(left: any, right: any, normalize?: boolean) {\n    return new Operator('ne', [left, right], normalize);\n  }\n  gt(left: any, right: any, normalize?: boolean) {\n    return new Operator('gt', [left, right], normalize);\n  }\n  ge(left: any, right: any, normalize?: boolean) {\n    return new Operator('ge', [left, right], normalize);\n  }\n  lt(left: any, right: any, normalize?: boolean) {\n    return new Operator('lt', [left, right], normalize);\n  }\n  le(left: any, right: any, normalize?: boolean) {\n    return new Operator('le', [left, right], normalize);\n  }\n  /*\n  and(left: any, right: any, normalize?: boolean) {\n    return new Operator('and', [left, right], normalize);\n  }\n  or(left: any, right: any, normalize?: boolean) {\n    return new Operator('or', [left, right], normalize);\n  }\n  */\n  not(value: any, normalize?: boolean) {\n    return new Operator<T>('not', [value], normalize);\n  }\n  has(left: any, right: any, normalize?: boolean) {\n    return new Operator('has', [left, right], normalize);\n  }\n  in(left: any, right: any, normalize?: boolean) {\n    return new Operator('in', [left, right], normalize);\n  }\n}\n\nexport class ArithmeticOperators<T> {\n  add(left: any, right: any, normalize?: boolean) {\n    return new Operator<T>('add', [left, right], normalize);\n  }\n  sub(left: any, right: any, normalize?: boolean) {\n    return new Operator('sub', [left, right], normalize);\n  }\n  mul(left: any, right: any, normalize?: boolean) {\n    return new Operator('mul', [left, right], normalize);\n  }\n  div(left: any, right: any, normalize?: boolean) {\n    return new Operator('div', [left, right], normalize);\n  }\n  mod(left: any, right: any, normalize?: boolean) {\n    return new Operator('mod', [left, right], normalize);\n  }\n  neg(value: any, normalize?: boolean) {\n    return new Operator('-', [value], normalize);\n  }\n}\n\nexport class Grouping<T> implements Renderable {\n  constructor(protected group: Renderable) {}\n\n  get [Symbol.toStringTag]() {\n    return 'Grouping';\n  }\n\n  toJSON() {\n    return {\n      group: this.group.toJSON(),\n    };\n  }\n\n  render({\n    aliases,\n    escape,\n    prefix,\n  }: {\n    aliases?: QueryCustomType[];\n    escape?: boolean;\n    prefix?: string;\n  }): string {\n    return `(${render(this.group, { aliases, escape, prefix })})`;\n  }\n}\n\n/*\nexport class Navigation<T, N> implements Renderable {\n  constructor(protected field: T, protected value: Field<N>) {}\n\n  get [Symbol.toStringTag]() {\n    return 'Navigation';\n  }\n\n  toJSON() {\n    return {\n      field: this.field,\n      value: this.value,\n    };\n  }\n\n  render({\n    aliases,\n    escape,\n    prefix,\n  }: {\n    aliases?: QueryCustomType[];\n    escape?: boolean;\n    prefix?: string;\n  }): string {\n    return `${this.field}/${render(this.value, { aliases, escape, prefix })}`;\n  }\n}\n*/\n\nexport class GroupingOperators<T> {\n  grouping(value: any) {\n    return new Grouping(value);\n  }\n\n  /*\n  navigation<N>(field: T, value: Field<N>) {\n    return new Navigation<T, N>(field, value);\n  }\n  */\n}\n\nexport class Lambda<T> implements Renderable {\n  constructor(\n    protected op: string,\n    protected values: any[],\n    protected alias?: string\n  ) {}\n\n  get [Symbol.toStringTag]() {\n    return 'Lambda';\n  }\n\n  toJSON() {\n    return {\n      op: this.op,\n      values: this.values,\n      alias: this.alias,\n    };\n  }\n\n  render({\n    aliases,\n    escape,\n    prefix,\n  }: {\n    aliases?: QueryCustomType[];\n    escape?: boolean;\n    prefix?: string;\n  }): string {\n    let [left, right] = this.values;\n\n    left = render(left, { aliases, escape, prefix });\n    let alias = this.alias || left.split('/').pop().toLowerCase()[0];\n    return `${left}/${this.op}(${alias}:${render(right, {\n      aliases,\n      escape,\n      prefix: alias,\n    })})`;\n  }\n}\n\nexport class LambdaOperators<T> {\n  any(field: T, value: any, alias?: string) {\n    return new Lambda('any', [field, value], alias);\n  }\n\n  all(field: T, value: any, alias?: string) {\n    return new Lambda('all', [field, value], alias);\n  }\n}\n\nexport class ODataOperators<T> {}\nexport interface ODataOperators<T>\n  extends LogicalOperators<T>,\n    ArithmeticOperators<T>,\n    GroupingOperators<T>,\n    LambdaOperators<T> {}\n\napplyMixins(ODataOperators, [\n  LogicalOperators,\n  ArithmeticOperators,\n  GroupingOperators,\n  LambdaOperators,\n]);\nexport const operators: ODataOperators<any> = new ODataOperators<any>();\n\nexport class ODataFunctions<T> {}\nexport interface ODataFunctions<T>\n  extends StringAndCollectionFunctions<T>,\n    CollectionFunctions<T>,\n    StringFunctions<T>,\n    DateAndTimeFunctions<T>,\n    ArithmeticFunctions<T>,\n    TypeFunctions<T>,\n    GeoFunctions<T>,\n    ConditionalFunctions<T> {}\n\napplyMixins(ODataFunctions, [\n  StringAndCollectionFunctions,\n  CollectionFunctions,\n  StringFunctions,\n  DateAndTimeFunctions,\n  ArithmeticFunctions,\n  TypeFunctions,\n  GeoFunctions,\n  ConditionalFunctions,\n]);\nexport const functions: ODataFunctions<any> = new ODataFunctions<any>();\n\nexport class ODataSyntax<T> {}\nexport interface ODataSyntax<T> extends ODataOperators<T>, ODataFunctions<T> {}\napplyMixins(ODataSyntax, [ODataOperators, ODataFunctions]);\n\nexport const syntax: ODataSyntax<any> = new ODataSyntax<any>();\n"]}