opacacms 0.1.0

package/dist/chunk-zvwb67nd.js

@@ -0,0 +1,332 @@
+// src/validation.ts
+import { z } from "zod";
+var FieldTypeSchema = z.enum([
+  "text",
+  "slug",
+  "textarea",
+  "number",
+  "richtext",
+  "relationship",
+  "select",
+  "radio",
+  "date",
+  "boolean",
+  "json",
+  "file",
+  "blocks",
+  "group",
+  "row",
+  "collapsible",
+  "tabs",
+  "join",
+  "array",
+  "virtual"
+]);
+var BaseFieldSchema = z.object({
+  name: z.string(),
+  label: z.string().optional(),
+  required: z.boolean().optional().default(false),
+  unique: z.boolean().optional().default(false),
+  localized: z.boolean().optional(),
+  defaultValue: z.any().optional(),
+  validate: z.function().optional(),
+  admin: z.object({
+    description: z.string().optional(),
+    condition: z.function().optional(),
+    hidden: z.boolean().optional(),
+    readOnly: z.boolean().optional(),
+    width: z.string().optional(),
+    style: z.any().optional(),
+    className: z.string().optional(),
+    components: z.object({
+      Field: z.string().optional(),
+      Cell: z.string().optional()
+    }).optional()
+  }).optional()
+});
+var FieldSchema = z.lazy(() => z.discriminatedUnion("type", [
+  BaseFieldSchema.extend({ type: z.literal("text") }),
+  BaseFieldSchema.extend({
+    type: z.literal("slug"),
+    from: z.string(),
+    format: z.function().optional()
+  }),
+  BaseFieldSchema.extend({ type: z.literal("textarea") }),
+  BaseFieldSchema.extend({ type: z.literal("number") }),
+  BaseFieldSchema.extend({ type: z.literal("date") }),
+  BaseFieldSchema.extend({
+    type: z.literal("boolean"),
+    options: z.object({
+      display: z.enum(["switch", "toggle", "checkbox", "select"]).optional().default("switch")
+    }).loose().optional()
+  }),
+  BaseFieldSchema.extend({
+    type: z.literal("richtext"),
+    options: z.object({
+      defaultMode: z.enum(["simple", "notion"]).optional()
+    }).loose().optional()
+  }),
+  BaseFieldSchema.extend({
+    type: z.literal("relationship"),
+    relationTo: z.string(),
+    hasMany: z.boolean().optional(),
+    displayField: z.string().optional(),
+    references: z.object({
+      table: z.string(),
+      column: z.string(),
+      onDelete: z.enum(["cascade", "set null", "restrict", "no action"]).optional()
+    }).optional()
+  }),
+  BaseFieldSchema.extend({
+    type: z.literal("select"),
+    options: z.object({
+      choices: z.array(z.union([z.string(), z.object({ label: z.string(), value: z.string() })]))
+    }).loose().optional()
+  }),
+  BaseFieldSchema.extend({
+    type: z.literal("radio"),
+    options: z.object({
+      choices: z.array(z.union([z.string(), z.object({ label: z.string(), value: z.string() })]))
+    }).loose()
+  }),
+  BaseFieldSchema.extend({
+    type: z.literal("file"),
+    bucket: z.string().optional(),
+    options: z.object({
+      allowedmime_types: z.array(z.string()).optional(),
+      maxFileSize: z.number().optional(),
+      metaFields: z.array(z.lazy(() => FieldSchema)).optional()
+    }).loose().optional()
+  }),
+  BaseFieldSchema.extend({
+    type: z.literal("json"),
+    fields: z.array(z.lazy(() => FieldSchema)).optional()
+  }),
+  BaseFieldSchema.extend({
+    type: z.literal("blocks"),
+    blocks: z.array(z.object({
+      slug: z.string(),
+      fields: z.array(z.lazy(() => FieldSchema)),
+      label: z.string().optional()
+    }))
+  }),
+  BaseFieldSchema.extend({
+    type: z.literal("group"),
+    fields: z.array(z.lazy(() => FieldSchema))
+  }),
+  z.object({
+    name: z.string().optional(),
+    type: z.literal("row"),
+    fields: z.array(z.lazy(() => FieldSchema)),
+    label: z.string().optional()
+  }),
+  z.object({
+    name: z.string().optional(),
+    type: z.literal("collapsible"),
+    fields: z.array(z.lazy(() => FieldSchema)),
+    label: z.string().optional(),
+    options: z.object({
+      initiallyCollapsed: z.boolean().optional()
+    }).loose().optional()
+  }),
+  z.object({
+    name: z.string().optional(),
+    type: z.literal("tabs"),
+    tabs: z.array(z.object({
+      label: z.string(),
+      fields: z.array(z.lazy(() => FieldSchema))
+    }))
+  }),
+  z.object({
+    name: z.string().optional().refine((val) => val === undefined, {
+      message: "Join fields are virtual and should not have a 'name' property. They are mapped dynamically via the API."
+    }).or(z.string()),
+    type: z.literal("join"),
+    collection: z.string(),
+    on: z.string(),
+    label: z.string().optional()
+  }),
+  BaseFieldSchema.extend({
+    type: z.literal("array"),
+    fields: z.array(z.lazy(() => FieldSchema)).optional()
+  }),
+  BaseFieldSchema.extend({
+    type: z.literal("virtual"),
+    resolve: z.function(),
+    returnType: z.string().optional()
+  })
+]));
+var AccessConfigSchema = z.object({
+  read: z.union([z.boolean(), z.function()]).optional(),
+  create: z.union([z.boolean(), z.function()]).optional(),
+  update: z.union([z.boolean(), z.function()]).optional(),
+  delete: z.union([z.boolean(), z.function()]).optional(),
+  requireApiKey: z.boolean().optional()
+});
+var CollectionHooksSchema = z.object({
+  beforeCreate: z.function().optional(),
+  afterCreate: z.function().optional(),
+  beforeUpdate: z.function().optional(),
+  afterUpdate: z.function().optional(),
+  beforeDelete: z.function().optional(),
+  afterDelete: z.function().optional()
+});
+var CollectionSchema = z.object({
+  slug: z.string(),
+  label: z.string().optional(),
+  icon: z.string().optional(),
+  apiPath: z.string().optional(),
+  fields: z.array(FieldSchema),
+  timestamps: z.union([
+    z.boolean(),
+    z.object({
+      createdAt: z.string().optional(),
+      updatedAt: z.string().optional()
+    })
+  ]).optional(),
+  auth: z.boolean().optional(),
+  hooks: CollectionHooksSchema.optional(),
+  access: AccessConfigSchema.optional(),
+  versions: z.object({
+    drafts: z.boolean().optional(),
+    maxRevisions: z.number().optional(),
+    autosave: z.boolean().optional()
+  }).optional(),
+  webhooks: z.array(z.object({
+    events: z.array(z.string()),
+    url: z.string(),
+    headers: z.record(z.string(), z.string()).optional()
+  })).optional(),
+  admin: z.union([
+    z.boolean(),
+    z.object({
+      defaultColumns: z.array(z.string()).optional(),
+      useAsTitle: z.string().optional(),
+      hidden: z.boolean().optional(),
+      disableAdmin: z.boolean().optional(),
+      views: z.array(z.object({
+        name: z.string(),
+        filter: z.record(z.string(), z.any()),
+        defaultColumns: z.array(z.string()).optional()
+      })).optional(),
+      bulkActions: z.array(z.object({
+        label: z.string(),
+        action: z.function()
+      })).optional()
+    })
+  ]).optional(),
+  hidden: z.boolean().optional()
+});
+var GlobalSchema = z.object({
+  slug: z.string(),
+  label: z.string().optional(),
+  icon: z.string().optional(),
+  fields: z.array(FieldSchema),
+  timestamps: z.union([
+    z.boolean(),
+    z.object({
+      createdAt: z.string().optional(),
+      updatedAt: z.string().optional()
+    })
+  ]).optional(),
+  access: AccessConfigSchema.optional()
+});
+var AdminConfigSchema = z.object({
+  userCollection: z.string().optional(),
+  disableAdmin: z.boolean().optional(),
+  route: z.string().optional()
+});
+var OpacaAuthConfigSchema = z.object({
+  strategies: z.object({
+    emailPassword: z.boolean().optional(),
+    magicLink: z.object({
+      enabled: z.boolean(),
+      sendEmail: z.function()
+    }).optional()
+  }).optional(),
+  socialProviders: z.object({
+    github: z.object({
+      clientId: z.string(),
+      clientSecret: z.string()
+    }).optional(),
+    google: z.object({
+      clientId: z.string(),
+      clientSecret: z.string()
+    }).optional()
+  }).optional(),
+  session: z.object({
+    expiresInDays: z.number().optional(),
+    updateAgeSeconds: z.number().optional()
+  }).optional(),
+  features: z.object({
+    apiKeys: z.object({
+      enabled: z.boolean()
+    }).optional(),
+    mfa: z.object({
+      enabled: z.boolean(),
+      issuer: z.string()
+    }).optional()
+  }).optional()
+});
+var ApiConfigSchema = z.object({
+  maxLimit: z.number().optional(),
+  rateLimit: z.object({
+    windowMs: z.number().optional(),
+    limit: z.number().optional(),
+    enabled: z.boolean().optional(),
+    store: z.any().optional(),
+    provider: z.function().optional(),
+    keyGenerator: z.function().optional()
+  }).optional()
+});
+var OpacaConfigSchema = z.object({
+  collections: z.array(CollectionSchema),
+  globals: z.array(GlobalSchema).optional(),
+  db: z.any(),
+  storages: z.record(z.string(), z.any()).optional(),
+  runMigrationsOnStartup: z.boolean().optional(),
+  admin: AdminConfigSchema.optional(),
+  serverURL: z.string().optional(),
+  appName: z.string().optional(),
+  secret: z.string().optional(),
+  trustedOrigins: z.union([z.array(z.string()), z.function()]).optional(),
+  auth: OpacaAuthConfigSchema.optional(),
+  api: ApiConfigSchema.optional(),
+  access: z.object({
+    roles: z.record(z.string(), z.record(z.string(), z.array(z.string()))).optional()
+  }).optional(),
+  i18n: z.object({
+    locales: z.array(z.string()),
+    defaultLocale: z.string()
+  }).optional()
+});
+
+// src/config.ts
+function recursivelyBuild(obj) {
+  if (!obj || typeof obj !== "object")
+    return obj;
+  if (typeof obj.build === "function") {
+    return recursivelyBuild(obj.build());
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(recursivelyBuild);
+  }
+  if (obj.constructor !== Object) {
+    return obj;
+  }
+  const built = {};
+  for (const [key, value] of Object.entries(obj)) {
+    built[key] = recursivelyBuild(value);
+  }
+  return built;
+}
+function defineConfig(config) {
+  const builtConfig = recursivelyBuild(config);
+  const result = OpacaConfigSchema.safeParse(builtConfig);
+  if (!result.success) {
+    throw new Error(`Invalid OpacaCMS Configuration: ${result.error.message}`);
+  }
+  return builtConfig;
+}
+
+export { defineConfig };

