kernelcms 0.1.0

package/dist/sqlite.js

@@ -0,0 +1,393 @@
+// ../db-sqlite/src/index.ts
+import { createRequire } from "module";
+var nodeRequire = createRequire(import.meta.url);
+var { DatabaseSync } = nodeRequire("node:sqlite");
+var SQL_TYPE = {
+  text: "TEXT",
+  integer: "INTEGER",
+  real: "REAL",
+  boolean: "INTEGER",
+  timestamp: "TEXT",
+  json: "TEXT"
+};
+function quote(ident) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(ident)) {
+    throw new Error(`Invalid SQL identifier: ${ident}`);
+  }
+  return `"${ident}"`;
+}
+function resolveLocation(url) {
+  if (!url) return ":memory:";
+  if (url === ":memory:") return url;
+  if (url.startsWith("file:")) return url.slice("file:".length);
+  return url;
+}
+var SQLiteAdapter = class {
+  kind = "db";
+  name = "sqlite";
+  contractVersion = "1.0";
+  capabilities = {
+    transactions: true,
+    joins: "application",
+    jsonQuery: false,
+    fullTextSearch: false,
+    returning: false
+  };
+  db = null;
+  logger = null;
+  options;
+  tables = /* @__PURE__ */ new Map();
+  allowedCols = /* @__PURE__ */ new Map();
+  // Serializes transactions. There is one shared synchronous connection, so two
+  // overlapping `BEGIN…COMMIT` blocks would interleave their statements at the
+  // `await` points inside the callback and corrupt each other. Chaining every
+  // transaction onto this tail guarantees at most one is open at a time.
+  txTail = Promise.resolve();
+  constructor(options) {
+    this.options = options;
+  }
+  async init(ctx) {
+    this.logger = ctx.logger;
+    const location = resolveLocation(this.options.url);
+    this.db = new DatabaseSync(location);
+    this.db.exec(`PRAGMA busy_timeout = ${Number(this.options.busyTimeout ?? 5e3)};`);
+    if (location !== ":memory:" && (this.options.wal ?? true)) {
+      this.db.exec("PRAGMA journal_mode = WAL;");
+    }
+    this.logger.info(`sqlite connected (${location})`);
+  }
+  conn() {
+    if (!this.db) throw new Error("SQLite adapter not initialized. Did you call initKernel()?");
+    return this.db;
+  }
+  table(name) {
+    const t = this.tables.get(name);
+    if (!t) throw new Error(`Unknown table "${name}". Run migrations first.`);
+    return t;
+  }
+  async migrate(schema) {
+    const db = this.conn();
+    const report = { createdTables: [], addedColumns: [], statements: [] };
+    for (const table of schema.tables) {
+      this.tables.set(table.table, table);
+      const allowed = /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt"]);
+      for (const c of table.columns) allowed.add(c.name);
+      this.allowedCols.set(table.table, allowed);
+      const existing = db.prepare(`PRAGMA table_info(${quote(table.table)})`).all();
+      if (existing.length === 0) {
+        const sql = this.createTableSql(table);
+        db.exec(sql);
+        report.createdTables.push(table.table);
+        report.statements.push(sql);
+      } else {
+        const have = new Set(existing.map((c) => c.name));
+        for (const col of table.columns) {
+          if (!have.has(col.name)) {
+            const sql = `ALTER TABLE ${quote(table.table)} ADD COLUMN ${this.columnSql(col)};`;
+            db.exec(sql);
+            report.addedColumns.push(`${table.table}.${col.name}`);
+            report.statements.push(sql);
+          }
+        }
+      }
+      for (const col of table.columns) {
+        if (col.indexed && !col.unique) {
+          const idx = `idx_${table.table}_${col.name}`;
+          const sql = `CREATE INDEX IF NOT EXISTS ${quote(idx)} ON ${quote(table.table)} (${quote(col.name)});`;
+          db.exec(sql);
+        }
+      }
+    }
+    this.logger?.info(
+      `migrated: ${report.createdTables.length} table(s) created, ${report.addedColumns.length} column(s) added`
+    );
+    return report;
+  }
+  columnSql(col) {
+    const parts = [quote(col.name), SQL_TYPE[col.type]];
+    if (col.unique) parts.push("UNIQUE");
+    return parts.join(" ");
+  }
+  createTableSql(table) {
+    const cols = [`${quote("id")} TEXT PRIMARY KEY`];
+    for (const col of table.columns) cols.push(this.columnSql(col));
+    if (table.timestamps) {
+      cols.push(`${quote("createdAt")} TEXT`);
+      cols.push(`${quote("updatedAt")} TEXT`);
+    }
+    return `CREATE TABLE IF NOT EXISTS ${quote(table.table)} (
+  ${cols.join(",\n  ")}
+);`;
+  }
+  // -- value codecs ---------------------------------------------------------
+  encode(col, value) {
+    if (value === void 0 || value === null) return null;
+    switch (col.type) {
+      case "boolean":
+        return value ? 1 : 0;
+      case "json":
+        return JSON.stringify(value);
+      case "integer":
+        return Math.trunc(Number(value));
+      case "real":
+        return Number(value);
+      case "timestamp":
+        return value instanceof Date ? value.toISOString() : String(value);
+      default:
+        return String(value);
+    }
+  }
+  decode(col, value) {
+    if (value === void 0 || value === null) return null;
+    switch (col.type) {
+      case "boolean":
+        return Boolean(value);
+      case "json":
+        try {
+          return typeof value === "string" ? JSON.parse(value) : value;
+        } catch {
+          return null;
+        }
+      default:
+        return value;
+    }
+  }
+  decodeRow(table, raw) {
+    const out = { id: raw.id };
+    if ("createdAt" in raw) out.createdAt = raw.createdAt;
+    if ("updatedAt" in raw) out.updatedAt = raw.updatedAt;
+    for (const col of table.columns) out[col.name] = this.decode(col, raw[col.name]);
+    return out;
+  }
+  colByName(table) {
+    const m = /* @__PURE__ */ new Map();
+    for (const c of table.columns) m.set(c.name, c);
+    return m;
+  }
+  // -- where compilation ----------------------------------------------------
+  buildWhere(where, table, cols, allowed, params) {
+    const clauses = [];
+    if (where.and?.length) {
+      const sub = where.and.map((w) => this.buildWhere(w, table, cols, allowed, params)).filter(Boolean);
+      if (sub.length) clauses.push(`(${sub.join(" AND ")})`);
+    }
+    if (where.or?.length) {
+      const sub = where.or.map((w) => this.buildWhere(w, table, cols, allowed, params)).filter(Boolean);
+      if (sub.length) clauses.push(`(${sub.join(" OR ")})`);
+    }
+    for (const [field, cond] of Object.entries(where)) {
+      if (field === "and" || field === "or" || cond === void 0) continue;
+      if (!allowed.has(field)) throw new Error(`Cannot filter on unknown field "${field}" of "${table.table}".`);
+      clauses.push(this.fieldClause(field, cond, cols.get(field), params));
+    }
+    return clauses.length ? clauses.join(" AND ") : "";
+  }
+  encodeOperand(col, operand) {
+    if (col) return this.encode(col, operand);
+    if (typeof operand === "boolean") return operand ? 1 : 0;
+    return operand;
+  }
+  fieldClause(field, cond, col, params) {
+    const id = quote(field);
+    const parts = [];
+    for (const [op, operand] of Object.entries(cond)) {
+      switch (op) {
+        case "equals":
+          if (operand === null) parts.push(`${id} IS NULL`);
+          else {
+            params.push(this.encodeOperand(col, operand));
+            parts.push(`${id} = ?`);
+          }
+          break;
+        case "not_equals":
+          if (operand === null) parts.push(`${id} IS NOT NULL`);
+          else {
+            params.push(this.encodeOperand(col, operand));
+            parts.push(`(${id} <> ? OR ${id} IS NULL)`);
+          }
+          break;
+        case "in":
+        case "not_in": {
+          const arr = Array.isArray(operand) ? operand : [operand];
+          if (arr.length === 0) {
+            parts.push(op === "in" ? "0" : "1");
+            break;
+          }
+          for (const v of arr) params.push(this.encodeOperand(col, v));
+          const ph = arr.map(() => "?").join(", ");
+          parts.push(`${id} ${op === "in" ? "IN" : "NOT IN"} (${ph})`);
+          break;
+        }
+        case "greater_than":
+          params.push(this.encodeOperand(col, operand));
+          parts.push(`${id} > ?`);
+          break;
+        case "greater_than_equal":
+          params.push(this.encodeOperand(col, operand));
+          parts.push(`${id} >= ?`);
+          break;
+        case "less_than":
+          params.push(this.encodeOperand(col, operand));
+          parts.push(`${id} < ?`);
+          break;
+        case "less_than_equal":
+          params.push(this.encodeOperand(col, operand));
+          parts.push(`${id} <= ?`);
+          break;
+        case "like":
+        case "contains": {
+          const literal = String(operand).replace(/[\\%_]/g, (ch) => `\\${ch}`);
+          params.push(`%${literal}%`);
+          parts.push(`${id} LIKE ? ESCAPE '\\'`);
+          break;
+        }
+        case "exists":
+          parts.push(operand ? `${id} IS NOT NULL` : `${id} IS NULL`);
+          break;
+        default:
+          throw new Error(`Unsupported operator "${op}".`);
+      }
+    }
+    return parts.length ? `(${parts.join(" AND ")})` : "";
+  }
+  whereSql(table, where) {
+    if (!where) return { sql: "", params: [] };
+    const params = [];
+    const allowed = this.allowedCols.get(table.table) ?? /* @__PURE__ */ new Set(["id"]);
+    const clause = this.buildWhere(where, table, this.colByName(table), allowed, params);
+    return { sql: clause ? ` WHERE ${clause}` : "", params };
+  }
+  // -- CRUD -----------------------------------------------------------------
+  rawGet(table, id) {
+    const row = this.conn().prepare(`SELECT * FROM ${quote(table.table)} WHERE ${quote("id")} = ?`).get(id);
+    return row ? this.decodeRow(table, row) : null;
+  }
+  async findByID(args) {
+    return this.rawGet(this.table(args.collection), args.id);
+  }
+  async find(args) {
+    const table = this.table(args.collection);
+    const db = this.conn();
+    const { sql: whereSql, params } = this.whereSql(table, args.where);
+    const allowed = this.allowedCols.get(table.table) ?? /* @__PURE__ */ new Set(["id"]);
+    const totalRow = db.prepare(`SELECT COUNT(*) AS c FROM ${quote(table.table)}${whereSql}`).get(...params);
+    const totalDocs = Number(totalRow.c);
+    const sortParts = (args.sort ?? []).filter((s) => allowed.has(s.field)).map((s) => `${quote(s.field)} ${s.direction === "desc" ? "DESC" : "ASC"}`);
+    const orderBy = sortParts.length ? ` ORDER BY ${sortParts.join(", ")}` : ` ORDER BY ${quote("id")} ASC`;
+    const limit = args.limit;
+    const offset = (args.page - 1) * limit;
+    const rows = db.prepare(`SELECT * FROM ${quote(table.table)}${whereSql}${orderBy} LIMIT ? OFFSET ?`).all(...params, limit, offset);
+    const docs = rows.map((r) => this.decodeRow(table, r));
+    const totalPages = limit > 0 ? Math.max(Math.ceil(totalDocs / limit), 1) : 1;
+    const page = args.page;
+    return {
+      docs,
+      totalDocs,
+      limit,
+      page,
+      totalPages,
+      hasPrevPage: page > 1,
+      hasNextPage: page < totalPages,
+      prevPage: page > 1 ? page - 1 : null,
+      nextPage: page < totalPages ? page + 1 : null,
+      pagingCounter: offset + 1
+    };
+  }
+  async create(args) {
+    const table = this.table(args.collection);
+    const id = String(args.data.id);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const fields = [quote("id")];
+    const values = [id];
+    for (const col of table.columns) {
+      if (Object.prototype.hasOwnProperty.call(args.data, col.name)) {
+        fields.push(quote(col.name));
+        values.push(this.encode(col, args.data[col.name]));
+      }
+    }
+    if (table.timestamps) {
+      fields.push(quote("createdAt"), quote("updatedAt"));
+      values.push(now, now);
+    }
+    const placeholders = fields.map(() => "?").join(", ");
+    this.conn().prepare(`INSERT INTO ${quote(table.table)} (${fields.join(", ")}) VALUES (${placeholders})`).run(...values);
+    const created = this.rawGet(table, id);
+    if (!created) throw new Error("Insert succeeded but row could not be read back.");
+    return created;
+  }
+  async update(args) {
+    const table = this.table(args.collection);
+    const sets = [];
+    const values = [];
+    for (const col of table.columns) {
+      if (Object.prototype.hasOwnProperty.call(args.data, col.name)) {
+        sets.push(`${quote(col.name)} = ?`);
+        values.push(this.encode(col, args.data[col.name]));
+      }
+    }
+    if (table.timestamps) {
+      sets.push(`${quote("updatedAt")} = ?`);
+      values.push((/* @__PURE__ */ new Date()).toISOString());
+    }
+    if (sets.length > 0) {
+      values.push(args.id);
+      const res = this.conn().prepare(`UPDATE ${quote(table.table)} SET ${sets.join(", ")} WHERE ${quote("id")} = ?`).run(...values);
+      if (Number(res.changes) === 0 && !this.rawGet(table, args.id)) return null;
+    }
+    return this.rawGet(table, args.id);
+  }
+  async delete(args) {
+    const table = this.table(args.collection);
+    const existing = this.rawGet(table, args.id);
+    if (!existing) return null;
+    this.conn().prepare(`DELETE FROM ${quote(table.table)} WHERE ${quote("id")} = ?`).run(args.id);
+    return existing;
+  }
+  async count(args) {
+    const table = this.table(args.collection);
+    const { sql, params } = this.whereSql(table, args.where);
+    const row = this.conn().prepare(`SELECT COUNT(*) AS c FROM ${quote(table.table)}${sql}`).get(...params);
+    return Number(row.c);
+  }
+  async transaction(fn) {
+    const run = async () => {
+      const db = this.conn();
+      db.exec("BEGIN IMMEDIATE");
+      try {
+        const result2 = await fn(this);
+        db.exec("COMMIT");
+        return result2;
+      } catch (err) {
+        try {
+          db.exec("ROLLBACK");
+        } catch {
+        }
+        throw err;
+      }
+    };
+    const result = this.txTail.then(run, run);
+    this.txTail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  async health() {
+    try {
+      this.conn().prepare("SELECT 1").get();
+      return { status: "ok" };
+    } catch (err) {
+      return { status: "down", detail: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  async destroy() {
+    this.db?.close();
+    this.db = null;
+  }
+};
+function sqliteAdapter(options = {}) {
+  return new SQLiteAdapter(options);
+}
+export {
+  sqliteAdapter
+};

package/dist/types-DMOX4FIP.d.ts

@@ -0,0 +1,310 @@
+import { R as Row, W as Where, D as DatabaseAdapter, K as KernelSchema, P as PaginatedResult } from './index-BxvPeUO2.js';
+
+interface AuthUser {
+    id: string;
+    email?: string;
+    roles?: string[];
+    collection?: string;
+    [key: string]: unknown;
+}
+interface RequestContext<TUser extends AuthUser = AuthUser> {
+    /** The authenticated user, or null for anonymous requests. */
+    user: TUser | null;
+    /** Active locale for reads/writes. */
+    locale: string;
+    /** Locale to fall back to when a value is missing, or false to disable. */
+    fallbackLocale: string | false;
+    /** Arbitrary per-request data plugins can attach. */
+    context: Record<string, unknown>;
+}
+interface AccessArgs<TUser extends AuthUser = AuthUser> {
+    req: RequestContext<TUser>;
+    /** Present for update/delete/read-by-id. */
+    id?: string;
+    /** Present for create/update. */
+    data?: Row;
+}
+/** `true`/`false` to allow/deny, or a `Where` to constrain which rows are visible. */
+type AccessResult = boolean | Where;
+type AccessFn<TUser extends AuthUser = AuthUser> = (args: AccessArgs<TUser>) => AccessResult | Promise<AccessResult>;
+type Operation = 'create' | 'read' | 'update' | 'delete';
+interface HookArgs {
+    req: RequestContext;
+    operation: Operation;
+    /** Incoming/outgoing document data. */
+    data?: Row;
+    /** The existing document for update/delete. */
+    originalDoc?: Row;
+    doc?: Row;
+}
+type CollectionBeforeChangeHook = (args: HookArgs & {
+    data: Row;
+}) => Row | Promise<Row>;
+type CollectionAfterChangeHook = (args: HookArgs & {
+    doc: Row;
+}) => Row | Promise<Row>;
+type CollectionAfterReadHook = (args: HookArgs & {
+    doc: Row;
+}) => Row | Promise<Row>;
+type CollectionBeforeDeleteHook = (args: {
+    req: RequestContext;
+    id: string;
+}) => void | Promise<void>;
+type CollectionAfterDeleteHook = (args: {
+    req: RequestContext;
+    id: string;
+    doc: Row;
+}) => void | Promise<void>;
+interface CollectionHooks {
+    beforeChange?: CollectionBeforeChangeHook[];
+    afterChange?: CollectionAfterChangeHook[];
+    afterRead?: CollectionAfterReadHook[];
+    beforeDelete?: CollectionBeforeDeleteHook[];
+    afterDelete?: CollectionAfterDeleteHook[];
+}
+interface FieldValidateArgs {
+    value: unknown;
+    data: Row;
+    req: RequestContext;
+    operation: 'create' | 'update';
+    siblingData: Row;
+}
+type ValidateFn = (args: FieldValidateArgs) => true | string | Promise<true | string>;
+interface FieldAdmin {
+    description?: string;
+    placeholder?: string;
+    readOnly?: boolean;
+    hidden?: boolean;
+    position?: 'main' | 'sidebar';
+    width?: number;
+    /** Show this field only when the predicate over the current form data is true. */
+    condition?: (data: Row, siblingData: Row) => boolean;
+}
+interface FieldAccess {
+    read?: AccessFn;
+    create?: AccessFn;
+    update?: AccessFn;
+}
+interface FieldBase {
+    name: string;
+    label?: string;
+    required?: boolean;
+    unique?: boolean;
+    localized?: boolean;
+    index?: boolean;
+    defaultValue?: unknown;
+    admin?: FieldAdmin;
+    access?: FieldAccess;
+    validate?: ValidateFn;
+}
+interface TextField extends FieldBase {
+    type: 'text' | 'textarea' | 'email' | 'code' | 'slug';
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+}
+interface NumberField extends FieldBase {
+    type: 'number';
+    min?: number;
+    max?: number;
+    integer?: boolean;
+}
+interface BooleanField extends FieldBase {
+    type: 'boolean' | 'checkbox';
+}
+interface DateField extends FieldBase {
+    type: 'date';
+}
+interface JSONField extends FieldBase {
+    type: 'json';
+}
+interface RichTextField extends FieldBase {
+    type: 'richText';
+}
+interface PointField extends FieldBase {
+    type: 'point';
+}
+type SelectOption = string | {
+    label: string;
+    value: string;
+};
+interface SelectField extends FieldBase {
+    type: 'select' | 'radio';
+    options: SelectOption[];
+    hasMany?: boolean;
+}
+interface RelationshipField extends FieldBase {
+    type: 'relationship' | 'upload';
+    relationTo: string;
+    hasMany?: boolean;
+}
+interface ArrayField extends FieldBase {
+    type: 'array';
+    fields: AnyField[];
+    minRows?: number;
+    maxRows?: number;
+}
+interface GroupField extends FieldBase {
+    type: 'group';
+    fields: AnyField[];
+}
+type AnyField = TextField | NumberField | BooleanField | DateField | JSONField | RichTextField | PointField | SelectField | RelationshipField | ArrayField | GroupField;
+type FieldType = AnyField['type'];
+interface CollectionAccess {
+    read?: AccessFn;
+    create?: AccessFn;
+    update?: AccessFn;
+    delete?: AccessFn;
+}
+interface AuthOptions {
+    /** Token lifetime in seconds. */
+    tokenExpiration?: number;
+    /** Field used as the login identifier. Defaults to "email". */
+    loginField?: string;
+}
+interface CollectionConfig {
+    slug: string;
+    labels?: {
+        singular?: string;
+        plural?: string;
+    };
+    fields: AnyField[];
+    timestamps?: boolean;
+    admin?: {
+        useAsTitle?: string;
+        defaultColumns?: string[];
+        group?: string;
+        description?: string;
+        hidden?: boolean;
+    };
+    access?: CollectionAccess;
+    hooks?: CollectionHooks;
+    /** Mark this collection as an auth collection (adds email + password handling). */
+    auth?: boolean | AuthOptions;
+}
+interface GlobalConfig {
+    slug: string;
+    label?: string;
+    fields: AnyField[];
+    access?: {
+        read?: AccessFn;
+        update?: AccessFn;
+    };
+    hooks?: Pick<CollectionHooks, 'beforeChange' | 'afterChange' | 'afterRead'>;
+}
+interface LocalizationConfig {
+    locales: string[];
+    defaultLocale: string;
+    fallback?: boolean;
+}
+interface KernelConfig {
+    serverURL?: string;
+    db: DatabaseAdapter;
+    collections: CollectionConfig[];
+    globals?: GlobalConfig[];
+    localization?: LocalizationConfig;
+    routes?: {
+        api?: string;
+    };
+    admin?: {
+        user?: string;
+        meta?: {
+            titleSuffix?: string;
+        };
+    };
+    /** Secret used to sign auth tokens. Never hardcode; read from env. */
+    secret?: string;
+}
+interface SanitizedLocalization {
+    locales: string[];
+    defaultLocale: string;
+    fallback: boolean;
+}
+interface SanitizedConfig {
+    serverURL: string;
+    db: DatabaseAdapter;
+    collections: CollectionConfig[];
+    globals: GlobalConfig[];
+    localization: SanitizedLocalization | false;
+    routes: {
+        api: string;
+    };
+    admin: {
+        user: string;
+    };
+    secret: string;
+    collectionsBySlug: Record<string, CollectionConfig>;
+    globalsBySlug: Record<string, GlobalConfig>;
+}
+type Doc = Row & {
+    id: string;
+};
+interface OperationBase {
+    req?: Partial<RequestContext>;
+    overrideAccess?: boolean;
+    depth?: number;
+}
+interface FindOptions extends OperationBase {
+    collection: string;
+    where?: Where;
+    sort?: string | string[];
+    limit?: number;
+    page?: number;
+}
+interface FindByIDOptions extends OperationBase {
+    collection: string;
+    id: string;
+}
+interface CreateOptions extends OperationBase {
+    collection: string;
+    data: Row;
+}
+interface UpdateOptions extends OperationBase {
+    collection: string;
+    id: string;
+    data: Row;
+}
+interface DeleteOptions extends OperationBase {
+    collection: string;
+    id: string;
+}
+interface CountOptions extends OperationBase {
+    collection: string;
+    where?: Where;
+}
+interface FindGlobalOptions extends OperationBase {
+    slug: string;
+}
+interface UpdateGlobalOptions extends OperationBase {
+    slug: string;
+    data: Row;
+}
+interface LoginOptions {
+    collection: string;
+    email: string;
+    password: string;
+}
+interface AuthResult {
+    user: AuthUser;
+    token: string;
+    exp: number;
+}
+interface Kernel {
+    readonly config: SanitizedConfig;
+    readonly db: DatabaseAdapter;
+    readonly schema: KernelSchema;
+    find<T extends Doc = Doc>(opts: FindOptions): Promise<PaginatedResult<T>>;
+    findByID<T extends Doc = Doc>(opts: FindByIDOptions): Promise<T | null>;
+    create<T extends Doc = Doc>(opts: CreateOptions): Promise<T>;
+    update<T extends Doc = Doc>(opts: UpdateOptions): Promise<T | null>;
+    delete<T extends Doc = Doc>(opts: DeleteOptions): Promise<T | null>;
+    count(opts: CountOptions): Promise<number>;
+    login(opts: LoginOptions): Promise<AuthResult>;
+    authenticate(token: string): Promise<AuthUser | null>;
+    findGlobal<T extends Row = Row>(opts: FindGlobalOptions): Promise<T>;
+    updateGlobal<T extends Row = Row>(opts: UpdateGlobalOptions): Promise<T>;
+    migrate(): Promise<void>;
+    destroy(): Promise<void>;
+}
+
+export type { AccessArgs as A, BooleanField as B, CollectionAccess as C, DateField as D, KernelConfig as E, FieldAccess as F, GlobalConfig as G, HookArgs as H, LoginOptions as I, JSONField as J, Kernel as K, LocalizationConfig as L, OperationBase as M, NumberField as N, Operation as O, PointField as P, RequestContext as Q, RelationshipField as R, RichTextField as S, SanitizedConfig as T, SanitizedLocalization as U, SelectField as V, SelectOption as W, TextField as X, UpdateGlobalOptions as Y, UpdateOptions as Z, ValidateFn as _, AccessFn as a, AccessResult as b, AnyField as c, ArrayField as d, AuthOptions as e, AuthResult as f, AuthUser as g, CollectionAfterChangeHook as h, CollectionAfterDeleteHook as i, CollectionAfterReadHook as j, CollectionBeforeChangeHook as k, CollectionBeforeDeleteHook as l, CollectionConfig as m, CollectionHooks as n, CountOptions as o, CreateOptions as p, DeleteOptions as q, Doc as r, FieldAdmin as s, FieldBase as t, FieldType as u, FieldValidateArgs as v, FindByIDOptions as w, FindGlobalOptions as x, FindOptions as y, GroupField as z };