@redocly/replay 0.27.0-next.3 → 0.27.0-next.5

package/dist/replay-indexes-CfsvVMi_.js

@@ -0,0 +1,1242 @@
+const s = /* @__PURE__ */ Symbol.for("drizzle:entityKind");
+function u(t, e) {
+  if (!t || typeof t != "object")
+    return !1;
+  if (t instanceof e)
+    return !0;
+  if (!Object.prototype.hasOwnProperty.call(e, s))
+    throw new Error(
+      `Class "${e.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`
+    );
+  let r = Object.getPrototypeOf(t).constructor;
+  if (r)
+    for (; r; ) {
+      if (s in r && r[s] === e[s])
+        return !0;
+      r = Object.getPrototypeOf(r);
+    }
+  return !1;
+}
+const L = /* @__PURE__ */ Symbol.for("drizzle:Name"), $ = /* @__PURE__ */ Symbol.for("drizzle:Schema"), U = /* @__PURE__ */ Symbol.for("drizzle:Columns"), K = /* @__PURE__ */ Symbol.for("drizzle:ExtraConfigColumns"), z = /* @__PURE__ */ Symbol.for("drizzle:OriginalName"), V = /* @__PURE__ */ Symbol.for("drizzle:BaseName"), F = /* @__PURE__ */ Symbol.for("drizzle:IsAlias"), E = /* @__PURE__ */ Symbol.for("drizzle:ExtraConfigBuilder"), k = /* @__PURE__ */ Symbol.for("drizzle:IsDrizzleTable");
+class d {
+  static [s] = "Table";
+  /** @internal */
+  static Symbol = {
+    Name: L,
+    Schema: $,
+    OriginalName: z,
+    Columns: U,
+    ExtraConfigColumns: K,
+    BaseName: V,
+    IsAlias: F,
+    ExtraConfigBuilder: E
+  };
+  /**
+   * @internal
+   * Can be changed if the table is aliased.
+   */
+  [L];
+  /**
+   * @internal
+   * Used to store the original name of the table, before any aliasing.
+   */
+  [z];
+  /** @internal */
+  [$];
+  /** @internal */
+  [U];
+  /** @internal */
+  [K];
+  /**
+   *  @internal
+   * Used to store the table name before the transformation via the `tableCreator` functions.
+   */
+  [V];
+  /** @internal */
+  [F] = !1;
+  /** @internal */
+  [k] = !0;
+  /** @internal */
+  [E] = void 0;
+  constructor(e, r, n) {
+    this[L] = this[z] = e, this[$] = r, this[V] = n;
+  }
+}
+function J(t) {
+  return t[L];
+}
+function Re(t) {
+  return `${t[$] ?? "public"}.${t[L]}`;
+}
+class B {
+  constructor(e, r) {
+    this.table = e, this.config = r, this.name = r.name, this.keyAsName = r.keyAsName, this.notNull = r.notNull, this.default = r.default, this.defaultFn = r.defaultFn, this.onUpdateFn = r.onUpdateFn, this.hasDefault = r.hasDefault, this.primary = r.primaryKey, this.isUnique = r.isUnique, this.uniqueName = r.uniqueName, this.uniqueType = r.uniqueType, this.dataType = r.dataType, this.columnType = r.columnType, this.generated = r.generated, this.generatedIdentity = r.generatedIdentity;
+  }
+  static [s] = "Column";
+  name;
+  keyAsName;
+  primary;
+  notNull;
+  default;
+  defaultFn;
+  onUpdateFn;
+  hasDefault;
+  isUnique;
+  uniqueName;
+  uniqueType;
+  dataType;
+  columnType;
+  enumValues = void 0;
+  generated = void 0;
+  generatedIdentity = void 0;
+  config;
+  mapFromDriverValue(e) {
+    return e;
+  }
+  mapToDriverValue(e) {
+    return e;
+  }
+  // ** @internal */
+  shouldDisableInsert() {
+    return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
+  }
+}
+class ee {
+  static [s] = "ColumnBuilder";
+  config;
+  constructor(e, r, n) {
+    this.config = {
+      name: e,
+      keyAsName: e === "",
+      notNull: !1,
+      default: void 0,
+      hasDefault: !1,
+      primaryKey: !1,
+      isUnique: !1,
+      uniqueName: void 0,
+      uniqueType: void 0,
+      dataType: r,
+      columnType: n,
+      generated: void 0
+    };
+  }
+  /**
+   * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
+   *
+   * @example
+   * ```ts
+   * const users = pgTable('users', {
+   * 	id: integer('id').$type<UserId>().primaryKey(),
+   * 	details: json('details').$type<UserDetails>().notNull(),
+   * });
+   * ```
+   */
+  $type() {
+    return this;
+  }
+  /**
+   * Adds a `not null` clause to the column definition.
+   *
+   * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
+   */
+  notNull() {
+    return this.config.notNull = !0, this;
+  }
+  /**
+   * Adds a `default <value>` clause to the column definition.
+   *
+   * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
+   *
+   * If you need to set a dynamic default value, use {@link $defaultFn} instead.
+   */
+  default(e) {
+    return this.config.default = e, this.config.hasDefault = !0, this;
+  }
+  /**
+   * Adds a dynamic default value to the column.
+   * The function will be called when the row is inserted, and the returned value will be used as the column value.
+   *
+   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+   */
+  $defaultFn(e) {
+    return this.config.defaultFn = e, this.config.hasDefault = !0, this;
+  }
+  /**
+   * Alias for {@link $defaultFn}.
+   */
+  $default = this.$defaultFn;
+  /**
+   * Adds a dynamic update value to the column.
+   * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
+   * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
+   *
+   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+   */
+  $onUpdateFn(e) {
+    return this.config.onUpdateFn = e, this.config.hasDefault = !0, this;
+  }
+  /**
+   * Alias for {@link $onUpdateFn}.
+   */
+  $onUpdate = this.$onUpdateFn;
+  /**
+   * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
+   *
+   * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
+   */
+  primaryKey() {
+    return this.config.primaryKey = !0, this.config.notNull = !0, this;
+  }
+  /** @internal Sets the name of the column to the key within the table definition if a name was not given. */
+  setName(e) {
+    this.config.name === "" && (this.config.name = e);
+  }
+}
+const _ = /* @__PURE__ */ Symbol.for("drizzle:isPgEnum");
+function te(t) {
+  return !!t && typeof t == "function" && _ in t && t[_] === !0;
+}
+class C {
+  static [s] = "Subquery";
+  constructor(e, r, n, a = !1, o = []) {
+    this._ = {
+      brand: "Subquery",
+      sql: e,
+      selectedFields: r,
+      alias: n,
+      isWith: a,
+      usedTables: o
+    };
+  }
+  // getSQL(): SQL<unknown> {
+  // 	return new SQL([this]);
+  // }
+}
+class We extends C {
+  static [s] = "WithSubquery";
+}
+const re = {
+  startActiveSpan(t, e) {
+    return e();
+  }
+}, N = /* @__PURE__ */ Symbol.for("drizzle:ViewBaseConfig");
+function M(t) {
+  return t != null && typeof t.getSQL == "function";
+}
+function ne(t) {
+  const e = { sql: "", params: [] };
+  for (const r of t)
+    e.sql += r.sql, e.params.push(...r.params), r.typings?.length && (e.typings || (e.typings = []), e.typings.push(...r.typings));
+  return e;
+}
+class S {
+  static [s] = "StringChunk";
+  value;
+  constructor(e) {
+    this.value = Array.isArray(e) ? e : [e];
+  }
+  getSQL() {
+    return new m([this]);
+  }
+}
+class m {
+  constructor(e) {
+    this.queryChunks = e;
+    for (const r of e)
+      if (u(r, d)) {
+        const n = r[d.Symbol.Schema];
+        this.usedTables.push(
+          n === void 0 ? r[d.Symbol.Name] : n + "." + r[d.Symbol.Name]
+        );
+      }
+  }
+  static [s] = "SQL";
+  /** @internal */
+  decoder = G;
+  shouldInlineParams = !1;
+  /** @internal */
+  usedTables = [];
+  append(e) {
+    return this.queryChunks.push(...e.queryChunks), this;
+  }
+  toQuery(e) {
+    return re.startActiveSpan("drizzle.buildSQL", (r) => {
+      const n = this.buildQueryFromSourceParams(this.queryChunks, e);
+      return r?.setAttributes({
+        "drizzle.query.text": n.sql,
+        "drizzle.query.params": JSON.stringify(n.params)
+      }), n;
+    });
+  }
+  buildQueryFromSourceParams(e, r) {
+    const n = Object.assign({}, r, {
+      inlineParams: r.inlineParams || this.shouldInlineParams,
+      paramStartIndex: r.paramStartIndex || { value: 0 }
+    }), {
+      casing: a,
+      escapeName: o,
+      escapeParam: g,
+      prepareTyping: f,
+      inlineParams: p,
+      paramStartIndex: h
+    } = n;
+    return ne(e.map((i) => {
+      if (u(i, S))
+        return { sql: i.value.join(""), params: [] };
+      if (u(i, P))
+        return { sql: o(i.value), params: [] };
+      if (i === void 0)
+        return { sql: "", params: [] };
+      if (Array.isArray(i)) {
+        const c = [new S("(")];
+        for (const [y, I] of i.entries())
+          c.push(I), y < i.length - 1 && c.push(new S(", "));
+        return c.push(new S(")")), this.buildQueryFromSourceParams(c, n);
+      }
+      if (u(i, m))
+        return this.buildQueryFromSourceParams(i.queryChunks, {
+          ...n,
+          inlineParams: p || i.shouldInlineParams
+        });
+      if (u(i, d)) {
+        const c = i[d.Symbol.Schema], y = i[d.Symbol.Name];
+        return {
+          sql: c === void 0 || i[F] ? o(y) : o(c) + "." + o(y),
+          params: []
+        };
+      }
+      if (u(i, B)) {
+        const c = a.getColumnCasing(i);
+        if (r.invokeSource === "indexes")
+          return { sql: o(c), params: [] };
+        const y = i.table[d.Symbol.Schema];
+        return {
+          sql: i.table[F] || y === void 0 ? o(i.table[d.Symbol.Name]) + "." + o(c) : o(y) + "." + o(i.table[d.Symbol.Name]) + "." + o(c),
+          params: []
+        };
+      }
+      if (u(i, A)) {
+        const c = i[N].schema, y = i[N].name;
+        return {
+          sql: c === void 0 || i[N].isAlias ? o(y) : o(c) + "." + o(y),
+          params: []
+        };
+      }
+      if (u(i, T)) {
+        if (u(i.value, x))
+          return { sql: g(h.value++, i), params: [i], typings: ["none"] };
+        const c = i.value === null ? null : i.encoder.mapToDriverValue(i.value);
+        if (u(c, m))
+          return this.buildQueryFromSourceParams([c], n);
+        if (p)
+          return { sql: this.mapInlineParam(c, n), params: [] };
+        let y = ["none"];
+        return f && (y = [f(i.encoder)]), { sql: g(h.value++, c), params: [c], typings: y };
+      }
+      return u(i, x) ? { sql: g(h.value++, i), params: [i], typings: ["none"] } : u(i, m.Aliased) && i.fieldAlias !== void 0 ? { sql: o(i.fieldAlias), params: [] } : u(i, C) ? i._.isWith ? { sql: o(i._.alias), params: [] } : this.buildQueryFromSourceParams([
+        new S("("),
+        i._.sql,
+        new S(") "),
+        new P(i._.alias)
+      ], n) : te(i) ? i.schema ? { sql: o(i.schema) + "." + o(i.enumName), params: [] } : { sql: o(i.enumName), params: [] } : M(i) ? i.shouldOmitSQLParens?.() ? this.buildQueryFromSourceParams([i.getSQL()], n) : this.buildQueryFromSourceParams([
+        new S("("),
+        i.getSQL(),
+        new S(")")
+      ], n) : p ? { sql: this.mapInlineParam(i, n), params: [] } : { sql: g(h.value++, i), params: [i], typings: ["none"] };
+    }));
+  }
+  mapInlineParam(e, { escapeString: r }) {
+    if (e === null)
+      return "null";
+    if (typeof e == "number" || typeof e == "boolean")
+      return e.toString();
+    if (typeof e == "string")
+      return r(e);
+    if (typeof e == "object") {
+      const n = e.toString();
+      return r(n === "[object Object]" ? JSON.stringify(e) : n);
+    }
+    throw new Error("Unexpected param value: " + e);
+  }
+  getSQL() {
+    return this;
+  }
+  as(e) {
+    return e === void 0 ? this : new m.Aliased(this, e);
+  }
+  mapWith(e) {
+    return this.decoder = typeof e == "function" ? { mapFromDriverValue: e } : e, this;
+  }
+  inlineParams() {
+    return this.shouldInlineParams = !0, this;
+  }
+  /**
+   * This method is used to conditionally include a part of the query.
+   *
+   * @param condition - Condition to check
+   * @returns itself if the condition is `true`, otherwise `undefined`
+   */
+  if(e) {
+    return e ? this : void 0;
+  }
+}
+class P {
+  constructor(e) {
+    this.value = e;
+  }
+  static [s] = "Name";
+  brand;
+  getSQL() {
+    return new m([this]);
+  }
+}
+function ie(t) {
+  return typeof t == "object" && t !== null && "mapToDriverValue" in t && typeof t.mapToDriverValue == "function";
+}
+const G = {
+  mapFromDriverValue: (t) => t
+}, H = {
+  mapToDriverValue: (t) => t
+};
+({
+  ...G,
+  ...H
+});
+class T {
+  /**
+   * @param value - Parameter value
+   * @param encoder - Encoder to convert the value to a driver parameter
+   */
+  constructor(e, r = H) {
+    this.value = e, this.encoder = r;
+  }
+  static [s] = "Param";
+  brand;
+  getSQL() {
+    return new m([this]);
+  }
+}
+function l(t, ...e) {
+  const r = [];
+  (e.length > 0 || t.length > 0 && t[0] !== "") && r.push(new S(t[0]));
+  for (const [n, a] of e.entries())
+    r.push(a, new S(t[n + 1]));
+  return new m(r);
+}
+((t) => {
+  function e() {
+    return new m([]);
+  }
+  t.empty = e;
+  function r(p) {
+    return new m(p);
+  }
+  t.fromList = r;
+  function n(p) {
+    return new m([new S(p)]);
+  }
+  t.raw = n;
+  function a(p, h) {
+    const i = [];
+    for (const [c, y] of p.entries())
+      c > 0 && h !== void 0 && i.push(h), i.push(y);
+    return new m(i);
+  }
+  t.join = a;
+  function o(p) {
+    return new P(p);
+  }
+  t.identifier = o;
+  function g(p) {
+    return new x(p);
+  }
+  t.placeholder = g;
+  function f(p, h) {
+    return new T(p, h);
+  }
+  t.param = f;
+})(l || (l = {}));
+((t) => {
+  class e {
+    constructor(n, a) {
+      this.sql = n, this.fieldAlias = a;
+    }
+    static [s] = "SQL.Aliased";
+    /** @internal */
+    isSelectionField = !1;
+    getSQL() {
+      return this.sql;
+    }
+    /** @internal */
+    clone() {
+      return new e(this.sql, this.fieldAlias);
+    }
+  }
+  t.Aliased = e;
+})(m || (m = {}));
+class x {
+  constructor(e) {
+    this.name = e;
+  }
+  static [s] = "Placeholder";
+  getSQL() {
+    return new m([this]);
+  }
+}
+function Me(t, e) {
+  return t.map((r) => {
+    if (u(r, x)) {
+      if (!(r.name in e))
+        throw new Error(`No value for placeholder "${r.name}" was provided`);
+      return e[r.name];
+    }
+    if (u(r, T) && u(r.value, x)) {
+      if (!(r.value.name in e))
+        throw new Error(`No value for placeholder "${r.value.name}" was provided`);
+      return r.encoder.mapToDriverValue(e[r.value.name]);
+    }
+    return r;
+  });
+}
+const se = /* @__PURE__ */ Symbol.for("drizzle:IsDrizzleView");
+class A {
+  static [s] = "View";
+  /** @internal */
+  [N];
+  /** @internal */
+  [se] = !0;
+  constructor({ name: e, schema: r, selectedFields: n, query: a }) {
+    this[N] = {
+      name: e,
+      originalName: e,
+      schema: r,
+      selectedFields: n,
+      query: a,
+      isExisting: !a,
+      isAlias: !1
+    };
+  }
+  getSQL() {
+    return new m([this]);
+  }
+}
+B.prototype.getSQL = function() {
+  return new m([this]);
+};
+d.prototype.getSQL = function() {
+  return new m([this]);
+};
+C.prototype.getSQL = function() {
+  return new m([this]);
+};
+function Ge(t, e, r) {
+  const n = {}, a = t.reduce(
+    (o, { path: g, field: f }, p) => {
+      let h;
+      u(f, B) ? h = f : u(f, m) ? h = f.decoder : u(f, C) ? h = f._.sql.decoder : h = f.sql.decoder;
+      let i = o;
+      for (const [c, y] of g.entries())
+        if (c < g.length - 1)
+          y in i || (i[y] = {}), i = i[y];
+        else {
+          const I = e[p], Z = i[y] = I === null ? null : h.mapFromDriverValue(I);
+          if (r && u(f, B) && g.length === 2) {
+            const D = g[0];
+            D in n ? typeof n[D] == "string" && n[D] !== J(f.table) && (n[D] = !1) : n[D] = Z === null ? J(f.table) : !1;
+          }
+        }
+      return o;
+    },
+    {}
+  );
+  if (r && Object.keys(n).length > 0)
+    for (const [o, g] of Object.entries(n))
+      typeof g == "string" && !r[g] && (a[o] = null);
+  return a;
+}
+function R(t, e) {
+  return Object.entries(t).reduce((r, [n, a]) => {
+    if (typeof n != "string")
+      return r;
+    const o = e ? [...e, n] : [n];
+    return u(a, B) || u(a, m) || u(a, m.Aliased) || u(a, C) ? r.push({ path: o, field: a }) : u(a, d) ? r.push(...R(a[d.Symbol.Columns], o)) : r.push(...R(a, o)), r;
+  }, []);
+}
+function He(t, e) {
+  const r = Object.keys(t), n = Object.keys(e);
+  if (r.length !== n.length)
+    return !1;
+  for (const [a, o] of r.entries())
+    if (o !== n[a])
+      return !1;
+  return !0;
+}
+function Xe(t, e) {
+  const r = Object.entries(e).filter(([, n]) => n !== void 0).map(([n, a]) => u(a, m) || u(a, B) ? [n, a] : [n, new T(a, t[d.Symbol.Columns][n])]);
+  if (r.length === 0)
+    throw new Error("No values to set");
+  return Object.fromEntries(r);
+}
+function Ye(t, e) {
+  for (const r of e)
+    for (const n of Object.getOwnPropertyNames(r.prototype))
+      n !== "constructor" && Object.defineProperty(
+        t.prototype,
+        n,
+        Object.getOwnPropertyDescriptor(r.prototype, n) || /* @__PURE__ */ Object.create(null)
+      );
+}
+function Ze(t) {
+  return t[d.Symbol.Columns];
+}
+function ke(t) {
+  return u(t, C) ? t._.alias : u(t, A) ? t[N].name : u(t, m) ? void 0 : t[d.Symbol.IsAlias] ? t[d.Symbol.Name] : t[d.Symbol.BaseName];
+}
+function q(t, e) {
+  return {
+    name: typeof t == "string" && t.length > 0 ? t : "",
+    config: typeof t == "object" ? t : e
+  };
+}
+const X = typeof TextDecoder > "u" ? null : new TextDecoder();
+function b(t, e) {
+  return ie(e) && !M(t) && !u(t, T) && !u(t, x) && !u(t, B) && !u(t, d) && !u(t, A) ? new T(t, e) : t;
+}
+const et = (t, e) => l`${t} = ${b(e, t)}`, tt = (t, e) => l`${t} <> ${b(e, t)}`;
+function rt(...t) {
+  const e = t.filter(
+    (r) => r !== void 0
+  );
+  if (e.length !== 0)
+    return e.length === 1 ? new m(e) : new m([
+      new S("("),
+      l.join(e, new S(" and ")),
+      new S(")")
+    ]);
+}
+function nt(...t) {
+  const e = t.filter(
+    (r) => r !== void 0
+  );
+  if (e.length !== 0)
+    return e.length === 1 ? new m(e) : new m([
+      new S("("),
+      l.join(e, new S(" or ")),
+      new S(")")
+    ]);
+}
+function it(t) {
+  return l`not ${t}`;
+}
+const st = (t, e) => l`${t} > ${b(e, t)}`, ot = (t, e) => l`${t} >= ${b(e, t)}`, at = (t, e) => l`${t} < ${b(e, t)}`, ut = (t, e) => l`${t} <= ${b(e, t)}`;
+function lt(t, e) {
+  return Array.isArray(e) ? e.length === 0 ? l`false` : l`${t} in ${e.map((r) => b(r, t))}` : l`${t} in ${b(e, t)}`;
+}
+function mt(t, e) {
+  return Array.isArray(e) ? e.length === 0 ? l`true` : l`${t} not in ${e.map((r) => b(r, t))}` : l`${t} not in ${b(e, t)}`;
+}
+function ct(t) {
+  return l`${t} is null`;
+}
+function ft(t) {
+  return l`${t} is not null`;
+}
+function dt(t) {
+  return l`exists ${t}`;
+}
+function pt(t) {
+  return l`not exists ${t}`;
+}
+function gt(t, e, r) {
+  return l`${t} between ${b(e, t)} and ${b(
+    r,
+    t
+  )}`;
+}
+function yt(t, e, r) {
+  return l`${t} not between ${b(
+    e,
+    t
+  )} and ${b(r, t)}`;
+}
+function ht(t, e) {
+  return l`${t} like ${e}`;
+}
+function St(t, e) {
+  return l`${t} not like ${e}`;
+}
+function bt(t, e) {
+  return l`${t} ilike ${e}`;
+}
+function wt(t, e) {
+  return l`${t} not ilike ${e}`;
+}
+function Qt(t) {
+  return l`${t} asc`;
+}
+function Lt(t) {
+  return l`${t} desc`;
+}
+class oe {
+  static [s] = "SQLiteForeignKeyBuilder";
+  /** @internal */
+  reference;
+  /** @internal */
+  _onUpdate;
+  /** @internal */
+  _onDelete;
+  constructor(e, r) {
+    this.reference = () => {
+      const { name: n, columns: a, foreignColumns: o } = e();
+      return { name: n, columns: a, foreignTable: o[0].table, foreignColumns: o };
+    }, r && (this._onUpdate = r.onUpdate, this._onDelete = r.onDelete);
+  }
+  onUpdate(e) {
+    return this._onUpdate = e, this;
+  }
+  onDelete(e) {
+    return this._onDelete = e, this;
+  }
+  /** @internal */
+  build(e) {
+    return new ae(e, this);
+  }
+}
+class ae {
+  constructor(e, r) {
+    this.table = e, this.reference = r.reference, this.onUpdate = r._onUpdate, this.onDelete = r._onDelete;
+  }
+  static [s] = "SQLiteForeignKey";
+  reference;
+  onUpdate;
+  onDelete;
+  getName() {
+    const { name: e, columns: r, foreignColumns: n } = this.reference(), a = r.map((f) => f.name), o = n.map((f) => f.name), g = [
+      this.table[L],
+      ...a,
+      n[0].table[L],
+      ...o
+    ];
+    return e ?? `${g.join("_")}_fk`;
+  }
+}
+function ue(t, e) {
+  return `${t[L]}_${e.join("_")}_unique`;
+}
+class w extends ee {
+  static [s] = "SQLiteColumnBuilder";
+  foreignKeyConfigs = [];
+  references(e, r = {}) {
+    return this.foreignKeyConfigs.push({ ref: e, actions: r }), this;
+  }
+  unique(e) {
+    return this.config.isUnique = !0, this.config.uniqueName = e, this;
+  }
+  generatedAlwaysAs(e, r) {
+    return this.config.generated = {
+      as: e,
+      type: "always",
+      mode: r?.mode ?? "virtual"
+    }, this;
+  }
+  /** @internal */
+  buildForeignKeys(e, r) {
+    return this.foreignKeyConfigs.map(({ ref: n, actions: a }) => ((o, g) => {
+      const f = new oe(() => {
+        const p = o();
+        return { columns: [e], foreignColumns: [p] };
+      });
+      return g.onUpdate && f.onUpdate(g.onUpdate), g.onDelete && f.onDelete(g.onDelete), f.build(r);
+    })(n, a));
+  }
+}
+class Q extends B {
+  constructor(e, r) {
+    r.uniqueName || (r.uniqueName = ue(e, [r.name])), super(e, r), this.table = e;
+  }
+  static [s] = "SQLiteColumn";
+}
+class le extends w {
+  static [s] = "SQLiteBigIntBuilder";
+  constructor(e) {
+    super(e, "bigint", "SQLiteBigInt");
+  }
+  /** @internal */
+  build(e) {
+    return new me(e, this.config);
+  }
+}
+class me extends Q {
+  static [s] = "SQLiteBigInt";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(e) {
+    if (typeof Buffer < "u" && Buffer.from) {
+      const r = Buffer.isBuffer(e) ? e : e instanceof ArrayBuffer ? Buffer.from(e) : e.buffer ? Buffer.from(e.buffer, e.byteOffset, e.byteLength) : Buffer.from(e);
+      return BigInt(r.toString("utf8"));
+    }
+    return BigInt(X.decode(e));
+  }
+  mapToDriverValue(e) {
+    return Buffer.from(e.toString());
+  }
+}
+class ce extends w {
+  static [s] = "SQLiteBlobJsonBuilder";
+  constructor(e) {
+    super(e, "json", "SQLiteBlobJson");
+  }
+  /** @internal */
+  build(e) {
+    return new fe(
+      e,
+      this.config
+    );
+  }
+}
+class fe extends Q {
+  static [s] = "SQLiteBlobJson";
+  getSQLType() {
+    return "blob";
+  }
+  mapFromDriverValue(e) {
+    if (typeof Buffer < "u" && Buffer.from) {
+      const r = Buffer.isBuffer(e) ? e : e instanceof ArrayBuffer ? Buffer.from(e) : e.buffer ? Buffer.from(e.buffer, e.byteOffset, e.byteLength) : Buffer.from(e);
+      return JSON.parse(r.toString("utf8"));
+    }
+    return JSON.parse(X.decode(e));
+  }
+  mapToDriverValue(e) {
+    return Buffer.from(JSON.stringify(e));
+  }
+}
+class de extends w {
+  static [s] = "SQLiteBlobBufferBuilder";
+  constructor(e) {
+    super(e, "buffer", "SQLiteBlobBuffer");
+  }
+  /** @internal */
+  build(e) {
+    return new pe(e, this.config);
+  }
+}
+class pe extends Q {
+  static [s] = "SQLiteBlobBuffer";
+  mapFromDriverValue(e) {
+    return Buffer.isBuffer(e) ? e : Buffer.from(e);
+  }
+  getSQLType() {
+    return "blob";
+  }
+}
+function ge(t, e) {
+  const { name: r, config: n } = q(t, e);
+  return n?.mode === "json" ? new ce(r) : n?.mode === "bigint" ? new le(r) : new de(r);
+}
+class ye extends w {
+  static [s] = "SQLiteCustomColumnBuilder";
+  constructor(e, r, n) {
+    super(e, "custom", "SQLiteCustomColumn"), this.config.fieldConfig = r, this.config.customTypeParams = n;
+  }
+  /** @internal */
+  build(e) {
+    return new he(
+      e,
+      this.config
+    );
+  }
+}
+class he extends Q {
+  static [s] = "SQLiteCustomColumn";
+  sqlName;
+  mapTo;
+  mapFrom;
+  constructor(e, r) {
+    super(e, r), this.sqlName = r.customTypeParams.dataType(r.fieldConfig), this.mapTo = r.customTypeParams.toDriver, this.mapFrom = r.customTypeParams.fromDriver;
+  }
+  getSQLType() {
+    return this.sqlName;
+  }
+  mapFromDriverValue(e) {
+    return typeof this.mapFrom == "function" ? this.mapFrom(e) : e;
+  }
+  mapToDriverValue(e) {
+    return typeof this.mapTo == "function" ? this.mapTo(e) : e;
+  }
+}
+function Se(t) {
+  return (e, r) => {
+    const { name: n, config: a } = q(e, r);
+    return new ye(
+      n,
+      a,
+      t
+    );
+  };
+}
+class j extends w {
+  static [s] = "SQLiteBaseIntegerBuilder";
+  constructor(e, r, n) {
+    super(e, r, n), this.config.autoIncrement = !1;
+  }
+  primaryKey(e) {
+    return e?.autoIncrement && (this.config.autoIncrement = !0), this.config.hasDefault = !0, super.primaryKey();
+  }
+}
+class v extends Q {
+  static [s] = "SQLiteBaseInteger";
+  autoIncrement = this.config.autoIncrement;
+  getSQLType() {
+    return "integer";
+  }
+}
+class be extends j {
+  static [s] = "SQLiteIntegerBuilder";
+  constructor(e) {
+    super(e, "number", "SQLiteInteger");
+  }
+  build(e) {
+    return new we(
+      e,
+      this.config
+    );
+  }
+}
+class we extends v {
+  static [s] = "SQLiteInteger";
+}
+class Qe extends j {
+  static [s] = "SQLiteTimestampBuilder";
+  constructor(e, r) {
+    super(e, "date", "SQLiteTimestamp"), this.config.mode = r;
+  }
+  /**
+   * @deprecated Use `default()` with your own expression instead.
+   *
+   * Adds `DEFAULT (cast((julianday('now') - 2440587.5)*86400000 as integer))` to the column, which is the current epoch timestamp in milliseconds.
+   */
+  defaultNow() {
+    return this.default(l`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);
+  }
+  build(e) {
+    return new Le(
+      e,
+      this.config
+    );
+  }
+}
+class Le extends v {
+  static [s] = "SQLiteTimestamp";
+  mode = this.config.mode;
+  mapFromDriverValue(e) {
+    return this.config.mode === "timestamp" ? new Date(e * 1e3) : new Date(e);
+  }
+  mapToDriverValue(e) {
+    const r = e.getTime();
+    return this.config.mode === "timestamp" ? Math.floor(r / 1e3) : r;
+  }
+}
+class Be extends j {
+  static [s] = "SQLiteBooleanBuilder";
+  constructor(e, r) {
+    super(e, "boolean", "SQLiteBoolean"), this.config.mode = r;
+  }
+  build(e) {
+    return new Ne(
+      e,
+      this.config
+    );
+  }
+}
+class Ne extends v {
+  static [s] = "SQLiteBoolean";
+  mode = this.config.mode;
+  mapFromDriverValue(e) {
+    return Number(e) === 1;
+  }
+  mapToDriverValue(e) {
+    return e ? 1 : 0;
+  }
+}
+function Te(t, e) {
+  const { name: r, config: n } = q(t, e);
+  return n?.mode === "timestamp" || n?.mode === "timestamp_ms" ? new Qe(r, n.mode) : n?.mode === "boolean" ? new Be(r, n.mode) : new be(r);
+}
+class xe extends w {
+  static [s] = "SQLiteNumericBuilder";
+  constructor(e) {
+    super(e, "string", "SQLiteNumeric");
+  }
+  /** @internal */
+  build(e) {
+    return new Ce(
+      e,
+      this.config
+    );
+  }
+}
+class Ce extends Q {
+  static [s] = "SQLiteNumeric";
+  mapFromDriverValue(e) {
+    return typeof e == "string" ? e : String(e);
+  }
+  getSQLType() {
+    return "numeric";
+  }
+}
+class De extends w {
+  static [s] = "SQLiteNumericNumberBuilder";
+  constructor(e) {
+    super(e, "number", "SQLiteNumericNumber");
+  }
+  /** @internal */
+  build(e) {
+    return new qe(
+      e,
+      this.config
+    );
+  }
+}
+class qe extends Q {
+  static [s] = "SQLiteNumericNumber";
+  mapFromDriverValue(e) {
+    return typeof e == "number" ? e : Number(e);
+  }
+  mapToDriverValue = String;
+  getSQLType() {
+    return "numeric";
+  }
+}
+class Ie extends w {
+  static [s] = "SQLiteNumericBigIntBuilder";
+  constructor(e) {
+    super(e, "bigint", "SQLiteNumericBigInt");
+  }
+  /** @internal */
+  build(e) {
+    return new $e(
+      e,
+      this.config
+    );
+  }
+}
+class $e extends Q {
+  static [s] = "SQLiteNumericBigInt";
+  mapFromDriverValue = BigInt;
+  mapToDriverValue = String;
+  getSQLType() {
+    return "numeric";
+  }
+}
+function Fe(t, e) {
+  const { name: r, config: n } = q(t, e), a = n?.mode;
+  return a === "number" ? new De(r) : a === "bigint" ? new Ie(r) : new xe(r);
+}
+class ze extends w {
+  static [s] = "SQLiteRealBuilder";
+  constructor(e) {
+    super(e, "number", "SQLiteReal");
+  }
+  /** @internal */
+  build(e) {
+    return new Ve(e, this.config);
+  }
+}
+class Ve extends Q {
+  static [s] = "SQLiteReal";
+  getSQLType() {
+    return "real";
+  }
+}
+function Pe(t) {
+  return new ze(t ?? "");
+}
+class Oe extends w {
+  static [s] = "SQLiteTextBuilder";
+  constructor(e, r) {
+    super(e, "string", "SQLiteText"), this.config.enumValues = r.enum, this.config.length = r.length;
+  }
+  /** @internal */
+  build(e) {
+    return new Ae(
+      e,
+      this.config
+    );
+  }
+}
+class Ae extends Q {
+  static [s] = "SQLiteText";
+  enumValues = this.config.enumValues;
+  length = this.config.length;
+  constructor(e, r) {
+    super(e, r);
+  }
+  getSQLType() {
+    return `text${this.config.length ? `(${this.config.length})` : ""}`;
+  }
+}
+class je extends w {
+  static [s] = "SQLiteTextJsonBuilder";
+  constructor(e) {
+    super(e, "json", "SQLiteTextJson");
+  }
+  /** @internal */
+  build(e) {
+    return new ve(
+      e,
+      this.config
+    );
+  }
+}
+class ve extends Q {
+  static [s] = "SQLiteTextJson";
+  getSQLType() {
+    return "text";
+  }
+  mapFromDriverValue(e) {
+    return JSON.parse(e);
+  }
+  mapToDriverValue(e) {
+    return JSON.stringify(e);
+  }
+}
+function Ue(t, e = {}) {
+  const { name: r, config: n } = q(t, e);
+  return n.mode === "json" ? new je(r) : new Oe(r, n);
+}
+function Ke() {
+  return {
+    blob: ge,
+    customType: Se,
+    integer: Te,
+    numeric: Fe,
+    real: Pe,
+    text: Ue
+  };
+}
+const O = /* @__PURE__ */ Symbol.for("drizzle:SQLiteInlineForeignKeys");
+class W extends d {
+  static [s] = "SQLiteTable";
+  /** @internal */
+  static Symbol = Object.assign({}, d.Symbol, {
+    InlineForeignKeys: O
+  });
+  /** @internal */
+  [d.Symbol.Columns];
+  /** @internal */
+  [O] = [];
+  /** @internal */
+  [d.Symbol.ExtraConfigBuilder] = void 0;
+}
+function Ee(t, e, r, n, a = t) {
+  const o = new W(t, n, a), g = typeof e == "function" ? e(Ke()) : e, f = Object.fromEntries(
+    Object.entries(g).map(([h, i]) => {
+      const c = i;
+      c.setName(h);
+      const y = c.build(o);
+      return o[O].push(...c.buildForeignKeys(y, o)), [h, y];
+    })
+  ), p = Object.assign(o, f);
+  return p[d.Symbol.Columns] = f, p[d.Symbol.ExtraConfigColumns] = f, r && (p[W.Symbol.ExtraConfigBuilder] = r), p;
+}
+const Bt = (t, e, r) => Ee(t, e, r);
+class Y {
+  constructor(e, r) {
+    this.name = e, this.unique = r;
+  }
+  static [s] = "SQLiteIndexBuilderOn";
+  on(...e) {
+    return new Je(this.name, e, this.unique);
+  }
+}
+class Je {
+  static [s] = "SQLiteIndexBuilder";
+  /** @internal */
+  config;
+  constructor(e, r, n) {
+    this.config = {
+      name: e,
+      columns: r,
+      unique: n,
+      where: void 0
+    };
+  }
+  /**
+   * Condition for partial index.
+   */
+  where(e) {
+    return this.config.where = e, this;
+  }
+  /** @internal */
+  build(e) {
+    return new _e(this.config, e);
+  }
+}
+class _e {
+  static [s] = "SQLiteIndex";
+  config;
+  constructor(e, r) {
+    this.config = { ...e, table: r };
+  }
+}
+function Nt(t) {
+  return new Y(t, !1);
+}
+function Tt(t) {
+  return new Y(t, !0);
+}
+export {
+  gt as A,
+  C as B,
+  B as C,
+  A as D,
+  W as E,
+  R as F,
+  J as G,
+  Q as H,
+  Ze as I,
+  ke as J,
+  He as K,
+  Ye as L,
+  U as M,
+  Xe as N,
+  Me as O,
+  T as P,
+  Ge as Q,
+  Bt as R,
+  m as S,
+  d as T,
+  Te as U,
+  N as V,
+  We as W,
+  Ue as X,
+  Nt as Y,
+  Tt as Z,
+  Qt as a,
+  rt as b,
+  s as c,
+  Lt as d,
+  et as e,
+  wt as f,
+  Re as g,
+  St as h,
+  u as i,
+  pt as j,
+  yt as k,
+  it as l,
+  tt as m,
+  mt as n,
+  nt as o,
+  ut as p,
+  at as q,
+  ht as r,
+  l as s,
+  ft as t,
+  ct as u,
+  lt as v,
+  bt as w,
+  ot as x,
+  st as y,
+  dt as z
+};