package/dist/cli/commands/generate-types.d.ts

@@ -0,0 +1 @@
+export declare function generateTypesCommand(url: string, token: string, out: string): Promise<void>;

package/dist/cli/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(target: string, example?: string): Promise<void>;

package/dist/cli/commands/migrate-commands.d.ts

@@ -0,0 +1,5 @@
+import type { DatabaseAdapter, OpacaConfig } from "../../types";
+export declare function migrateCreateCommand(opaca: OpacaConfig, migrationName?: string, outDir?: string): Promise<void>;
+export declare function migrateRunCommand(db: DatabaseAdapter): Promise<void>;
+export declare function migrateStatusCommand(opaca: OpacaConfig): Promise<void>;
+export declare function migrateD1Command(migrationDir: string, isRemote: boolean, binding?: string): Promise<void>;

package/dist/cli/commands/seed-command.d.ts

@@ -0,0 +1,2 @@
+import type { OpacaConfig } from "../../types";
+export declare function seedCommand(opaca: OpacaConfig, count: number, reset: boolean, type: "assets" | "collections"): Promise<void>;

package/dist/cli/d1-mock.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A minimal D1Database mock that wraps bun:sqlite to allow OpacaCMS CLI
+ * to run D1-based configurations locally.
+ *
+ * It prioritizes Wrangler's local state if found.
+ */
+export declare function createD1Mock(dbPath?: string): {
+    prepare(query: string): {
+        bind(...params: any[]): /*elided*/ any;
+        first(): Promise<unknown>;
+        all(): Promise<{
+            results: unknown[];
+            success: boolean;
+            meta: {};
+        }>;
+        run(): Promise<{
+            success: boolean;
+            meta: {
+                changes: number;
+                last_row_id: number | bigint;
+            };
+        }>;
+        raw(): Promise<unknown[]>;
+    };
+    batch(statements: any[]): Promise<any[]>;
+    exec(query: string): Promise<{
+        count: number;
+        duration: number;
+    }>;
+};

