@magemetrics/core 0.0.59 → 0.0.60

package/dist/index.js

@@ -0,0 +1,2923 @@
+import z5, { z } from 'zod';
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat.js';
+import relativeTime from 'dayjs/plugin/relativeTime.js';
+import timezone from 'dayjs/plugin/timezone.js';
+import utc from 'dayjs/plugin/utc.js';
+import { GoTrueClient } from '@supabase/auth-js';
+import createApiClient from 'openapi-fetch';
+import { sha256 } from '@noble/hashes/sha2';
+
+// ../shared/dist/src/api/client/middleware.js
+var HEADER_CLIENT_VERSION = "X-Client-Version";
+var HEADER_API_KEY = "X-Api-Key";
+var ApiError = class extends Error {
+  extra;
+  response;
+  constructor(message, response, extra) {
+    super(message);
+    this.name = "ApiError";
+    this.response = response;
+    this.extra = extra;
+  }
+};
+var throwOnError = {
+  async onResponse({ response, request }) {
+    if (response.status >= 400) {
+      const body = response.headers.get("content-type")?.includes("json") ? await response.clone().json() : await response.clone().text();
+      throw new ApiError(`[${response.status}] ${request.method} ${request.url}`, response, {
+        body,
+        status: response.status,
+        statusText: response.statusText,
+        url: request.url,
+        method: request.method
+      });
+    }
+    return void 0;
+  }
+};
+var addVersionHeader = (clientVersion) => {
+  return {
+    onRequest({ request }) {
+      request.headers.set(HEADER_CLIENT_VERSION, clientVersion);
+      return request;
+    }
+  };
+};
+var addApiKeyHeader = (apiKey) => {
+  return {
+    onRequest({ request }) {
+      request.headers.set(HEADER_API_KEY, apiKey);
+      return request;
+    }
+  };
+};
+
+// ../../node_modules/.pnpm/@asteasolutions+zod-to-openapi@7.3.2_zod@3.25.76/node_modules/@asteasolutions/zod-to-openapi/dist/index.mjs
+function __rest(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+}
+function isZodType(schema, typeName) {
+  var _a;
+  return ((_a = schema === null || schema === void 0 ? void 0 : schema._def) === null || _a === void 0 ? void 0 : _a.typeName) === typeName;
+}
+function preserveMetadataFromModifier(zod, modifier) {
+  const zodModifier = zod.ZodType.prototype[modifier];
+  zod.ZodType.prototype[modifier] = function(...args) {
+    const result = zodModifier.apply(this, args);
+    result._def.openapi = this._def.openapi;
+    return result;
+  };
+}
+function extendZodWithOpenApi(zod) {
+  if (typeof zod.ZodType.prototype.openapi !== "undefined") {
+    return;
+  }
+  zod.ZodType.prototype.openapi = function(refOrOpenapi, metadata) {
+    var _a, _b, _c, _d, _e, _f;
+    const openapi = typeof refOrOpenapi === "string" ? metadata : refOrOpenapi;
+    const _g = openapi !== null && openapi !== void 0 ? openapi : {}, { param } = _g, restOfOpenApi = __rest(_g, ["param"]);
+    const _internal = Object.assign(Object.assign({}, (_a = this._def.openapi) === null || _a === void 0 ? void 0 : _a._internal), typeof refOrOpenapi === "string" ? { refId: refOrOpenapi } : void 0);
+    const resultMetadata = Object.assign(Object.assign(Object.assign({}, (_b = this._def.openapi) === null || _b === void 0 ? void 0 : _b.metadata), restOfOpenApi), ((_d = (_c = this._def.openapi) === null || _c === void 0 ? void 0 : _c.metadata) === null || _d === void 0 ? void 0 : _d.param) || param ? {
+      param: Object.assign(Object.assign({}, (_f = (_e = this._def.openapi) === null || _e === void 0 ? void 0 : _e.metadata) === null || _f === void 0 ? void 0 : _f.param), param)
+    } : void 0);
+    const result = new this.constructor(Object.assign(Object.assign({}, this._def), { openapi: Object.assign(Object.assign({}, Object.keys(_internal).length > 0 ? { _internal } : void 0), Object.keys(resultMetadata).length > 0 ? { metadata: resultMetadata } : void 0) }));
+    if (isZodType(this, "ZodObject")) {
+      const originalExtend = this.extend;
+      result.extend = function(...args) {
+        var _a2, _b2, _c2, _d2, _e2, _f2;
+        const extendedResult = originalExtend.apply(this, args);
+        extendedResult._def.openapi = {
+          _internal: {
+            extendedFrom: ((_b2 = (_a2 = this._def.openapi) === null || _a2 === void 0 ? void 0 : _a2._internal) === null || _b2 === void 0 ? void 0 : _b2.refId) ? { refId: (_d2 = (_c2 = this._def.openapi) === null || _c2 === void 0 ? void 0 : _c2._internal) === null || _d2 === void 0 ? void 0 : _d2.refId, schema: this } : (_e2 = this._def.openapi) === null || _e2 === void 0 ? void 0 : _e2._internal.extendedFrom
+          },
+          metadata: (_f2 = extendedResult._def.openapi) === null || _f2 === void 0 ? void 0 : _f2.metadata
+        };
+        return extendedResult;
+      };
+    }
+    return result;
+  };
+  preserveMetadataFromModifier(zod, "optional");
+  preserveMetadataFromModifier(zod, "nullable");
+  preserveMetadataFromModifier(zod, "default");
+  preserveMetadataFromModifier(zod, "transform");
+  preserveMetadataFromModifier(zod, "refine");
+  const zodDeepPartial = zod.ZodObject.prototype.deepPartial;
+  zod.ZodObject.prototype.deepPartial = function() {
+    const initialShape = this._def.shape();
+    const result = zodDeepPartial.apply(this);
+    const resultShape = result._def.shape();
+    Object.entries(resultShape).forEach(([key, value]) => {
+      var _a, _b;
+      value._def.openapi = (_b = (_a = initialShape[key]) === null || _a === void 0 ? void 0 : _a._def) === null || _b === void 0 ? void 0 : _b.openapi;
+    });
+    result._def.openapi = void 0;
+    return result;
+  };
+  const zodPick = zod.ZodObject.prototype.pick;
+  zod.ZodObject.prototype.pick = function(...args) {
+    const result = zodPick.apply(this, args);
+    result._def.openapi = void 0;
+    return result;
+  };
+  const zodOmit = zod.ZodObject.prototype.omit;
+  zod.ZodObject.prototype.omit = function(...args) {
+    const result = zodOmit.apply(this, args);
+    result._def.openapi = void 0;
+    return result;
+  };
+}
+new Set(".\\+*[^]$()");
+var createRoute = (routeConfig) => {
+  const route = {
+    ...routeConfig,
+    getRoutingPath() {
+      return routeConfig.path.replaceAll(/\/{(.+?)}/g, "/:$1");
+    }
+  };
+  return Object.defineProperty(route, "getRoutingPath", { enumerable: false });
+};
+extendZodWithOpenApi(z);
+
+// ../shared/dist/src/endpoints/admin-console/sqlPreview.routes.js
+var TanStackColumnSchema = z.object({
+  id: z.string(),
+  accessorKey: z.string(),
+  header: z.string(),
+  cell: z.any().optional(),
+  meta: z.record(z.any()).optional()
+});
+var SqlPreviewResponseSchema = z.object({
+  columns: z.array(TanStackColumnSchema),
+  data: z.array(z.record(z.any())),
+  metadata: z.object({
+    wasSampled: z.boolean(),
+    originalCount: z.number(),
+    sampledCount: z.number()
+  }).optional()
+});
+var SqlPreviewErrorSchema = z.object({
+  error: z.string()
+});
+createRoute({
+  method: "post",
+  path: "/api/v1/admin-console/sql/preview",
+  operationId: "sqlPreview",
+  request: {
+    body: {
+      content: {
+        "application/json": {
+          schema: z.object({
+            sql: z.string().min(1, "SQL query is required")
+          })
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "SQL query executed successfully",
+      content: {
+        "application/json": {
+          schema: SqlPreviewResponseSchema
+        }
+      }
+    },
+    400: {
+      description: "Invalid SQL query or request",
+      content: {
+        "application/json": {
+          schema: SqlPreviewErrorSchema
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: SqlPreviewErrorSchema
+        }
+      }
+    }
+  }
+});
+
+// ../shared/dist/src/endpoints/utils.js
+var limitQueryParams = z.string().pipe(z.coerce.number()).optional().openapi({
+  param: {
+    required: false
+  },
+  type: "integer"
+});
+var orderQueryParams = z.string().transform((str) => {
+  if (!str)
+    return [];
+  return str.split(",").map((part) => {
+    const [column, direction = "ASC"] = part.split(":");
+    return {
+      column,
+      direction: direction.toUpperCase()
+    };
+  });
+}).pipe(z.array(z.object({
+  column: z.string(),
+  direction: z.enum(["ASC", "DESC"])
+}))).optional().openapi({
+  param: {
+    required: false,
+    example: "name:asc,date:desc"
+  },
+  type: "string"
+});
+var cursorParams = z.string().pipe(z.coerce.number()).optional().openapi({
+  param: {
+    required: false
+  },
+  type: "number"
+});
+var filterQueryParams = z.string().transform((str) => {
+  if (!str)
+    return [];
+  return str.split(",").map((part) => {
+    const [column, value = ""] = part.split(":").map(decodeURIComponent);
+    return { column, value };
+  });
+}).pipe(z.array(z.object({
+  column: z.string(),
+  value: z.string()
+}))).optional().openapi({
+  param: {
+    required: false,
+    example: "status:active,name:John%20Doe"
+  },
+  type: "string"
+});
+var columnsQueryParams = z.string().transform((str) => {
+  if (!str)
+    return [];
+  return str.split(",");
+}).optional().openapi({
+  param: {
+    required: false,
+    example: "name,date"
+  },
+  type: "string"
+});
+var SupabaseUserHeaderSchema = z.object({
+  "sp-access-token": z.string()
+});
+var SupabaseHeaderSchema = SupabaseUserHeaderSchema;
+var FEEDBACK_OPTIONS = [
+  { label: "Helpful", value: "helpful" },
+  { label: "Partially helpful", value: "partially helpful" },
+  { label: "Not helpful", value: "not helpful" },
+  { label: "Incorrect", value: "incorrect" }
+];
+var FeedbackSchema = z.object({
+  created_at: z.string(),
+  flow_data_id: z.number(),
+  helpfulness: z.enum(FEEDBACK_OPTIONS.map((option) => option.value)),
+  id: z.number()
+});
+var Node3 = z.object({
+  id: z.string(),
+  type: z.enum([
+    "entity",
+    "attribute",
+    "filter",
+    "process",
+    "combine",
+    "result"
+  ]),
+  explanation: z.string()
+});
+var Edge = z.object({
+  source: z.string(),
+  target: z.string()
+});
+z.object({
+  score: z.number(),
+  reason: z.string()
+});
+var LLMColumnsLineageResponse = z.record(z.string(), z.object({
+  nodes: z.array(Node3),
+  edges: z.array(Edge)
+}));
+var SqlAnalysisChunkSchema = z.object({
+  chunk_title: z.string(),
+  chunk_explanation: z.string(),
+  lines: z.array(z.object({
+    sql: z.string(),
+    explanation: z.string()
+  }))
+});
+var BusinessExplanationSchema = z.object({
+  summary: z.string(),
+  implementation: z.array(z.string()),
+  assumptions: z.array(z.object({
+    type: z.enum([
+      "grain",
+      "completeness",
+      "transformation",
+      "relationship",
+      "other"
+    ]),
+    details: z.string(),
+    explanation: z.string()
+  }))
+});
+
+// ../shared/dist/src/schemas/flows.js
+var FlowStepSchema = z.object({
+  name: z.string(),
+  status: z.enum(["running", "completed", "failed", "awaiting_input"]),
+  output: z.object({}).passthrough().or(z.unknown().array()).nullable()
+});
+var DatabaseFlowSchema = z.object({
+  created_at: z.string(),
+  id: z.string(),
+  request: z.string(),
+  user_id: z.string().nullable(),
+  flow_steps: z.array(FlowStepSchema),
+  flow_chat_messages: z.array(z.object({ count: z.number() }))
+});
+z.object({
+  table: z.string(),
+  schema: z.string(),
+  database: z.string()
+});
+var FrontendFlowSchema = DatabaseFlowSchema.omit({
+  flow_chat_messages: true,
+  flow_steps: true
+}).extend({
+  user_friendly_goal: z.string().optional(),
+  has_chat_messages: z.boolean()
+});
+var FrontendRecentFlowsSchema = DatabaseFlowSchema.omit({
+  flow_steps: true,
+  flow_chat_messages: true
+});
+var ReportColumnSchema = z.object({
+  position: z.number().nonnegative().optional(),
+  data_type: z.string(),
+  null_count: z.number().nullable(),
+  unique_count: z.number().nullable(),
+  unique_percentage: z.number().nullable()
+}).passthrough();
+var ReportSchema = z.object({
+  created_at: z.string(),
+  flow_id: z.string(),
+  id: z.number(),
+  is_sample: z.boolean(),
+  schema: z.string(),
+  sql: z.string(),
+  table: z.string(),
+  title: z.string(),
+  request: z.string().nullable(),
+  data_sample: z.array(z.record(z.unknown())),
+  data_summary: z.object({
+    columns: z.record(z.string(), ReportColumnSchema)
+  }).passthrough(),
+  bookmarked: z.boolean(),
+  status: z.string().nullable()
+});
+var FrontendReportSchema = ReportSchema.omit({
+  sql: true,
+  table: true,
+  data_sample: true,
+  is_sample: true,
+  schema: true
+});
+var ReportDataSchema = z.object({}).passthrough().array().openapi("ReportData");
+var ReportColumnsSchema = z.object({
+  name: z.string(),
+  data_type: z.string()
+}).array();
+z.object({
+  render_type: z.string().nullish(),
+  unit: z.string().nullish()
+});
+var FrontendReportColumnsSchema = ReportColumnsSchema.element.merge(z.object({
+  dataType: z.string(),
+  renderType: z.string().optional(),
+  unit: z.string().optional()
+})).array().openapi("ReportColumns");
+z.object({
+  goal: z.string(),
+  user_friendly_goal: z.string().optional()
+});
+var ReportExplainabilitySchema = z.object({
+  sql_explanation: z.array(SqlAnalysisChunkSchema).nullish(),
+  business_explanation: BusinessExplanationSchema.nullish(),
+  columns_lineage: LLMColumnsLineageResponse.nullish(),
+  confidence_score: z.number(),
+  confidence_score_reason: z.string(),
+  assumptions_score: z.number().optional(),
+  assumptions_score_reason: z.string().optional(),
+  friendliness_score: z.number().optional(),
+  friendliness_score_reason: z.string().optional(),
+  id: z.number(),
+  flow_data_id: z.number(),
+  created_at: z.string()
+});
+var FrontendReportExplainabilitySchema = ReportExplainabilitySchema.omit({
+  id: true,
+  created_at: true
+});
+dayjs.extend(relativeTime);
+dayjs.extend(customParseFormat);
+dayjs.extend(utc);
+dayjs.extend(timezone);
+var daysjs_default = dayjs;
+
+// ../shared/dist/src/data/FormattedData.js
+var formatWithAutoPrecision = (value, options = {}) => {
+  const { minPrecision = 0, maxPrecision = 6, trimZeros = true, useGrouping = true } = options;
+  if (typeof value !== "number" || isNaN(value)) {
+    return String(value);
+  }
+  if (value === 0) {
+    return "0";
+  }
+  const absValue = Math.abs(value);
+  let maximumFractionDigits;
+  if (absValue >= 1e3) {
+    maximumFractionDigits = 0;
+  } else if (absValue >= 100) {
+    maximumFractionDigits = 1;
+  } else if (absValue >= 10) {
+    maximumFractionDigits = 2;
+  } else if (absValue >= 1) {
+    maximumFractionDigits = 3;
+  } else if (absValue >= 0.1) {
+    maximumFractionDigits = 4;
+  } else if (absValue >= 0.01) {
+    maximumFractionDigits = 5;
+  } else {
+    maximumFractionDigits = maxPrecision;
+    if (absValue > 0) {
+      const exponent = Math.floor(Math.log10(absValue));
+      if (exponent < 0) {
+        maximumFractionDigits = Math.min(Math.abs(exponent) + 2, maxPrecision);
+      }
+    }
+  }
+  maximumFractionDigits = Math.max(maximumFractionDigits, minPrecision);
+  const formatter = new Intl.NumberFormat(void 0, {
+    minimumFractionDigits: trimZeros ? 0 : maximumFractionDigits,
+    maximumFractionDigits,
+    useGrouping
+  });
+  return formatter.format(value);
+};
+var MIN_VALID_YEAR = 1900;
+var MAX_VALID_YEAR = 2200;
+var zonedatetime = (format, zone) => ({ format, type: "zonedatetime", zone });
+var datetime = (format) => ({ format, type: "datetime" });
+var date = (format) => ({ format, type: "date" });
+var DATE_FORMATS = [
+  // ISO 8601 formats
+  zonedatetime("YYYY-MM-DDTHH:mm:ss.SSSZ", "UTC"),
+  zonedatetime("YYYY-MM-DDTHH:mm:ssZ", "UTC"),
+  zonedatetime("YYYY-MM-DDTHH:mmZ", "UTC"),
+  datetime("YYYY-MM-DDTHH:mm:ss"),
+  datetime("YYYY-MM-DDTHH:mm"),
+  date("YYYY-MM-DDT"),
+  // Standard date formats
+  date("YYYY-MM-DD"),
+  date("YYYY/MM/DD"),
+  date("DD-MM-YYYY"),
+  date("DD/MM/YYYY"),
+  date("MM-DD-YYYY"),
+  date("MM/DD/YYYY"),
+  // Date time formats
+  datetime("YYYY-MM-DD HH:mm:ss"),
+  datetime("YYYY-MM-DD HH:mm"),
+  datetime("YYYY/MM/DD HH:mm:ss"),
+  datetime("YYYY/MM/DD HH:mm"),
+  datetime("DD-MM-YYYY HH:mm:ss"),
+  datetime("DD-MM-YYYY HH:mm"),
+  datetime("DD/MM/YYYY HH:mm:ss"),
+  datetime("DD/MM/YYYY HH:mm"),
+  datetime("MM-DD-YYYY HH:mm:ss"),
+  datetime("MM-DD-YYYY HH:mm"),
+  datetime("MM/DD/YYYY HH:mm:ss"),
+  datetime("MM/DD/YYYY HH:mm")
+];
+var isDateString = (value) => {
+  if (typeof value !== "string")
+    return { isValid: false };
+  const stripped = value.replace(/[-/.:\s]/g, "");
+  if (/^\d+$/.test(stripped)) {
+    if (stripped.length < 6)
+      return { isValid: false };
+    if (value.length === stripped.length)
+      return { isValid: false };
+  }
+  if (stripped.length > "YYYY-MM-DDTHH:mm:ss.SSS+00:00".length) {
+    return { isValid: false };
+  }
+  for (const format of DATE_FORMATS) {
+    let date2;
+    try {
+      if (format.type === "zonedatetime") {
+        date2 = daysjs_default.tz(value, format.format, format.zone);
+      } else {
+        date2 = daysjs_default(value, format.format, true);
+      }
+    } catch {
+      continue;
+    }
+    if (date2.isValid()) {
+      const year = date2.year();
+      if (year < MIN_VALID_YEAR || year > MAX_VALID_YEAR)
+        continue;
+      const isDateTime = format.type === "zonedatetime" || format.type == "datetime";
+      return {
+        isValid: true,
+        parsedDate: date2,
+        isDateTime
+      };
+    }
+  }
+  return { isValid: false };
+};
+var formatDataValue = (value, { replaceNullValue } = {
+  replaceNullValue: true
+}) => {
+  if (value === null || value === void 0) {
+    return {
+      display: replaceNullValue ? "empty" : null,
+      sortValue: null
+    };
+  }
+  let processedValue = value;
+  if (typeof processedValue === "string") {
+    try {
+      const parsed = JSON.parse(processedValue);
+      processedValue = parsed;
+    } catch {
+    }
+  }
+  if (processedValue && typeof processedValue === "object" && Object.keys(processedValue).length === 1 && "value" in processedValue) {
+    const extractedValue = processedValue.value;
+    const dateResult2 = isDateString(extractedValue);
+    if (dateResult2.isValid) {
+      return {
+        display: dateResult2.isDateTime ? dateResult2.parsedDate.format("YYYY-MM-DD HH:mm:ss") : dateResult2.parsedDate.format("YYYY-MM-DD"),
+        sortValue: dateResult2.parsedDate.valueOf()
+      };
+    }
+    return {
+      display: String(extractedValue),
+      sortValue: extractedValue
+    };
+  }
+  const dateResult = isDateString(processedValue);
+  if (dateResult.isValid) {
+    return {
+      display: dateResult.isDateTime ? dateResult.parsedDate.format("YYYY-MM-DD HH:mm:ss") : dateResult.parsedDate.format("YYYY-MM-DD"),
+      sortValue: dateResult.parsedDate.valueOf()
+    };
+  }
+  if (typeof processedValue === "object") {
+    const stringified = JSON.stringify(processedValue, null, 2);
+    return {
+      display: stringified,
+      sortValue: stringified
+    };
+  }
+  if (typeof processedValue === "boolean") {
+    return {
+      display: String(processedValue),
+      sortValue: processedValue ? 1 : 0
+    };
+  }
+  if (typeof processedValue === "number") {
+    return {
+      display: processedValue >= MIN_VALID_YEAR && processedValue <= MAX_VALID_YEAR && Number.isInteger(processedValue) ? String(processedValue) : formatWithAutoPrecision(processedValue),
+      sortValue: processedValue
+    };
+  }
+  return {
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string
+    display: String(processedValue),
+    sortValue: processedValue
+  };
+};
+
+// ../shared/dist/src/schemas/visualizations.js
+var commonConfigProperties = {
+  title: z.string()
+};
+var cartesianConfigProperties = {
+  xAxisLabel: z.string(),
+  yAxisLabel: z.string(),
+  xAxisDataKey: z.string().optional(),
+  yAxisDataKey: z.string().optional(),
+  dimensionDataKey: z.string().optional(),
+  valueColumns: z.array(z.string()).optional()
+};
+var V1VisualizationConfigurationSchema = z.discriminatedUnion("type", [
+  // Bar chart
+  z.object({
+    type: z.literal("bar"),
+    ...commonConfigProperties,
+    ...cartesianConfigProperties
+  }),
+  // Line/Area chart
+  z.object({
+    type: z.literal("line/area"),
+    ...commonConfigProperties,
+    ...cartesianConfigProperties
+  }),
+  // Scatter chart
+  z.object({
+    type: z.literal("scatter"),
+    ...commonConfigProperties,
+    ...cartesianConfigProperties
+  }),
+  // Pie chart
+  z.object({
+    type: z.literal("pie"),
+    ...commonConfigProperties,
+    nameKey: z.string(),
+    dataKey: z.string()
+  })
+]);
+var VisualizationConfigurationSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("bar"),
+    ...commonConfigProperties,
+    config_version: z.literal(2),
+    xAxisLabel: z.string(),
+    yAxisLabel: z.string(),
+    categoryColumn: z.string(),
+    secondaryCategoryColumn: z.string().optional(),
+    valueColumn: z.string()
+  }),
+  // Line/Area chart - version 2: New format
+  z.object({
+    type: z.literal("line/area"),
+    config_version: z.literal(2),
+    ...commonConfigProperties,
+    xAxisColumn: z.string(),
+    valueColumns: z.array(z.string()),
+    yAxisLabels: z.array(z.string())
+  }),
+  // Line/Area chart - categorical format (requires pivoting)
+  z.object({
+    type: z.literal("line/area-categorical"),
+    ...commonConfigProperties,
+    config_version: z.literal(2),
+    valueColumn: z.string(),
+    xAxisColumn: z.string(),
+    xAxisLabel: z.string(),
+    yAxisLabel: z.string(),
+    categoryColumn: z.string()
+  }),
+  // Scatter chart - new format (v2)
+  z.object({
+    type: z.literal("scatter"),
+    ...commonConfigProperties,
+    config_version: z.literal(2),
+    xAxisLabel: z.string(),
+    yAxisLabel: z.string(),
+    xAxisValueColumn: z.string(),
+    yAxisValueColumn: z.string()
+  }),
+  // Pie chart - new format (v2)
+  z.object({
+    type: z.literal("pie"),
+    ...commonConfigProperties,
+    config_version: z.literal(2),
+    categoryColumn: z.string(),
+    valueColumn: z.string()
+  })
+]);
+var BaseVisualizationSchema = z.object({
+  id: z.number(),
+  flow_data_id: z.number(),
+  created_at: z.string(),
+  sql: z.string(),
+  bookmarked: z.boolean(),
+  data_sample: z.array(z.record(z.unknown())),
+  is_sample: z.boolean(),
+  data_summary: z.record(z.unknown())
+});
+var V1VisualizationSchema = BaseVisualizationSchema.merge(z.object({
+  configuration: V1VisualizationConfigurationSchema
+}));
+var VisualizationSchema = BaseVisualizationSchema.merge(z.object({
+  configuration: VisualizationConfigurationSchema
+}));
+var VisualizationDataSchema = z.array(z.record(
+  z.string(),
+  // any key
+  z.union([
+    // Date objects FIRST
+    z.date(),
+    z.coerce.number(),
+    // Handle various data types including BigQueryDate
+    z.unknown().transform((val) => formatDataValue(val).display)
+  ])
+)).openapi("VisualizationData");
+var V1FrontendVisualizationSchema = V1VisualizationSchema.omit({
+  sql: true,
+  data_sample: true,
+  is_sample: true,
+  data_summary: true
+});
+var FrontendVisualizationSchema = VisualizationSchema.omit({
+  sql: true,
+  data_sample: true,
+  is_sample: true,
+  data_summary: true
+});
+var VisualizationMetadataSchema = z.object({
+  wasSampled: z.boolean(),
+  originalCount: z.number(),
+  sampledCount: z.number()
+}).optional();
+V1FrontendVisualizationSchema.extend({
+  data: VisualizationDataSchema,
+  _metadata: VisualizationMetadataSchema
+});
+FrontendVisualizationSchema.extend({
+  data: VisualizationDataSchema,
+  _metadata: VisualizationMetadataSchema
+});
+
+// ../shared/dist/src/endpoints/companion/flows.routes.js
+var FlowIdParam = z.object({ flowId: z.string().uuid() }).openapi("FlowId", { type: "string" });
+var FlowDataIdParam = z.object({ flowDataId: z.string().pipe(z.coerce.number()) }).openapi("FlowDataId", { type: "integer" });
+var ReportId = z.string().pipe(z.coerce.number());
+var ReportIdParam = z.object({ report_id: ReportId }).openapi("ReportId", { type: "integer" });
+createRoute({
+  method: "get",
+  path: "/api/v1/flows/{flowId}/data-reports",
+  operationId: "retrieveFlowDataReports",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowIdParam
+  },
+  responses: {
+    200: {
+      description: "The data reports associated with the flow",
+      content: {
+        "application/json": {
+          schema: FrontendReportSchema.array()
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve flow with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "get",
+  path: "/api/v1/flows/{flowId}/data-reports/last/status",
+  operationId: "retrieveLatestDataReportStatus",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowIdParam
+  },
+  responses: {
+    200: {
+      description: "The status of the latest flow data for a given flow",
+      content: {
+        "application/json": {
+          schema: z.object({ status: z.string().nullable() })
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve status for latest flow data of flow with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  // this endpoint is deprecated and will be removed in the future
+  hide: true,
+  method: "get",
+  path: "/api/v1/flows/{flowId}/insights",
+  operationId: "retrieveInsights",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowIdParam,
+    query: z.object({
+      flowDataId: z.string().pipe(z.coerce.number()).optional().openapi({
+        param: {
+          required: false
+        },
+        type: "integer"
+      })
+    })
+  },
+  responses: {
+    200: {
+      description: "The content of the flow",
+      content: {
+        "application/json": {
+          schema: z.object({
+            dataReports: FrontendReportSchema.array(),
+            visualizations: V1FrontendVisualizationSchema.array()
+          })
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve flow with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  // this endpoint is deprecated and will be removed in the future
+  hide: true,
+  method: "get",
+  path: "/api/v1/flows/{flowId}/columns",
+  operationId: "retrieveFlowColumns",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowIdParam,
+    query: FlowDataIdParam
+  },
+  responses: {
+    200: {
+      description: "A list containing the columns of the flow",
+      content: {
+        "application/json": {
+          schema: FrontendReportColumnsSchema
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve flow with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "get",
+  path: "/api/v1/flows/{flowId}",
+  operationId: "retrieveFlow",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowIdParam
+  },
+  responses: {
+    200: {
+      description: "The flow with its steps",
+      content: {
+        "application/json": {
+          schema: FrontendFlowSchema
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve flow with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+var RetrieveRecentFlows = createRoute({
+  method: "get",
+  path: "/api/v1/recent-flows",
+  operationId: "retrieveRecentFlows",
+  request: {
+    headers: SupabaseHeaderSchema,
+    query: z.object({
+      limit: limitQueryParams
+    })
+  },
+  responses: {
+    200: {
+      description: "A list of recent flows",
+      content: {
+        "application/json": {
+          schema: FrontendRecentFlowsSchema.array()
+        }
+      }
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "get",
+  path: "/api/v1/data-reports/{report_id}/columns",
+  operationId: "getDataReportColumns",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: ReportIdParam
+  },
+  responses: {
+    200: {
+      description: "A list containing the columns of the report",
+      content: {
+        "application/json": {
+          schema: FrontendReportColumnsSchema
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve report with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+var ExportReportData = createRoute({
+  method: "get",
+  path: "/api/v1/data-reports/{report_id}/export",
+  operationId: "exportReportData",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: ReportIdParam
+  },
+  responses: {
+    200: {
+      description: "The report data exported in CSV format",
+      content: {
+        "text/csv": {
+          schema: z.string().describe("CSV formatted string of report data")
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve flow with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  // this endpoint is deprecated and will be removed in the future
+  hide: true,
+  method: "get",
+  path: "/api/v1/flows/{flowId}/data",
+  operationId: "retrieveFlowData",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowIdParam,
+    query: z.object({
+      limit: limitQueryParams,
+      order: orderQueryParams,
+      cursor: cursorParams,
+      filter: filterQueryParams,
+      flowDataId: FlowDataIdParam.shape.flowDataId.openapi({
+        type: "integer",
+        param: { required: true }
+      })
+    })
+  },
+  responses: {
+    200: {
+      description: "The content of the flow",
+      content: {
+        "application/json": {
+          schema: ReportDataSchema
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve flow with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "get",
+  path: "/api/v1/data-reports/{report_id}/data",
+  operationId: "getDataReportData",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: ReportIdParam,
+    query: z.object({
+      columns: columnsQueryParams,
+      limit: limitQueryParams,
+      order: orderQueryParams,
+      cursor: cursorParams,
+      filter: filterQueryParams
+    })
+  },
+  responses: {
+    200: {
+      description: "The content of the report",
+      content: {
+        "application/json": {
+          schema: ReportDataSchema
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve report with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  // this endpoint is deprecated and will be removed in the future
+  hide: true,
+  method: "get",
+  path: "/api/v1/flows/{flowId}/count",
+  operationId: "retrieveFlowDataCount",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowIdParam,
+    query: z.object({
+      flowDataId: z.string().pipe(z.coerce.number()).openapi({
+        param: {
+          required: false
+        },
+        type: "integer"
+      })
+    })
+  },
+  responses: {
+    200: {
+      description: "The total count of rows in the flow",
+      content: {
+        "application/json": {
+          schema: z.object({
+            count: z.number().int().nonnegative().describe("Total number of rows in the flow")
+          })
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve flow with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "get",
+  path: "/api/v1/data-reports/{report_id}/count",
+  operationId: "getDataReportRowCount",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: ReportIdParam
+  },
+  responses: {
+    200: {
+      description: "The total count of rows in the report",
+      content: {
+        "application/json": {
+          schema: z.object({
+            count: z.number().int().nonnegative().describe("Total number of rows in the report")
+          })
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve report with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  // this endpoint is deprecated and will be removed in the future
+  hide: true,
+  method: "get",
+  path: "/api/v1/flow-data/{flowDataId}/feedback",
+  operationId: "retrieveFeedback",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowDataIdParam
+  },
+  responses: {
+    200: {
+      description: "The feedback for the flow data",
+      content: {
+        "application/json": {
+          schema: FeedbackSchema.nullable()
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve feedback"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "get",
+  path: "/api/v1/data-reports/{report_id}/feedback",
+  operationId: "getDataReportFeedback",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: ReportIdParam
+  },
+  responses: {
+    200: {
+      description: "The feedback for the report",
+      content: {
+        "application/json": {
+          schema: FeedbackSchema.nullable()
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve feedback"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  // this endpoint is deprecated and will be removed in the future
+  hide: true,
+  method: "post",
+  path: "/api/v1/flow-data/{flowDataId}/feedback",
+  operationId: "upsertFeedback",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowDataIdParam,
+    body: {
+      description: "The feedback for the flow data",
+      required: true,
+      content: {
+        "application/json": {
+          schema: z.object({
+            helpfulness: FeedbackSchema.shape.helpfulness
+          })
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "Successfully upserted feedback"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "post",
+  path: "/api/v1/data-reports/{report_id}/feedback",
+  operationId: "upsertReportFeedback",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: ReportIdParam,
+    body: {
+      description: "The feedback for the flow data",
+      required: true,
+      content: {
+        "application/json": {
+          schema: z.object({
+            helpfulness: FeedbackSchema.shape.helpfulness
+          })
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "Successfully upserted feedback"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  // this endpoint is deprecated and will be removed in the future
+  hide: true,
+  method: "delete",
+  path: "/api/v1/flow-data/{flowDataId}/feedback",
+  operationId: "deleteFeedback",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowDataIdParam
+  },
+  responses: {
+    200: {
+      description: "Successfully deleted feedback"
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve feedback"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "delete",
+  path: "/api/v1/data-reports/{report_id}/feedback",
+  operationId: "deleteReportFeedback",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: ReportIdParam
+  },
+  responses: {
+    200: {
+      description: "Successfully deleted feedback"
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve feedback"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  // this endpoint is deprecated and will be removed in the future
+  hide: true,
+  method: "get",
+  path: "/api/v1/flow-data/{flowDataId}/explainability",
+  operationId: "retrieveFlowDataExplainability",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: FlowDataIdParam
+  },
+  responses: {
+    200: {
+      description: "The explainability of the flow data",
+      content: {
+        "application/json": {
+          schema: FrontendReportExplainabilitySchema
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve flow with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "get",
+  path: "/api/v1/data-reports/{report_id}/explainability",
+  operationId: "getDataReportExplainability",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: ReportIdParam
+  },
+  responses: {
+    200: {
+      description: "The explainability of the report",
+      content: {
+        "application/json": {
+          schema: FrontendReportExplainabilitySchema
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve report with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "get",
+  path: "/api/v1/data-reports/{report_id}",
+  operationId: "getDataReport",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: ReportIdParam
+  },
+  responses: {
+    200: {
+      description: "The visualizations for the report",
+      content: {
+        "application/json": {
+          schema: FrontendReportSchema
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve report with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  hide: true,
+  method: "get",
+  path: "/api/v1/data-reports/{report_id}/visualizations",
+  operationId: "getDataReportVisualizations",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: ReportIdParam
+  },
+  responses: {
+    200: {
+      description: "The visualizations for the report",
+      content: {
+        "application/json": {
+          schema: FrontendReportSchema.merge(z.object({
+            visualizations: z.union([
+              V1FrontendVisualizationSchema,
+              FrontendVisualizationSchema
+            ]).array()
+          }))
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve report with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+var CreateFlow = createRoute({
+  method: "post",
+  path: "/api/v1/flows",
+  operationId: "createFlow",
+  request: {
+    headers: SupabaseHeaderSchema,
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: z.object({
+            userQuery: z.string()
+          })
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "Create a new flow",
+      content: {
+        "application/json": {
+          schema: z.object({
+            status: z.literal("success"),
+            flowId: z.string()
+          })
+        }
+      }
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+
+// ../shared/dist/src/endpoints/admin-console/contextualInsights.routes.js
+var ExtractInsightResponseSchema = z.object({
+  type: z.literal("text"),
+  insight: z.string()
+}).or(z.object({
+  type: z.literal("missing")
+}));
+createRoute({
+  method: "post",
+  path: "/api/v1/admin-console/contextual-insights/generate-template",
+  operationId: "generateInsightTemplate",
+  request: {
+    body: {
+      content: {
+        "application/json": {
+          schema: z.object({
+            request: z.string(),
+            insight_type: z.string(),
+            additional_context: z.string().optional()
+          })
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "Insight template generated successfully",
+      content: {
+        "application/json": {
+          schema: z.object({
+            expanded_request: z.string()
+          })
+        }
+      }
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "get",
+  path: "/api/v1/admin-console/contextual-insights/preview/{report_id}/data",
+  operationId: "getContextualInsightPreviewData",
+  request: {
+    params: ReportIdParam,
+    query: z.object({
+      limit: limitQueryParams,
+      order: orderQueryParams,
+      cursor: cursorParams,
+      filter: filterQueryParams
+    })
+  },
+  responses: {
+    200: {
+      description: "The preview data for the contextual insight",
+      content: {
+        "application/json": {
+          schema: SqlPreviewResponseSchema
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve flow data with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "get",
+  path: "/api/v1/admin-console/contextual-insights/preview/{report_id}/sample-values",
+  operationId: "getContextualInsightColumnSampleValues",
+  request: {
+    params: ReportIdParam,
+    query: z.object({
+      column_name: z.string().openapi({
+        param: {
+          required: true
+        },
+        type: "string",
+        description: "The column name to get sample values for"
+      })
+    })
+  },
+  responses: {
+    200: {
+      description: "Sample values for the specified column",
+      content: {
+        "application/json": {
+          schema: z.object({
+            options: z.array(z.unknown())
+          })
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve flow data with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+var GenerateInsight = createRoute({
+  method: "post",
+  path: "/api/v1/contextual-insights/generate-insight",
+  operationId: "generateInsight",
+  request: {
+    body: {
+      content: {
+        "application/json": {
+          schema: z.object({
+            selected_filter_value: z.string(),
+            custom_id: z.string()
+          })
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "Insight generated successfully",
+      content: {
+        "application/json": {
+          schema: ExtractInsightResponseSchema
+        }
+      }
+    },
+    404: {
+      description: "Insight not found",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    },
+    400: {
+      description: "Invalid request",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "post",
+  path: "/api/v1/admin-console/contextual-insights/extract-insight",
+  operationId: "extractInsight",
+  request: {
+    body: {
+      content: {
+        "application/json": {
+          schema: z.object({
+            flow_id: z.string(),
+            report_id: z.number(),
+            topic: z.string(),
+            expanded_request: z.string(),
+            insight_type: z.string(),
+            selected_filter: z.string(),
+            selected_filter_value: z.string(),
+            additional_context: z.string().optional()
+          })
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "Insight extracted successfully",
+      content: {
+        "application/json": {
+          schema: ExtractInsightResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "post",
+  path: "/api/v1/admin-console/contextual-insights/suggest-filter-column",
+  operationId: "suggestFilterColumn",
+  request: {
+    body: {
+      content: {
+        "application/json": {
+          schema: z.object({
+            report_id: z.number(),
+            request: z.string(),
+            insight_type: z.string(),
+            additional_context: z.string().optional()
+          })
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "Filter column suggestion generated successfully",
+      content: {
+        "application/json": {
+          schema: z.object({
+            recommended_column: z.string(),
+            reasoning: z.string()
+          })
+        }
+      }
+    },
+    404: {
+      description: "Report not found",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+
+// ../shared/dist/src/endpoints/auth.routes.js
+var GetApiInformationInputSchema = z.object({
+  apiKey: z.string()
+});
+var GetApiInformationOutputSchema = z.object({
+  apiUrl: z.string(),
+  anonKey: z.string()
+});
+var GetApiInformation = createRoute({
+  method: "get",
+  path: "/api/v1/auth/apiInformation",
+  operationId: "getApiInformation",
+  request: {
+    query: GetApiInformationInputSchema
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: GetApiInformationOutputSchema
+        }
+      },
+      description: "Retrieve the API URL and anon key"
+    },
+    400: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Invalid input"
+    },
+    500: {
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      },
+      description: "Unable to retrieve the API URL and anon key"
+    }
+  }
+});
+createRoute({
+  hide: true,
+  method: "get",
+  path: "/api/auth/apiInformation",
+  operationId: "getApiInformation",
+  request: {
+    query: GetApiInformationInputSchema
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: GetApiInformationOutputSchema
+        }
+      },
+      description: "Retrieve the API URL and anon key"
+    },
+    400: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Invalid input"
+    },
+    500: {
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      },
+      description: "Unable to retrieve the API URL and anon key"
+    }
+  }
+});
+var ExchangeExternalTokenInputSchema = z.object({
+  apiKey: z.string(),
+  externalJWT: z.string()
+});
+var ExchangeExternalTokenOutputSchema = z.object({
+  accessToken: z.string(),
+  refreshToken: z.string()
+});
+var ExchangeExternalToken = createRoute({
+  method: "post",
+  path: "/api/v1/auth/exchangeExternalToken",
+  operationId: "exchangeExternalToken",
+  request: {
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: ExchangeExternalTokenInputSchema
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: ExchangeExternalTokenOutputSchema
+        }
+      },
+      description: "Retrieve a JWT for an external user"
+    },
+    400: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Invalid input"
+    },
+    500: {
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      },
+      description: "Unable to retrieve a JWT for an external user"
+    }
+  }
+});
+
+// ../shared/dist/src/schemas/dashboard.js
+var DashboardTileSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("data-report"),
+    flowId: z.string(),
+    flowDataId: z.number(),
+    title: z.string(),
+    col: z.number(),
+    colSpan: z.number(),
+    rowSpan: z.number()
+  }),
+  z.object({
+    type: z.literal("visualization"),
+    visualizationId: z.number(),
+    title: z.string(),
+    col: z.number(),
+    colSpan: z.number(),
+    rowSpan: z.number()
+  })
+]);
+var DashboardSchema = z.object({
+  company_id: z.number(),
+  created_at: z.string(),
+  description: z.string().nullable(),
+  id: z.string().uuid(),
+  name: z.string(),
+  positions: z.array(DashboardTileSchema),
+  updated_at: z.string(),
+  is_removed: z.boolean(),
+  is_public: z.boolean()
+});
+var DashboardIdParam = DashboardSchema.shape.id.openapi("DashboardId", {
+  type: "string",
+  format: "uuid"
+});
+var FrontendDashboardSchema = DashboardSchema.omit({
+  company_id: true,
+  created_at: true,
+  updated_at: true,
+  is_removed: true
+});
+
+// ../shared/dist/src/endpoints/companion/dashboards.routes.js
+var RetrieveDashboard = createRoute({
+  method: "get",
+  path: "/api/v1/dashboard/{dashboard_id}",
+  operationId: "retrieveDashboard",
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: z.object({
+      dashboard_id: DashboardIdParam
+    })
+  },
+  responses: {
+    200: {
+      description: "The dashboard with the given id",
+      content: {
+        "application/json": {
+          schema: FrontendDashboardSchema
+        }
+      }
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to retrieve dashboard with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z.object({
+            error: z.string()
+          })
+        }
+      }
+    }
+  }
+});
+
+// ../shared/dist/src/endpoints/end2end/run.routes.js
+var End2EndApiResponseSchema = z.discriminatedUnion("status", [
+  z.object({
+    status: z.literal("error"),
+    error: z.string()
+  }),
+  z.object({
+    status: z.literal("success"),
+    flowId: z.string()
+  })
+]);
+var RunEnd2EndFlowRoute = createRoute({
+  method: "post",
+  path: "/api/v1/end2end",
+  operationId: "runEnd2EndFlow",
+  request: {
+    headers: SupabaseHeaderSchema,
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: z.object({
+            userQuery: z.string(),
+            isNewAnalysisGoal: z.boolean().default(true),
+            difficultyLevel: z.enum(["simple", "moderate", "complex"]).default("complex")
+          })
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "Run the end2end flow",
+      content: {
+        "application/json": {
+          schema: End2EndApiResponseSchema
+        }
+      }
+    }
+  }
+});
+
+// ../shared/dist/src/endpoints/companion/triggers.routes.js
+var TriggerFlowBody = z5.object({
+  triggerId: z5.string(),
+  variables: z5.record(z5.string(), z5.string())
+});
+var TriggerFlow = createRoute({
+  method: "post",
+  path: "/api/v1/trigger-flow/",
+  operationId: "triggerFlow",
+  request: {
+    headers: SupabaseHeaderSchema,
+    body: {
+      required: true,
+      description: "Trigger flow request body",
+      content: {
+        "application/json": {
+          schema: TriggerFlowBody
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "Flow id",
+      content: {
+        "application/json": {
+          schema: End2EndApiResponseSchema
+        }
+      }
+    },
+    400: {
+      content: {
+        "application/json": {
+          schema: z5.object({ error: z5.string() })
+        }
+      },
+      description: "Invalid template or variable values"
+    },
+    404: {
+      content: {
+        "application/json": {
+          schema: z5.object({ error: z5.string() })
+        }
+      },
+      description: "Unable to retrieve trigger with this id"
+    },
+    500: {
+      description: "Something wrong happened",
+      content: {
+        "application/json": {
+          schema: z5.object({
+            error: z5.string()
+          })
+        }
+      }
+    }
+  }
+});
+
+// src/utils/platform.ts
+var isBrowser = () => {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+};
+var isNode = () => {
+  return typeof process !== "undefined" && typeof process.versions === "object" && "node" in process.versions;
+};
+var isReactNative = () => {
+  return typeof navigator !== "undefined" && navigator.product === "ReactNative";
+};
+var getPlatform = () => {
+  if (isReactNative()) return "react-native";
+  if (isBrowser()) return "browser";
+  if (isNode()) return "node";
+  return "unknown";
+};
+
+// src/adapters/storage/browser.ts
+var BrowserStorageAdapter = class {
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async getItem(key) {
+    try {
+      return localStorage.getItem(key);
+    } catch (error) {
+      console.warn(
+        "BrowserStorageAdapter: Failed to get item from localStorage",
+        error
+      );
+      return null;
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async setItem(key, value) {
+    try {
+      localStorage.setItem(key, value);
+    } catch (error) {
+      console.warn(
+        "BrowserStorageAdapter: Failed to set item in localStorage",
+        error
+      );
+      throw error;
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async removeItem(key) {
+    try {
+      localStorage.removeItem(key);
+    } catch (error) {
+      console.warn(
+        "BrowserStorageAdapter: Failed to remove item from localStorage",
+        error
+      );
+      throw error;
+    }
+  }
+};
+
+// src/adapters/storage/memory.ts
+var MemoryStorageAdapter = class {
+  storage = /* @__PURE__ */ new Map();
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async getItem(key) {
+    const value = this.storage.get(key);
+    return value !== void 0 ? value : null;
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async setItem(key, value) {
+    this.storage.set(key, value);
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async removeItem(key) {
+    this.storage.delete(key);
+  }
+};
+
+// src/adapters/storage/factory.ts
+var createStorageAdapter = () => {
+  const platform = getPlatform();
+  switch (platform) {
+    case "browser":
+      return new BrowserStorageAdapter();
+    case "node":
+      return new MemoryStorageAdapter();
+    case "react-native":
+      throw new Error("Please provide AsyncStorage for React Native");
+    case "unknown":
+    default:
+      console.warn(
+        `Unknown platform detected: ${platform}. Defaulting to in memory storage.`
+      );
+      return new MemoryStorageAdapter();
+  }
+};
+var hashString = (value) => {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const hash = sha256(data);
+  return Array.from(hash).map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+
+// package.json
+var package_default = {
+  version: "0.0.60"};
+
+// src/core/MageMetricsEventEmitter.ts
+var MageMetricsEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  addEventListener(type, listener, options) {
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, /* @__PURE__ */ new Set());
+    }
+    if (options?.signal) {
+      if (options.signal.aborted) {
+        return;
+      }
+      const abortHandler = () => {
+        this.removeEventListener(type, listener);
+      };
+      options.signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    this.listeners.get(type).add(listener);
+  }
+  removeEventListener(type, listener) {
+    const typeListeners = this.listeners.get(type);
+    if (typeListeners) {
+      typeListeners.delete(listener);
+      if (typeListeners.size === 0) {
+        this.listeners.delete(type);
+      }
+    }
+  }
+  dispatch(type, detail) {
+    const typeListeners = this.listeners.get(type);
+    if (typeListeners) {
+      const event = { type, detail };
+      typeListeners.forEach((listener) => {
+        try {
+          listener(event);
+        } catch (error) {
+          console.error(`Error in event listener for "${type}":`, error);
+        }
+      });
+    }
+  }
+};
+
+// src/core/types.ts
+var TOKEN_STORAGE_KEY = "mm-ai-sp-token";
+var CHECK_KEY = "mm-ai-check-key";
+
+// src/core/MageMetricsClient.ts
+var MM_CLIENT_VERSION = package_default.version;
+var getPublicApiClient = (apiUrl, apiKey) => {
+  const client = createApiClient({ baseUrl: apiUrl });
+  client.use(throwOnError);
+  client.use(addVersionHeader(MM_CLIENT_VERSION));
+  client.use(addApiKeyHeader(apiKey));
+  return client;
+};
+var MageMetricsClient = class {
+  config;
+  authState = "initializing";
+  supabaseClient = null;
+  internalApiClient = null;
+  noAuthApiClient = null;
+  authApiResponse = null;
+  authPromise = null;
+  processedJwt = Symbol("initial");
+  storageAdapter;
+  events = new MageMetricsEventEmitter();
+  constructor(config) {
+    this.config = config;
+    this.storageAdapter = config.storageAdapter || createStorageAdapter();
+    void this.initializeAuth();
+  }
+  /**
+   * Add an event listener for authentication state changes
+   * @param type the type of the event
+   * @param listener the listener to add
+   * @param options options for the event listener
+   * @param options.signal an optional AbortSignal to abort the event listener
+   */
+  addEventListener(type, listener, options) {
+    this.events.addEventListener(type, listener, options);
+  }
+  /**
+   * Remove an event listener
+   * @param type the type of the event
+   * @param listener the listener to remove
+   */
+  removeEventListener(type, listener) {
+    this.events.removeEventListener(type, listener);
+  }
+  async waitForAuth() {
+    if (this.authState === "ready") {
+      return Promise.resolve();
+    }
+    if (this.authState === "error") {
+      throw new Error("Authentication failed");
+    }
+    if (this.authPromise) {
+      return this.authPromise;
+    }
+    throw new Error("Authentication not initialized");
+  }
+  async updateExternalJwt(jwt) {
+    if (this.config.externalJwt === jwt) return;
+    this.config.externalJwt = jwt;
+    this.processedJwt = Symbol("updating");
+    await this.performAuthFlow();
+  }
+  get state() {
+    return this.authState;
+  }
+  async getAuthHeaders() {
+    await this.waitForAuth();
+    if (!this.supabaseClient) {
+      return {};
+    }
+    const session = await this.supabaseClient.getSession();
+    if (!session.data.session) {
+      return {};
+    }
+    const { access_token } = session.data.session;
+    const headers = {};
+    if (access_token) {
+      headers["sp-access-token"] = access_token;
+    }
+    return headers;
+  }
+  async clearStorage() {
+    try {
+      await this.storageAdapter.removeItem(TOKEN_STORAGE_KEY);
+      await this.storageAdapter.removeItem(CHECK_KEY);
+    } catch {
+    }
+  }
+  async logout() {
+    if (this.supabaseClient) {
+      await this.supabaseClient.signOut({ scope: "local" });
+    }
+    await this.clearStorage();
+  }
+  /**
+   * Public API methods that automatically wait for authentication
+   */
+  api = {
+    getRecentFlows: async (params = {}) => {
+      await this.waitForAuth();
+      if (!this.internalApiClient) throw new Error("API client not ready");
+      const { data, error, response } = await this.internalApiClient.GET(
+        RetrieveRecentFlows.path,
+        {
+          params: {
+            query: {
+              limit: params.limit ?? 10
+            }
+          }
+        }
+      );
+      if (error) {
+        throw new ApiError(error.error, response, {
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url,
+          method: "GET"
+        });
+      }
+      return data;
+    },
+    /**
+     * @deprecated Use `createFlow` instead.
+     * @param request the user request
+     * @returns the id of the created flow
+     */
+    startFlow: async (request) => {
+      await this.waitForAuth();
+      if (!this.internalApiClient) throw new Error("API client not ready");
+      if ("query" in request) {
+        const { data, response } = await this.internalApiClient.POST(
+          RunEnd2EndFlowRoute.path,
+          {
+            body: {
+              userQuery: request.query,
+              isNewAnalysisGoal: true,
+              difficultyLevel: "complex"
+            }
+          }
+        );
+        if (!data || data.status === "error") {
+          throw new ApiError(data?.error ?? "Failed to start flow", response, {
+            status: response.status,
+            statusText: response.statusText,
+            url: response.url,
+            method: "POST"
+          });
+        }
+        return data.flowId;
+      } else {
+        const { triggerId, variables } = request;
+        const { data, response } = await this.internalApiClient.POST(
+          TriggerFlow.path,
+          {
+            body: {
+              triggerId,
+              variables
+            }
+          }
+        );
+        if (!data || data.status === "error") {
+          throw new ApiError(
+            data?.error ?? "Failed to trigger flow",
+            response,
+            {
+              status: response.status,
+              statusText: response.statusText,
+              url: response.url,
+              method: "POST"
+            }
+          );
+        }
+        return data.flowId;
+      }
+    },
+    createFlow: async (request) => {
+      await this.waitForAuth();
+      if (!this.internalApiClient) throw new Error("API client not ready");
+      if ("query" in request) {
+        const { data, error, response } = await this.internalApiClient.POST(
+          CreateFlow.path,
+          {
+            body: {
+              userQuery: request.query
+            }
+          }
+        );
+        if (error) {
+          throw new ApiError(error.error, response, {
+            status: response.status,
+            statusText: response.statusText,
+            url: response.url,
+            method: "POST"
+          });
+        }
+        return { flowId: data.flowId };
+      } else {
+        const { triggerId, variables } = request;
+        const { data, response } = await this.internalApiClient.POST(
+          TriggerFlow.path,
+          {
+            body: {
+              triggerId,
+              variables
+            }
+          }
+        );
+        if (!data || data.status === "error") {
+          throw new ApiError(
+            data?.error ?? "Failed to trigger flow",
+            response,
+            {
+              status: response.status,
+              statusText: response.statusText,
+              url: response.url,
+              method: "POST"
+            }
+          );
+        }
+        return { flowId: data.flowId };
+      }
+    },
+    getDashboard: async (dashboardId) => {
+      await this.waitForAuth();
+      if (!this.internalApiClient) throw new Error("API client not ready");
+      const { data, error, response } = await this.internalApiClient.GET(
+        RetrieveDashboard.path,
+        {
+          params: {
+            path: {
+              dashboard_id: dashboardId
+            }
+          }
+        }
+      );
+      if (error) {
+        throw new ApiError(error.error, response, {
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url,
+          method: "GET"
+        });
+      }
+      return data;
+    },
+    exportReportData: async (reportId, format = "blob") => {
+      await this.waitForAuth();
+      if (!this.internalApiClient) throw new Error("API client not ready");
+      const { data, error, response } = await this.internalApiClient.GET(
+        ExportReportData.path,
+        {
+          params: {
+            path: {
+              report_id: String(reportId)
+            }
+          },
+          parseAs: format
+        }
+      );
+      if (error) {
+        throw new ApiError(error.error, response, {
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url,
+          method: "GET"
+        });
+      }
+      const contentDisposition = response.headers.get("content-disposition");
+      const filename = contentDisposition ? contentDisposition.split("filename=")[1]?.replace(/"/g, "") || `mm-export-${reportId}.csv` : `mm-export-${reportId}.csv`;
+      return { filename, data };
+    },
+    generateContextualInsight: async (payload) => {
+      await this.waitForAuth();
+      if (!this.internalApiClient) throw new Error("API client not ready");
+      const { data, error, response } = await this.internalApiClient.POST(
+        GenerateInsight.path,
+        {
+          body: {
+            selected_filter_value: payload.selectedFilterValue,
+            custom_id: payload.customId
+          }
+        }
+      );
+      if (error) {
+        throw new ApiError(error.error, response, {
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url,
+          method: "POST"
+        });
+      }
+      return data;
+    }
+  };
+  /**
+   * Initialize authentication flow
+   */
+  async initializeAuth() {
+    this.authPromise = this.performAuthFlow();
+    try {
+      await this.authPromise;
+    } catch (error) {
+      console.error("Failed to initialize authentication:", error);
+    }
+  }
+  /**
+   * Perform the complete authentication flow
+   */
+  async performAuthFlow() {
+    try {
+      this.setState("initializing");
+      const apiInfo = await this.getApiInformation();
+      this.initializeSupabaseClient(apiInfo.anonKey, apiInfo.apiUrl);
+      this.initializeApiClient();
+      await this.handleAuthentication();
+      if (this.config.externalJwt) {
+        await this.saveCheckKey(this.config.externalJwt, this.config.apiKey);
+      }
+      this.setState("ready");
+    } catch (error) {
+      console.error("Authentication flow failed:", error);
+      this.setState("error");
+      throw error;
+    }
+  }
+  async getApiInformation() {
+    if (!this.noAuthApiClient || !this.authApiResponse) {
+      this.noAuthApiClient = getPublicApiClient(
+        this.config.apiUrl,
+        this.config.apiKey
+      );
+      const { data } = await this.noAuthApiClient.GET(GetApiInformation.path, {
+        params: {
+          query: {
+            apiKey: this.config.apiKey
+          }
+        }
+      });
+      if (!data) {
+        throw new Error("Failed to fetch API information");
+      }
+      this.authApiResponse = data;
+    }
+    return this.authApiResponse;
+  }
+  initializeSupabaseClient(anonKey, apiUrl) {
+    if (!this.supabaseClient) {
+      this.supabaseClient = new GoTrueClient({
+        url: `${apiUrl}/auth/v1`,
+        storageKey: TOKEN_STORAGE_KEY,
+        headers: {
+          apiKey: anonKey
+        }
+      });
+      this.supabaseClient.onAuthStateChange((event, session) => {
+        console.debug("Supabase auth state change:", event, !!session);
+        if (event === "TOKEN_REFRESHED" && session) {
+          console.debug("Token refreshed successfully");
+          this.setState("ready");
+        } else if (event === "SIGNED_OUT") {
+          console.debug("User signed out");
+          void this.clearStorage();
+          this.setState("initializing");
+        }
+      });
+    }
+  }
+  /* This method always waits for authentication to complete before returning the client */
+  async client() {
+    await this.waitForAuth();
+    if (this.authState === "ready") {
+      if (!this.internalApiClient) {
+        throw new Error(
+          "Client is ready but API client not available. This should never happen"
+        );
+      }
+      return this.internalApiClient;
+    }
+    throw new Error(`Client is not available in auth state: ${this.authState}`);
+  }
+  /**
+   * Initialize the API client with Supabase headers
+   */
+  initializeApiClient() {
+    this.internalApiClient = createApiClient({ baseUrl: this.config.apiUrl });
+    this.internalApiClient.use(throwOnError);
+    this.internalApiClient.use(this.createSupabaseHeaderMiddleware());
+    this.internalApiClient.use(addVersionHeader(MM_CLIENT_VERSION));
+  }
+  /**
+   * Handle the authentication logic (check session or exchange token)
+   */
+  async handleAuthentication() {
+    if (!this.supabaseClient) {
+      throw new Error("Supabase client not initialized");
+    }
+    if (this.processedJwt === this.config.externalJwt) {
+      return;
+    }
+    try {
+      const { data, error } = await this.supabaseClient.getSession();
+      if (error) {
+        console.error("Error getting session:", error);
+        this.processedJwt = this.config.externalJwt || "";
+        return;
+      }
+      const isCheckValid = await this.compareCheckKey(
+        this.config.externalJwt ?? "",
+        this.config.apiKey
+      );
+      if (data.session && this.config.externalJwt && isCheckValid) {
+        console.debug("Session found, authentication ready");
+        this.processedJwt = this.config.externalJwt || "";
+      } else if (this.config.externalJwt) {
+        console.debug("No session found, exchanging external JWT");
+        await this.clearCheckKey();
+        await this.exchangeExternalToken();
+        this.processedJwt = this.config.externalJwt;
+      } else {
+        console.debug("No session and no external JWT provided");
+        this.processedJwt = this.config.externalJwt || "";
+      }
+    } catch (error) {
+      console.error("Unhandled error during authentication:", error);
+      this.processedJwt = this.config.externalJwt || "";
+      throw error;
+    }
+  }
+  /**
+   * Exchange external JWT for Supabase tokens
+   */
+  async exchangeExternalToken() {
+    if (!this.noAuthApiClient || !this.supabaseClient || !this.config.externalJwt) {
+      throw new Error(
+        "Required clients or JWT not available for token exchange"
+      );
+    }
+    const { data } = await this.noAuthApiClient.POST(
+      ExchangeExternalToken.path,
+      {
+        body: {
+          apiKey: this.config.apiKey,
+          externalJWT: this.config.externalJwt
+        },
+        headers: this.config.additionalHeaders || {}
+      }
+    );
+    if (!data) {
+      throw new Error("Failed to exchange tokens");
+    }
+    await this.supabaseClient.setSession({
+      access_token: data.accessToken,
+      refresh_token: data.refreshToken
+    });
+    console.debug("Token exchange successful, session set");
+  }
+  createSupabaseHeaderMiddleware() {
+    const supabaseClient = this.supabaseClient;
+    return {
+      async onRequest({ request }) {
+        if (!supabaseClient) {
+          return request;
+        }
+        const session = await supabaseClient.getSession();
+        if (!session.data.session) {
+          return request;
+        }
+        const { access_token } = session.data.session;
+        if (access_token) {
+          request.headers.set("sp-access-token", access_token);
+        }
+        return request;
+      }
+    };
+  }
+  setState(state) {
+    this.authState = state;
+    this.events.dispatch("authStateChange", state);
+  }
+  encodeCheckKey(externalJwt, apiKey) {
+    return hashString(
+      JSON.stringify({
+        externalJwt,
+        apiKey
+      })
+    );
+  }
+  async saveCheckKey(externalJwt, apiKey) {
+    const encodedKey = this.encodeCheckKey(externalJwt, apiKey);
+    await this.storageAdapter.setItem(CHECK_KEY, encodedKey);
+  }
+  async compareCheckKey(externalJwt, apiKey) {
+    const storedKey = await this.storageAdapter.getItem(CHECK_KEY);
+    if (!storedKey) return false;
+    const newValue = this.encodeCheckKey(externalJwt, apiKey);
+    return storedKey === newValue;
+  }
+  async clearCheckKey() {
+    await this.storageAdapter.removeItem(CHECK_KEY);
+  }
+};
+
+export { BrowserStorageAdapter, CHECK_KEY, MageMetricsClient, MageMetricsEventEmitter, MemoryStorageAdapter, TOKEN_STORAGE_KEY, getPublicApiClient };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map