@tellaro/tql 0.1.0 → 0.1.2

package/dist/src/completionProvider.js

@@ -1,5 +1,10 @@
-import { tokenizeTql as y, COMPARISON_OPERATORS as k, LOGICAL_OPERATORS as v, AGGREGATION_FUNCTIONS as T, VISUALIZATION_TYPES as C, TYPE_HINTS as O, MUTATORS as N } from "./tokenizer.js";
-const I = [
+var I = Object.defineProperty;
+var S = (e, t, a) => t in e ? I(e, t, { enumerable: !0, configurable: !0, writable: !0, value: a }) : e[t] = a;
+var p = (e, t, a) => S(e, typeof t != "symbol" ? t + "" : t, a);
+import { tokenizeTql as b, COMPARISON_OPERATORS as A, LOGICAL_OPERATORS as L, AGGREGATION_FUNCTIONS as R, VISUALIZATION_TYPES as $, TYPE_HINTS as P, MUTATORS as D } from "./tokenizer.js";
+import { fuzzyMatch as _ } from "./fuzzyMatcher.js";
+import { getSchemaCache as M } from "./schemaCache.js";
+const E = [
   {
     label: "Simple equality",
     insertText: 'field eq "value"',
@@ -102,7 +107,7 @@ const I = [
     description: "Top 10 results by count",
     category: "Stats"
   }
-], A = {
+], U = {
   eq: { detail: "Equals", documentation: "Exact match comparison" },
   ne: { detail: "Not equals", documentation: "Match any value except this one" },
   gt: { detail: "Greater than", documentation: "Numeric/date comparison" },
@@ -136,7 +141,7 @@ const I = [
   not_any: { detail: "Not any matches", documentation: "Negation of any" },
   not_all: { detail: "Not all match", documentation: "Negation of all" },
   not_none: { detail: "Not none match", documentation: "Negation of none" }
-}, L = {
+}, z = {
   lowercase: { detail: "Convert to lowercase", documentation: "Transform string to lowercase" },
   uppercase: { detail: "Convert to uppercase", documentation: "Transform string to uppercase" },
   trim: { detail: "Trim whitespace", documentation: "Remove leading/trailing whitespace" },
@@ -165,7 +170,7 @@ const I = [
   sum: { detail: "Sum", documentation: "Sum of numeric array elements" },
   min: { detail: "Minimum", documentation: "Minimum value in array" },
   max: { detail: "Maximum", documentation: "Maximum value in array" }
-}, m = {
+}, h = {
   // String outputs
   lowercase: "keyword",
   uppercase: "keyword",
@@ -199,7 +204,7 @@ const I = [
   geo: "object",
   // Array output (returns array of strings)
   split: "keyword"
-}, S = {
+}, F = {
   // Universal operators (work with all types)
   eq: ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip"],
   ne: ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip"],
@@ -236,147 +241,190 @@ const I = [
   all: ["nested", "object", "keyword"],
   none: ["nested", "object", "keyword"]
 };
-function R(e, t, n) {
-  var u;
-  const o = y(e.substring(0, t)).filter((s) => s.type !== "whitespace");
-  if (o.length === 0)
+class q {
+  constructor() {
+    p(this, "cache", /* @__PURE__ */ new Map());
+    p(this, "maxSize", 50);
+    p(this, "maxAge", 5e3);
+  }
+  // 5 seconds
+  get(t) {
+    const a = this.cache.get(t);
+    if (a && Date.now() - a.timestamp < this.maxAge)
+      return a.result;
+    a && this.cache.delete(t);
+  }
+  set(t, a) {
+    if (this.cache.size >= this.maxSize) {
+      const o = this.cache.keys().next().value;
+      o && this.cache.delete(o);
+    }
+    this.cache.set(t, { result: a, timestamp: Date.now() });
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+const v = new q();
+function B(e, t, a) {
+  const o = `${e.substring(0, t)}|${t}`, i = v.get(o);
+  if (i)
+    return i.fieldName && !i.fieldType && a && (i.fieldType = f(i.fieldName, a)), i;
+  const n = G(e, t, a);
+  return v.set(o, n), n;
+}
+function G(e, t, a) {
+  var d;
+  const i = b(e.substring(0, t)).filter((l) => l.type !== "whitespace");
+  if (i.length === 0)
     return { type: "start" };
-  const a = o[o.length - 1], r = o.length > 1 ? o[o.length - 2] : null, d = a.end === t && !((u = e[t - 1]) != null && u.match(/\s/)), l = d ? a.value : void 0;
-  if (a.type === "logicalOp")
+  const n = i[i.length - 1], r = i.length > 1 ? i[i.length - 2] : null, u = n.end === t && !((d = e[t - 1]) != null && d.match(/\s/)), s = u ? n.value : void 0;
+  if (n.type === "logicalOp")
     return { type: "start" };
-  if (a.type === "paren" && a.value === "(")
+  if (n.type === "paren" && n.value === "(")
     return { type: "after_paren" };
-  if (a.type === "arrow")
-    return { type: "after_arrow", partialText: l };
-  if (a.type === "doubleColon")
-    return { type: "after_double_colon", partialText: l };
-  if (a.type === "visualization" && d)
-    return { type: "after_arrow", partialText: l };
-  if (a.type === "typeHint" && d)
-    return { type: "after_double_colon", partialText: l };
-  if (a.type === "keyword" && a.value.toLowerCase() === "stats")
-    return { type: "after_stats", partialText: l };
-  if (a.type === "keyword" && a.value.toLowerCase() === "by")
-    return { type: "after_by", partialText: l };
-  if (a.type === "pipe")
-    return { type: "after_pipe", partialText: l };
-  if (a.type === "mutator") {
-    if (d)
-      return { type: "after_pipe", partialText: l };
-    const s = a.value.toLowerCase(), c = m[s];
+  if (n.type === "arrow")
+    return { type: "after_arrow", partialText: s };
+  if (n.type === "doubleColon")
+    return { type: "after_double_colon", partialText: s };
+  if (n.type === "visualization" && u)
+    return { type: "after_arrow", partialText: s };
+  if (n.type === "typeHint" && u)
+    return { type: "after_double_colon", partialText: s };
+  if (n.type === "keyword" && n.value.toLowerCase() === "stats")
+    return { type: "after_stats", partialText: s };
+  if (n.type === "keyword" && n.value.toLowerCase() === "by")
+    return { type: "after_by", partialText: s };
+  if (n.type === "pipe")
+    return { type: "after_pipe", partialText: s };
+  if (n.type === "mutator") {
+    if (u)
+      return { type: "after_pipe", partialText: s };
+    const l = n.value.toLowerCase(), c = h[l];
     return {
       type: "after_mutator",
-      mutatorName: s,
+      mutatorName: l,
       mutatorOutputType: c
     };
   }
-  if (a.type === "aggregation")
-    return d ? { type: "after_stats", partialText: l } : { type: "after_value" };
-  if (a.type === "field") {
-    if (d)
-      return (r == null ? void 0 : r.type) === "pipe" ? { type: "after_pipe", partialText: l } : { type: "start", partialText: l };
+  if (n.type === "aggregation")
+    return u ? { type: "after_stats", partialText: s } : { type: "after_value" };
+  if (n.type === "field") {
+    if (u)
+      return (r == null ? void 0 : r.type) === "pipe" ? { type: "after_pipe", partialText: s } : { type: "start", partialText: s };
     if ((r == null ? void 0 : r.type) === "pipe")
-      return { type: "after_pipe", partialText: a.value };
-    const s = p(a.value, n);
-    return { type: "after_field", fieldName: a.value, fieldType: s };
+      return { type: "after_pipe", partialText: n.value };
+    const l = f(n.value, a);
+    return { type: "after_field", fieldName: n.value, fieldType: l };
   }
-  if (a.type === "operator") {
-    if (d) {
+  if (n.type === "operator") {
+    if (u) {
       if ((r == null ? void 0 : r.type) === "field") {
-        const s = p(r.value, n);
-        return { type: "after_field", fieldName: r.value, fieldType: s, partialText: l };
+        const l = f(r.value, a);
+        return { type: "after_field", fieldName: r.value, fieldType: l, partialText: s };
       }
       if ((r == null ? void 0 : r.type) === "mutator") {
-        const s = r.value.toLowerCase(), c = m[s];
-        return { type: "after_mutator", mutatorName: s, mutatorOutputType: c, partialText: l };
+        const l = r.value.toLowerCase(), c = h[l];
+        return { type: "after_mutator", mutatorName: l, mutatorOutputType: c, partialText: s };
       }
     }
-    return { type: "after_operator", operatorName: a.value };
+    return { type: "after_operator", operatorName: n.value };
   }
-  if (a.type === "string" || a.type === "number" || a.type === "boolean" || a.type === "null")
+  if (n.type === "string" || n.type === "number" || n.type === "boolean" || n.type === "null")
     return { type: "after_value" };
-  if (a.type === "paren" && a.value === ")")
+  if (n.type === "paren" && n.value === ")")
     return { type: "after_value" };
-  if ((r == null ? void 0 : r.type) === "field" && d) {
-    const s = p(r.value, n);
-    return { type: "after_field", fieldName: r.value, fieldType: s, partialText: l };
+  if ((r == null ? void 0 : r.type) === "field" && u) {
+    const l = f(r.value, a);
+    return { type: "after_field", fieldName: r.value, fieldType: l, partialText: s };
   }
-  if ((r == null ? void 0 : r.type) === "mutator" && d) {
-    const s = r.value.toLowerCase(), c = m[s];
-    return { type: "after_mutator", mutatorName: s, mutatorOutputType: c, partialText: l };
+  if ((r == null ? void 0 : r.type) === "mutator" && u) {
+    const l = r.value.toLowerCase(), c = h[l];
+    return { type: "after_mutator", mutatorName: l, mutatorOutputType: c, partialText: s };
   }
-  return { type: "unknown", partialText: l };
+  return { type: "unknown", partialText: s };
 }
-function p(e, t) {
-  if (!t) return;
-  const n = t.find((i) => i.name === e);
-  return n == null ? void 0 : n.type;
+function f(e, t) {
+  return t ? M().getFieldType(t, e) : void 0;
 }
-function B(e, t = {}) {
-  const { query: n, cursorPosition: i } = e, o = R(n, i, t.fields), a = [];
-  switch (o.type) {
+function te(e, t = {}) {
+  const { query: a, cursorPosition: o } = e, i = B(a, o, t.fields), n = [];
+  switch (i.type) {
     case "start":
     case "after_paren":
-      a.push(...f(t.fields, o.partialText)), a.push(_("NOT")), t.includeSnippets !== !1 && a.push(...E(t, o.partialText));
+      n.push(...y(t.fields, i.partialText)), n.push(N("NOT")), t.includeSnippets !== !1 && n.push(...Y(t, i.partialText));
       break;
     case "after_field":
-      a.push(...g(o.partialText, o.fieldType));
+      n.push(...x(i.partialText, i.fieldType));
       break;
     case "after_mutator":
-      a.push(...g(o.partialText, o.mutatorOutputType));
+      n.push(...x(i.partialText, i.mutatorOutputType));
       break;
     case "after_operator":
-      a.push(...D(o.fieldName, t));
+      n.push(...H(i.fieldName, t));
       break;
     case "after_value":
-      a.push(...x());
+      n.push(...C());
       break;
     case "after_pipe":
-      a.push(...M(o.partialText));
+      n.push(...K(i.partialText));
       break;
     case "after_double_colon":
-      a.push(...U(o.partialText));
+      n.push(...W(i.partialText));
       break;
     case "after_arrow":
-      a.push(...q(o.partialText));
+      n.push(...Z(i.partialText));
       break;
     case "after_stats":
-      a.push(...w(o.partialText));
+      n.push(...O(i.partialText));
       break;
     case "after_by":
-      a.push(...f(t.fields, o.partialText));
+      n.push(...y(t.fields, i.partialText));
       break;
     default:
-      a.push(...f(t.fields, o.partialText)), a.push(...g(o.partialText)), a.push(...x());
+      n.push(...y(t.fields, i.partialText)), n.push(...x(i.partialText)), n.push(...C());
   }
-  t.includeAggregations && o.type === "start" && a.push(...w(o.partialText));
-  let r = a;
-  if (o.partialText) {
-    const d = o.partialText.toLowerCase();
-    r = a.filter(
-      (l) => {
-        var u;
-        return l.label.toLowerCase().includes(d) || ((u = l.filterText) == null ? void 0 : u.toLowerCase().includes(d));
+  t.includeAggregations && i.type === "start" && n.push(...O(i.partialText));
+  let r = n;
+  const u = t.fuzzyMatching !== !1, s = t.minFuzzyScore ?? 0;
+  if (i.partialText) {
+    const d = i.partialText.toLowerCase();
+    if (u) {
+      const l = [];
+      for (const c of n) {
+        const m = _(d, c.label), w = c.filterText ? _(d, c.filterText) : { matched: !1, score: 0 }, g = m.score >= w.score ? m : w;
+        g.matched && g.score >= s && l.push({
+          ...c,
+          matchScore: g.score,
+          matchedIndices: m.matched ? m.matchedIndices : void 0
+        });
       }
-    );
+      r = l;
+    } else
+      r = n.filter(
+        (l) => {
+          var c;
+          return l.label.toLowerCase().includes(d) || ((c = l.filterText) == null ? void 0 : c.toLowerCase().includes(d));
+        }
+      );
   }
-  return r.sort((d, l) => d.sortOrder - l.sortOrder), t.maxItems && t.maxItems > 0 && (r = r.slice(0, t.maxItems)), r;
+  return r.sort((d, l) => d.matchScore !== void 0 && l.matchScore !== void 0 && l.matchScore !== d.matchScore ? l.matchScore - d.matchScore : d.sortOrder - l.sortOrder), t.maxItems && t.maxItems > 0 && (r = r.slice(0, t.maxItems)), r;
 }
-function f(e, t) {
+function y(e, t) {
   if (!e || e.length === 0)
-    return $(t);
-  const n = [];
-  for (const i of e) {
-    const o = h(i);
-    if (n.push(o), i.nested)
-      for (const a of i.nested) {
-        const r = h(a, i.name);
-        n.push(r);
+    return V(t);
+  const a = [];
+  for (const o of e) {
+    const i = k(o);
+    if (a.push(i), o.nested)
+      for (const n of o.nested) {
+        const r = k(n, o.name);
+        a.push(r);
       }
   }
-  return n;
+  return a;
 }
-function $(e) {
+function V(e) {
   return [
     { name: "hostname", description: "Host/machine name" },
     { name: "status", description: "Status value" },
@@ -393,44 +441,44 @@ function $(e) {
     { name: "os.version", description: "Operating system version" },
     { name: "customer", description: "Customer identifier" },
     { name: "stack", description: "Stack identifier" }
-  ].filter((n) => !e || n.name.toLowerCase().includes(e.toLowerCase())).map((n) => ({
-    label: n.name,
-    insertText: n.name,
+  ].filter((a) => !e || a.name.toLowerCase().includes(e.toLowerCase())).map((a) => ({
+    label: a.name,
+    insertText: a.name,
     kind: "field",
-    detail: n.description,
+    detail: a.description,
     sortOrder: 10
   }));
 }
-function h(e, t) {
-  const n = t ? `${t}.${e.name}` : e.name;
+function k(e, t) {
+  const a = t ? `${t}.${e.name}` : e.name;
   return {
-    label: n,
-    insertText: n,
+    label: a,
+    insertText: a,
     kind: "field",
     detail: e.description || `Type: ${e.type}`,
     documentation: e.examples ? `Examples: ${e.examples.join(", ")}` : void 0,
     sortOrder: 10
   };
 }
-function g(e, t) {
-  let n = [...k];
-  return t && (n = n.filter((i) => {
-    const o = S[i];
-    return !o || o.includes(t);
-  })), e && (n = n.filter((i) => i.toLowerCase().includes(e.toLowerCase()))), n.map((i, o) => {
-    const a = A[i] || { detail: i, documentation: "" }, r = P(i, t);
+function x(e, t) {
+  let a = [...A];
+  return t && (a = a.filter((o) => {
+    const i = F[o];
+    return !i || i.includes(t);
+  })), e && (a = a.filter((o) => o.toLowerCase().includes(e.toLowerCase()))), a.map((o, i) => {
+    const n = U[o] || { detail: o, documentation: "" }, r = j(o, t);
     return {
-      label: i,
+      label: o,
       insertText: r,
       kind: "operator",
-      detail: a.detail,
-      documentation: a.documentation,
-      sortOrder: 20 + o
+      detail: n.detail,
+      documentation: n.documentation,
+      sortOrder: 20 + i
     };
   });
 }
-function P(e, t) {
-  const n = [
+function j(e, t) {
+  const a = [
     "contains",
     "not_contains",
     "startswith",
@@ -442,18 +490,18 @@ function P(e, t) {
     "not_regexp",
     "matches",
     "not_matches"
-  ], i = ["exists", "not_exists"], o = ["is", "is_not"];
+  ], o = ["exists", "not_exists"], i = ["is", "is_not"];
   if (e === "in" || e === "not_in")
-    return b(t) ? `${e} [$1]` : `${e} ["$1"]`;
+    return T(t) ? `${e} [$1]` : `${e} ["$1"]`;
   if (e === "between" || e === "not_between")
-    return b(t) ? `${e} $1 AND $2` : `${e} "$1" AND "$2"`;
-  if (o.includes(e))
-    return `${e} null`;
+    return T(t) ? `${e} $1 AND $2` : `${e} "$1" AND "$2"`;
   if (i.includes(e))
+    return `${e} null`;
+  if (o.includes(e))
     return e;
   if (e === "cidr" || e === "not_cidr")
     return `${e} "$1"`;
-  if (n.includes(e))
+  if (a.includes(e))
     return `${e} "$1"`;
   if (!t)
     return `${e} `;
@@ -476,15 +524,15 @@ function P(e, t) {
       return `${e} `;
   }
 }
-function b(e) {
+function T(e) {
   return e === "long" || e === "integer" || e === "double" || e === "float" || e === "short" || e === "byte" || e === "half_float" || e === "scaled_float" || e === "unsigned_long";
 }
-function x() {
-  return v.filter((e) => e !== "NOT").map(
-    (e, t) => _(e, t)
+function C() {
+  return L.filter((e) => e !== "NOT").map(
+    (e, t) => N(e, t)
   );
 }
-function _(e, t = 0) {
+function N(e, t = 0) {
   return {
     label: e,
     insertText: e + " ",
@@ -493,18 +541,18 @@ function _(e, t = 0) {
     sortOrder: 30 + t
   };
 }
-function D(e, t) {
-  var i;
-  const n = [];
-  return e && ((i = t == null ? void 0 : t.fieldValues) != null && i[e]) && t.fieldValues[e].forEach((a, r) => {
-    n.push({
-      label: a,
-      insertText: `"${a}"`,
+function H(e, t) {
+  var o;
+  const a = [];
+  return e && ((o = t == null ? void 0 : t.fieldValues) != null && o[e]) && t.fieldValues[e].forEach((n, r) => {
+    a.push({
+      label: n,
+      insertText: `"${n}"`,
       kind: "value",
       detail: `Known value for ${e}`,
       sortOrder: 40 + r
     });
-  }), n.push(
+  }), a.push(
     {
       label: '"text"',
       insertText: '"$1"',
@@ -533,87 +581,87 @@ function D(e, t) {
       detail: "Null value",
       sortOrder: 53
     }
-  ), n;
+  ), a;
 }
-function E(e, t) {
-  return I.filter((i) => !t || i.label.toLowerCase().includes(t.toLowerCase())).map((i, o) => ({
-    label: i.label,
-    insertText: i.insertText,
+function Y(e, t) {
+  return E.filter((o) => !t || o.label.toLowerCase().includes(t.toLowerCase())).map((o, i) => ({
+    label: o.label,
+    insertText: o.insertText,
     kind: "snippet",
-    detail: i.description,
-    documentation: `Insert: ${i.insertText}`,
-    sortOrder: 100 + o
+    detail: o.description,
+    documentation: `Insert: ${o.insertText}`,
+    sortOrder: 100 + i
   }));
 }
-function M(e) {
-  return N.filter((t) => !e || t.toLowerCase().includes(e.toLowerCase())).map(
-    (t, n) => {
-      const i = L[t] || { detail: "Field mutator", documentation: "" };
+function K(e) {
+  return D.filter((t) => !e || t.toLowerCase().includes(e.toLowerCase())).map(
+    (t, a) => {
+      const o = z[t] || { detail: "Field mutator", documentation: "" };
       return {
         label: t,
         insertText: t,
         kind: "mutator",
-        detail: i.detail,
-        documentation: i.documentation,
-        sortOrder: 60 + n
+        detail: o.detail,
+        documentation: o.documentation,
+        sortOrder: 60 + a
       };
     }
   );
 }
-function w(e) {
-  return T.filter(
+function O(e) {
+  return R.filter(
     (t) => !e || t.toLowerCase().includes(e.toLowerCase())
-  ).map((t, n) => ({
+  ).map((t, a) => ({
     label: t,
     insertText: `${t}($1)`,
     kind: "aggregation",
     detail: "Aggregation function",
-    sortOrder: 70 + n
+    sortOrder: 70 + a
   }));
 }
-function U(e) {
-  return O.filter(
+function W(e) {
+  return P.filter(
     (t) => !e || t.toLowerCase().includes(e.toLowerCase())
-  ).map((t, n) => ({
+  ).map((t, a) => ({
     label: t,
     insertText: t,
     kind: "typeHint",
     detail: "Type hint",
-    sortOrder: 80 + n
+    sortOrder: 80 + a
   }));
 }
-function q(e) {
-  return C.filter(
+function Z(e) {
+  return $.filter(
     (t) => !e || t.toLowerCase().includes(e.toLowerCase())
-  ).map((t, n) => ({
+  ).map((t, a) => ({
     label: t,
     insertText: t,
     kind: "visualization",
     detail: "Visualization type",
-    sortOrder: 90 + n
+    sortOrder: 90 + a
   }));
 }
-function G(e, t) {
-  const i = y(e).find(
-    (o) => o.start <= t && o.end >= t && o.type !== "whitespace"
+function ae(e, t) {
+  const o = b(e).find(
+    (i) => i.start <= t && i.end >= t && i.type !== "whitespace"
   );
-  return i ? {
-    word: i.value,
-    start: i.start,
-    end: i.end
+  return o ? {
+    word: o.value,
+    start: o.start,
+    end: o.end
   } : null;
 }
-function V() {
+function ne() {
   return [" ", "(", ".", '"', "'", "|", ":", "="];
 }
-function j(e, t, n) {
-  if (n === " " || n === "(" || n === "." || n === "|" || n === ":" || n === "=") return !0;
-  const i = y(e.substring(0, t)), o = i[i.length - 1];
-  return !!(o && o.type === "field" && o.value.length >= 2);
+function ie(e, t, a) {
+  if (a === " " || a === "(" || a === "." || a === "|" || a === ":" || a === "=") return !0;
+  const o = b(e.substring(0, t)), i = o[o.length - 1];
+  return !!(i && i.type === "field" && i.value.length >= 2);
 }
 export {
-  V as getCompletionTriggerCharacters,
-  B as getCompletions,
-  G as getWordAtPosition,
-  j as shouldTriggerCompletion
+  ne as getCompletionTriggerCharacters,
+  te as getCompletions,
+  ae as getWordAtPosition,
+  ie as shouldTriggerCompletion
 };

package/dist/src/complexityAnalyzer.d.ts

@@ -0,0 +1,55 @@
+import { ComplexityMetrics, ComplexityResult, ComplexityThresholds, ComplexityWarning } from './types';
+
+export declare class ComplexityAnalyzer {
+    private thresholds;
+    constructor(thresholds?: ComplexityThresholds);
+    /**
+     * Analyze a TQL query for complexity
+     */
+    analyze(query: string): ComplexityResult;
+    /**
+     * Recursively analyze an expression and collect metrics
+     */
+    private analyzeExpression;
+    private analyzeBinaryExpression;
+    private analyzeUnaryExpression;
+    private analyzeGroupExpression;
+    private analyzeComparisonExpression;
+    private analyzeValue;
+    /**
+     * Calculate the length of OR chains (consecutive ORs)
+     */
+    private calculateOrChainLength;
+    /**
+     * Calculate the length of AND chains (consecutive ANDs)
+     */
+    private calculateAndChainLength;
+    /**
+     * Generate warnings based on collected metrics
+     */
+    private generateWarnings;
+    /**
+     * Generate optimization suggestions based on warnings
+     */
+    private generateSuggestions;
+    /**
+     * Calculate overall complexity score based on metrics and warnings
+     */
+    private calculateScore;
+}
+/**
+ * Analyze a TQL query for complexity using default thresholds
+ */
+export declare function analyzeComplexity(query: string, thresholds?: ComplexityThresholds): ComplexityResult;
+/**
+ * Quick check if a query is considered high complexity
+ */
+export declare function isHighComplexity(query: string, thresholds?: ComplexityThresholds): boolean;
+/**
+ * Get only warnings for a query (without full analysis)
+ */
+export declare function getComplexityWarnings(query: string, thresholds?: ComplexityThresholds): ComplexityWarning[];
+/**
+ * Get complexity metrics for a query
+ */
+export declare function getComplexityMetrics(query: string): ComplexityMetrics;