package/dist/cli/index.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+/**
+ * Loads and validates the OpacaCMS configuration from a file.
+ */
+export declare function loadConfig(configPath: string): Promise<any>;

package/dist/cli/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/r2-mock.d.ts

@@ -0,0 +1,46 @@
+/**
+ * A minimal R2Bucket mock for OpacaCMS CLI that uses Wrangler's local state.
+ * Stores metadata in _mf_objects table and blobs in .blobs sibling directory.
+ */
+export declare function createR2Mock(dbPath?: string): {
+    put(key: string, value: any, options?: any): Promise<{
+        key: string;
+        size: number;
+        etag: string;
+        httpMetadata: any;
+        customMetadata: any;
+    }>;
+    get(key: string): Promise<{
+        key: any;
+        size: any;
+        etag: any;
+        uploaded: Date;
+        httpMetadata: any;
+        customMetadata: any;
+        body: ReadableStream<any>;
+        bodyUsed: boolean;
+        arrayBuffer(): Promise<ArrayBuffer>;
+        text(): Promise<string>;
+        json(): Promise<any>;
+    } | null>;
+    head(key: string): Promise<{
+        key: any;
+        size: any;
+        etag: any;
+        uploaded: Date;
+        httpMetadata: any;
+        customMetadata: any;
+    } | null>;
+    delete(key: string): Promise<void>;
+    list(): Promise<{
+        objects: {
+            key: any;
+            size: any;
+            etag: any;
+            uploaded: Date;
+            httpMetadata: any;
+            customMetadata: any;
+        }[];
+        truncated: boolean;
+    }>;
+};

package/dist/cli/seeding.d.ts

@@ -0,0 +1,17 @@
+import type { Collection, DatabaseAdapter, OpacaConfig } from "../types";
+/**
+ * Default generators for each field type.
+ */
+export declare const defaultFieldGenerators: Record<string, () => any>;
+/**
+ * Generates a single record for a collection.
+ */
+export declare function generateRecord(db: DatabaseAdapter, collection: Collection, locales?: string[]): Promise<Record<string, any>>;
+/**
+ * Topologically sorts collections based on their dependencies.
+ */
+export declare function sortCollections(collections: Collection[]): Collection[];
+/**
+ * Seeds the database with mock data.
+ */
+export declare function autoSeed(config: OpacaConfig, countPerCollection?: number, reset?: boolean, type?: "collections" | "assets" | "all"): Promise<void>;

package/dist/client.d.ts

@@ -0,0 +1,51 @@
+import type { OpacaConfig } from "./types";
+export interface OpacaClientOptions {
+    baseURL: string;
+    token?: string;
+}
+/**
+ * A proxy-based client that provides a typed experience for interacting with the OpacaCMS API.
+ */
+export interface GeneratedTypes {
+    collections: Record<string, any>;
+    globals: Record<string, any>;
+}
+/**
+ * Custom error class for OpacaCMS SDK errors.
+ */
+export declare class OpacaError extends Error {
+    status: number;
+    data: any;
+    constructor(message: string, status: number, data?: any);
+}
+export declare function createClient<T = any>(configOrOptions: T | OpacaClientOptions): {
+    getMetadata: () => Promise<any>;
+    getCollections: () => Promise<any[]>;
+    getSetupStatus: () => Promise<{
+        initialized: boolean;
+    }>;
+    collections: { [K in T extends OpacaConfig<string> ? T["collections"] extends any[] ? T["collections"][number]["slug"] : string : T extends GeneratedTypes ? keyof T["collections"] : string]: {
+        find: (query?: any) => Promise<{
+            docs: (T extends GeneratedTypes ? K extends keyof T["collections"] ? T["collections"][K] : any : any)[];
+            totalDocs: number;
+            page: number;
+            totalPages: number;
+        }>;
+        findOne: (id: string) => Promise<T extends GeneratedTypes ? K extends keyof T["collections"] ? T["collections"][K] : any : any>;
+        list: () => Promise<{
+            docs: (T extends GeneratedTypes ? K extends keyof T["collections"] ? T["collections"][K] : any : any)[];
+            totalDocs: number;
+            page: number;
+            totalPages: number;
+        }>;
+        create: (data: Partial<T extends GeneratedTypes ? K extends keyof T["collections"] ? T["collections"][K] : any : any>) => Promise<T extends GeneratedTypes ? K extends keyof T["collections"] ? T["collections"][K] : any : any>;
+        update: (id: string, data: Partial<T extends GeneratedTypes ? K extends keyof T["collections"] ? T["collections"][K] : any : any>) => Promise<T extends GeneratedTypes ? K extends keyof T["collections"] ? T["collections"][K] : any : any>;
+        delete: (id: string) => Promise<{
+            success: boolean;
+        }>;
+    }; };
+    globals: { [K in T extends OpacaConfig<string> ? T["globals"] extends any[] ? T["globals"][number]["slug"] : string : T extends GeneratedTypes ? keyof T["globals"] : string]: {
+        get: () => Promise<T extends GeneratedTypes ? K extends keyof T["globals"] ? T["globals"][K] : any : any>;
+        update: (data: Partial<T extends GeneratedTypes ? K extends keyof T["globals"] ? T["globals"][K] : any : any>) => Promise<T extends GeneratedTypes ? K extends keyof T["globals"] ? T["globals"][K] : any : any>;
+    }; };
+};

package/dist/config-utils.d.ts

@@ -0,0 +1,6 @@
+import type { OpacaConfig, SerializableConfig } from "./types";
+/**
+ * Sanitizes the OpacaConfig to ensure it's safe to pass to Client Components or over the API.
+ * Strips out functions (hooks, access) and the database adapter.
+ */
+export declare function sanitizeConfig(config: OpacaConfig): SerializableConfig;

package/dist/config.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Helper to define the OpacaCMS configuration with full type safety.
+ */
+import type { Collection, OpacaConfig } from "./types";
+/**
+ * Helper logic to infer slugs from collections.
+ */
+export declare function defineConfig<const TCollections extends readonly Collection[]>(config: OpacaConfig<TCollections[number]["slug"]> & {
+    collections: TCollections;
+}): OpacaConfig<TCollections[number]["slug"]>;

package/dist/db/adapter.d.ts

@@ -0,0 +1,34 @@
+import type { Collection, DatabaseAdapter, FindOptions, Global, PaginatedResult } from "../types";
+/**
+ * BaseDatabaseAdapter is an abstract class that implements the DatabaseAdapter interface.
+ * It provides a foundation for database adapters and enforces the implementation of required methods.
+ */
+export declare abstract class BaseDatabaseAdapter implements DatabaseAdapter {
+    abstract name: string;
+    get raw(): unknown;
+    get db(): unknown;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    /**
+     * Execute a raw SQL query directly on the database.
+     */
+    abstract unsafe(sql: string, params?: any[]): Promise<any>;
+    /**
+     * Count documents in a collection.
+     */
+    abstract count(collection: string, query?: any): Promise<number>;
+    abstract create<T extends object>(collection: string, data: Partial<T>): Promise<T>;
+    abstract find<T extends object>(collection: string, query?: any, options?: FindOptions): Promise<PaginatedResult<T>>;
+    abstract findOne<T extends object>(collection: string, query: any): Promise<T | null>;
+    abstract update<T extends object>(collection: string, query: any, data: Partial<T>): Promise<T>;
+    abstract updateMany?<T extends object>(collection: string, query: any, data: Partial<T>): Promise<number>;
+    abstract delete(collection: string, query: any): Promise<boolean>;
+    abstract deleteMany?(collection: string, query: any): Promise<number>;
+    abstract findGlobal?<T extends object>(slug: string): Promise<T | null>;
+    abstract updateGlobal?<T extends object>(slug: string, data: Partial<T>): Promise<T>;
+    abstract migrate(collections: Collection[], globals?: Global[]): Promise<void>;
+    push?: boolean;
+    pushDestructive?: boolean;
+    migrationDir?: string;
+    runMigrations?(): Promise<void>;
+}

package/dist/db/better-sqlite.d.ts

@@ -0,0 +1,40 @@
+import { Kysely } from "kysely";
+import type { Collection, FindOptions, Global, PaginatedResult } from "../types";
+import { BaseDatabaseAdapter } from "./adapter";
+export declare class BetterSQLiteAdapter extends BaseDatabaseAdapter {
+    name: string;
+    private _rawDb;
+    private _db;
+    private _collections;
+    push: boolean;
+    migrationDir: string;
+    pushDestructive: boolean;
+    get raw(): any;
+    get db(): Kysely<any>;
+    constructor(path: string, options?: {
+        push?: boolean;
+        pushDestructive?: boolean;
+        migrationDir?: string;
+    });
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    unsafe(query: string, params?: any[]): Promise<unknown>;
+    private coerceData;
+    count(collection: string, query?: Record<string, unknown>): Promise<number>;
+    create<T extends object>(collection: string, data: Partial<T>): Promise<T>;
+    findOne<T extends object>(collection: string, query: Record<string, unknown>, tx?: any): Promise<T | null>;
+    find<T extends object>(collection: string, query?: Record<string, unknown>, options?: FindOptions): Promise<PaginatedResult<T>>;
+    update<T extends object>(collection: string, query: Record<string, unknown> | string | number, data: Partial<T>): Promise<T>;
+    delete(collection: string, query: Record<string, unknown> | string | number): Promise<boolean>;
+    updateMany<T extends object>(collection: string, query: Record<string, unknown>, data: Partial<T>): Promise<number>;
+    deleteMany(collection: string, query: Record<string, unknown>): Promise<number>;
+    findGlobal<T extends object>(slug: string): Promise<T | null>;
+    updateGlobal<T extends object>(slug: string, data: Partial<T>): Promise<T>;
+    runMigrations(): Promise<void>;
+    migrate(collections: Collection[], globals?: Global[]): Promise<void>;
+}
+export declare function createBetterSQLiteAdapter(path: string, options?: {
+    push?: boolean;
+    pushDestructive?: boolean;
+    migrationDir?: string;
+}): BetterSQLiteAdapter;

package/dist/db/bun-sqlite.d.ts

@@ -0,0 +1,40 @@
+import { Kysely } from "kysely";
+import type { Collection, FindOptions, Global, PaginatedResult } from "../types";
+import { BaseDatabaseAdapter } from "./adapter";
+export declare class BunSQLiteAdapter extends BaseDatabaseAdapter {
+    name: string;
+    private _rawDb;
+    private _db;
+    private _collections;
+    push: boolean;
+    migrationDir: string;
+    pushDestructive: boolean;
+    get raw(): any;
+    get db(): Kysely<any>;
+    constructor(path: string, options?: {
+        push?: boolean;
+        pushDestructive?: boolean;
+        migrationDir?: string;
+    });
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    unsafe(query: string, params?: any[]): Promise<unknown>;
+    private coerceData;
+    count(collection: string, query?: Record<string, unknown>): Promise<number>;
+    create<T extends object>(collection: string, data: Partial<T>): Promise<T>;
+    findOne<T extends object>(collection: string, query: Record<string, unknown>, tx?: any): Promise<T | null>;
+    find<T extends object>(collection: string, query?: Record<string, unknown>, options?: FindOptions): Promise<PaginatedResult<T>>;
+    update<T extends object>(collection: string, query: Record<string, unknown> | string | number, data: Partial<T>): Promise<T>;
+    updateMany<T extends object>(collection: string, query: Record<string, unknown>, data: Partial<T>): Promise<number>;
+    delete(collection: string, query: Record<string, unknown> | string | number): Promise<boolean>;
+    deleteMany(collection: string, query: Record<string, unknown>): Promise<number>;
+    findGlobal<T extends object>(slug: string): Promise<T | null>;
+    updateGlobal<T extends object>(slug: string, data: Partial<T>): Promise<T>;
+    runMigrations(): Promise<void>;
+    migrate(collections: Collection[], globals?: Global[]): Promise<void>;
+}
+export declare function createBunSQLiteAdapter(path: string, options?: {
+    push?: boolean;
+    pushDestructive?: boolean;
+    migrationDir?: string;
+}): BunSQLiteAdapter;