@kyro-cms/core 0.1.6 → 0.1.8

package/dist/index.d.ts

@@ -3,36 +3,87 @@ export { createContext, createCountProcedure, createCreateProcedure, createDelet
 import * as graphql from 'graphql';
 import * as hono from 'hono';
 import * as hono_types from 'hono/types';
-import { R as Registry } from './index-4fJKLFK2.js';
-export { c as createRegistry, g as getRegistry, r as resetRegistry } from './index-4fJKLFK2.js';
-import { B as BaseAdapter, K as KyroConfig, f as User, g as Request$1, C as CollectionConfig, G as GlobalConfig, F as Field, a as FindArgs, b as FindResult, c as FindByIDArgs, d as CreateArgs, U as UpdateArgs, D as DeleteArgs, H as Hook } from './types-BGM5MV_K.js';
-export { A as ALL_FIELD_TYPES, h as AccessArgs, i as AccessControl, j as AdapterConfig, k as AdminConfig, l as ArrayField, m as AuthConfig, n as BaseField, o as Block, p as BlocksField, q as COMPLEX_FIELD_TYPES, r as CheckboxField, s as CodeField, t as CollapsibleField, u as CollectionAccess, v as CollectionHooks, w as ColorField, x as CreateResult, y as DateField, E as EmailField, z as FieldAccess, I as FieldAdmin, J as FieldHooks, L as FieldType, M as GlobalAccess, N as GlobalHooks, O as GroupField, Q as HookArgs, S as ImageSize, T as JSONField, V as LAYOUT_FIELD_TYPES, W as MarkdownField, X as NumberField, Y as PRIMITIVE_FIELD_TYPES, Z as PasswordField, P as PluginConfig, _ as RELATIONAL_FIELD_TYPES, $ as RadioField, R as RelationshipField, a0 as RichTextBlock, a1 as RichTextField, a2 as RowField, a3 as SelectField, a4 as TabsField, a5 as TextField, a6 as TextareaField, a7 as UploadConfig, e as UploadField, a8 as ValidateOptions, a9 as VersionConfig, aa as WhereClause, ab as evaluateAccess, ac as getWhereClause, ad as isArrayField, ae as isBlocksField, af as isGroupField, ag as isLayoutField, ah as isNumberField, ai as isRelationshipField, aj as isRichTextField, ak as isSelectField, al as isTextField, am as isUploadField, an as mergeWhereClauses, ao as runFieldHooks, ap as runHooks } from './types-BGM5MV_K.js';
+import { R as Registry } from './index-BvZ1iWm2.js';
+export { c as createRegistry, g as getRegistry, r as resetRegistry } from './index-BvZ1iWm2.js';
+import { w as BaseAdapter, K as KyroConfig, Q as User, W as Request$1, i as CollectionConfig, G as GlobalConfig, F as Field, x as FindArgs, y as FindResult, z as FindByIDArgs, H as CreateArgs, L as UpdateArgs, O as DeleteArgs, X as Hook } from './types-Bt1OEk0S.js';
+export { Y as ALL_FIELD_TYPES, Z as AccessArgs, _ as AccessControl, $ as AdapterConfig, A as AdminConfig, a as ArrayField, b as AuthConfig, B as BaseField, c as Block, f as BlocksField, a0 as COMPLEX_FIELD_TYPES, C as CheckboxField, g as CodeField, h as CollapsibleField, a1 as CollectionAccess, a2 as CollectionHooks, j as ColorField, a3 as CreateResult, D as DateField, E as EmailField, a4 as FieldAccess, k as FieldAdmin, a5 as FieldHooks, l as FieldType, a6 as GlobalAccess, a7 as GlobalHooks, m as GroupField, a8 as HookArgs, I as ImageField, n as ImageSize, J as JSONField, a9 as LAYOUT_FIELD_TYPES, M as MarkdownField, N as NumberField, aa as PRIMITIVE_FIELD_TYPES, P as PasswordField, v as PluginConfig, ab as RELATIONAL_FIELD_TYPES, R as RadioField, o as RelationshipField, p as RichTextBlock, q as RichTextField, r as RowField, S as SelectField, T as TabsField, s as TextField, t as TextareaField, U as UploadConfig, u as UploadField, ac as ValidateOptions, V as VersionConfig, ad as WhereClause, ae as evaluateAccess, af as getWhereClause, ag as isArrayField, ah as isBlocksField, ai as isGroupField, aj as isImageField, ak as isLayoutField, al as isNumberField, am as isRelationshipField, an as isRichTextField, ao as isSelectField, ap as isTextField, aq as isUploadField, ar as mergeWhereClauses, as as runFieldHooks, at as runHooks } from './types-Bt1OEk0S.js';
 import { KyroPubSub, KyroWSServer } from './ws/index.js';
 export { PubSub, createWSServer } from './ws/index.js';
 import { ZodTypeAny } from 'zod';
 export { z } from 'zod';
-import { A as AbstractBaseAdapter } from './base-CQkFzqQl.js';
-import { A as AuthAdapter, U as UserRole, a as AuthUser, S as Session, b as AuthTokenConfig, R as RegisterData, c as AuthResult, L as LoginCredentials, J as JWTPayload } from './index-CMUNCIWQ.js';
-export { D as DrizzleAdapter, P as PostgresAuthAdapter, d as collectionToDrizzleSchema, e as createDatabase, f as createDrizzleAdapter, g as fieldToDrizzleType, r as runMigrations, s as seedDefaultRoles } from './index-CMUNCIWQ.js';
+import { A as AbstractBaseAdapter } from './base-CciYzoDF.js';
+import { Dialect } from './drizzle/index.js';
+export { DrizzleAdapter, PostgresAuthAdapter, collectionToDrizzleSchema, createDatabase, createDrizzleAdapter, fieldToDrizzleType, runMigrations, seedDefaultRoles } from './drizzle/index.js';
 export { MongoDBAdapter, createMongoDBAdapter } from './mongodb/index.js';
 export { buildGraphQLSchema, createGraphQLSchema } from './graphql/index.js';
 export { createHonoApp, createRESTAPI } from './rest/index.js';
+import { R as RateLimitConfig, b as RateLimitResult, L as LockoutConfig, a as LockoutStatus } from './rate-limit-CJnqG1mG.js';
+export { q as AccountLockout, A as AdminStylingConfig, C as CSSGenerator, F as FieldStyling, r as RateLimiter, s as RedisAuthAdapter, S as StylingConfig, d as StylingMode, T as ThemeBorderRadius, e as ThemeColors, f as ThemeConfig, g as ThemeFonts, h as ThemeShadows, i as ThemeSpacing, j as createAdminStyling, k as defaultDarkTheme, l as defaultFieldStyling, m as defaultLightTheme, n as ecommerce2026Theme, o as generateCSSVariables, p as generateTailwindConfig } from './rate-limit-CJnqG1mG.js';
+import { f as AuthUser, c as AuthAdapter, a as AuditLog, b as AuditLogFilter, U as UserRole, S as Session, e as AuthTokenConfig, R as RegisterData, d as AuthResult, L as LoginCredentials, J as JWTPayload } from './types-BSR91JFN.js';
+export { A as AuditAction, g as AuditLogger, h as createAuditContext } from './types-BSR91JFN.js';
 import Database from 'better-sqlite3';
+import { W as WebhookPayload, a as WebhookDelivery, b as WebhookConfig } from './WebhookService-CXJ5oz6L.js';
+export { A as ALL_WEBHOOK_EVENTS, C as CreateWebhookData, U as UpdateWebhookData, c as WEBHOOK_COLLECTION, d as WEBHOOK_DELIVERY_COLLECTION, e as WEBHOOK_EVENTS, f as WebhookEvent, g as WebhookService, h as WebhookTriggerResult, i as createWebhookService } from './WebhookService-CXJ5oz6L.js';
 export { TemplateConfig, allSettingsGlobals, blogCollections, blogGlobals, coreSettingsGlobals, createTemplateConfig, ecommerceCollections, ecommerceGlobals, ecommerceSettingsGlobals, kitchenSinkCollections, mediaCollections, minimalCollections } from './templates/index.js';
-import Redis from 'ioredis';
-import { SentMessageInfo } from 'nodemailer';
 import 'ws';
 import 'drizzle-orm/postgres-js';
-import 'postgres';
+import 'ioredis';
+
+interface DeliveryResult {
+    success: boolean;
+    status: number;
+    statusText?: string;
+    body?: string;
+    duration: number;
+    error?: string;
+}
+interface DeliveryOptions {
+    timeout?: number;
+    maxRetries?: number;
+    retryDelay?: number;
+    onRetry?: (attempt: number, error: string) => void;
+    onSuccess?: (result: DeliveryResult) => void;
+    onFailure?: (error: string) => void;
+}
+declare function signPayload(payload: string, secret: string): string;
+declare function generateWebhookSecret(): string;
+declare function deliverWebhook(webhook: WebhookConfig, payload: WebhookPayload, options?: DeliveryOptions): Promise<DeliveryResult>;
+declare function deliverWithRetry(webhook: WebhookConfig, payload: WebhookPayload, deliveryId: string, options?: DeliveryOptions): Promise<DeliveryResult>;
+declare function buildDeliveryRecord(deliveryId: string, webhookId: string, event: string, payload: WebhookPayload, attempt: number, result: DeliveryResult): WebhookDelivery;
+declare function createTestPayload(): WebhookPayload;
+
+interface RichTextMark {
+    type: string;
+    attrs?: Record<string, unknown>;
+}
+interface RichTextNode {
+    type?: string;
+    attrs?: Record<string, unknown>;
+    content?: RichTextNode[];
+    text?: string;
+    marks?: RichTextMark[];
+    [key: string]: unknown;
+}
+interface RichTextDocument extends RichTextNode {
+    type: "doc";
+    content: RichTextNode[];
+}
+declare const richTextStyles: string;
+declare function createColumnsNode(columns?: number): RichTextNode;
+declare function normalizeRichTextDocument(value: unknown): RichTextDocument;
+declare function normalizeRichTextValue<T>(value: T): T;
+declare function renderRichText(value: unknown): string;
 
 declare class Kyro {
     registry: Registry;
     db: BaseAdapter;
     pubsub: KyroPubSub;
+    settings?: Record<string, any>;
     private wsServer?;
     private config;
     constructor(config: KyroConfig);
     init(): Promise<void>;
+    loadSettings(): Promise<Record<string, any>>;
     getREST(options?: {
         user?: User;
         req?: Request$1;
@@ -52,7 +103,7 @@ declare class Kyro {
         port?: number;
         requireAuth?: boolean;
         verifyToken?: (token: string) => Promise<any>;
-    }): Promise<KyroWSServer>;
+    }): Promise<KyroWSServer | null>;
     shutdown(): Promise<void>;
 }
 declare function createKyro(config: KyroConfig): Kyro;
@@ -255,159 +306,43 @@ declare const presetPlugins: {
     Wishlist: typeof WishlistPlugin;
 };
 
-type StylingMode = 'css' | 'tailwind' | 'css-in-js' | 'styled-components' | 'vanilla-extract';
-interface StylingConfig {
-    mode: StylingMode;
-    theme?: ThemeConfig;
-    customProperties?: Record<string, string>;
-}
-interface ThemeConfig {
-    colors?: ThemeColors;
-    fonts?: ThemeFonts;
-    spacing?: ThemeSpacing;
-    borderRadius?: ThemeBorderRadius;
-    shadows?: ThemeShadows;
-    breakpoints?: Record<string, string>;
-}
-interface ThemeColors {
-    primary?: string;
-    secondary?: string;
-    accent?: string;
-    background?: string;
-    surface?: string;
-    text?: string;
-    textMuted?: string;
-    border?: string;
-    error?: string;
-    warning?: string;
-    success?: string;
-    info?: string;
-}
-interface ThemeFonts {
-    sans?: string;
-    serif?: string;
-    mono?: string;
-}
-interface ThemeSpacing {
-    xs?: string;
-    sm?: string;
-    md?: string;
-    lg?: string;
-    xl?: string;
-    '2xl'?: string;
-    '3xl'?: string;
-    '4xl'?: string;
-}
-interface ThemeBorderRadius {
-    sm?: string;
-    md?: string;
-    lg?: string;
-    xl?: string;
-    full?: string;
-}
-interface ThemeShadows {
-    sm?: string;
-    md?: string;
-    lg?: string;
-    xl?: string;
-}
-declare class CSSGenerator {
-    private config;
-    private css;
-    constructor(config: StylingConfig);
-    addRule(selector: string, properties: Record<string, string>): this;
-    addMediaQuery(breakpoint: string, rules: string[]): this;
-    generate(): string;
-}
-declare function generateTailwindConfig(theme: ThemeConfig): Record<string, any>;
-declare const defaultLightTheme: ThemeConfig;
-declare const defaultDarkTheme: ThemeConfig;
-declare const ecommerce2026Theme: ThemeConfig;
-declare function generateCSSVariables(theme: ThemeConfig): string;
-interface AdminStylingConfig {
-    mode: StylingMode;
-    theme?: ThemeConfig;
-    customStyles?: string;
-    componentOverrides?: Record<string, Record<string, string>>;
-}
-declare function createAdminStyling(config: AdminStylingConfig): string;
-interface FieldStyling {
-    wrapper?: Record<string, string>;
-    label?: Record<string, string>;
-    input?: Record<string, string>;
-    error?: Record<string, string>;
-    description?: Record<string, string>;
-}
-declare const defaultFieldStyling: Record<string, FieldStyling>;
-
-interface RedisAuthAdapterOptions {
-    url?: string;
-    host?: string;
-    port?: number;
-    password?: string;
-    db?: number;
-    keyPrefix?: string;
-    tokenExpiration?: number;
-    refreshTokenExpiration?: number;
-    tls?: boolean;
-}
-declare class RedisAuthAdapter implements AuthAdapter {
-    private redis;
-    private prefix;
-    private tokenExpiration;
-    private refreshExpiration;
-    constructor(options?: RedisAuthAdapterOptions);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    private userKey;
-    private sessionKey;
-    private refreshKey;
-    private userByEmailKey;
-    private passwordHistoryKey;
-    createUser(data: {
-        email: string;
-        passwordHash: string;
-        role?: UserRole;
-        tenantId?: string;
-    }): Promise<AuthUser>;
-    findUserByEmail(email: string): Promise<AuthUser | null>;
-    findUserById(userId: string): Promise<AuthUser | null>;
-    updateUser(userId: string, data: Partial<AuthUser>): Promise<AuthUser | null>;
-    deleteUser(userId: string): Promise<boolean>;
-    hashPassword(password: string): Promise<string>;
-    verifyPassword(password: string, hash: string): Promise<boolean>;
-    createSession(userId: string, data?: {
-        ipAddress?: string;
-        userAgent?: string;
-    }): Promise<Session>;
-    findSessionByToken(token: string): Promise<Session | null>;
-    deleteSession(sessionId: string): Promise<boolean>;
-    deleteUserSessions(userId: string): Promise<number>;
-    addPasswordToHistory(userId: string, passwordHash: string): Promise<void>;
-    getPasswordHistory(userId: string, count?: number): Promise<string[]>;
-    isPasswordInHistory(password: string, userId: string, historyCount?: number): Promise<boolean>;
-    private userToHash;
-    private hashToUser;
-    private sessionToHash;
-    private hashToSession;
-}
-
-interface EmailConfig {
-    host: string;
-    port: number;
-    secure: boolean;
-    auth: {
-        user: string;
-        pass: string;
-    };
+interface EmailConfig$1 {
+    provider: "smtp" | "resend" | "sendgrid" | "mailgun" | "ses";
     from: string;
     fromName?: string;
+    replyTo?: string;
+    smtp?: {
+        host: string;
+        port: number;
+        secure: boolean;
+        auth: {
+            user: string;
+            pass: string;
+        };
+    };
+    resend?: {
+        apiKey: string;
+    };
+    sendgrid?: {
+        apiKey: string;
+    };
+    mailgun?: {
+        apiKey: string;
+        domain: string;
+        region?: "us" | "eu";
+    };
+    ses?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        region: string;
+    };
 }
 interface EmailOptions {
     to: string | string[];
     subject: string;
     html: string;
     text?: string;
+    replyTo?: string;
 }
 interface EmailTemplates {
     verifyEmail: (link: string, userName?: string) => {
@@ -442,14 +377,17 @@ interface EmailTemplates {
     };
 }
 declare class EmailTransport {
-    private transporter;
-    private from;
-    private fromName;
+    private transporter?;
+    private config;
     private templates;
-    constructor(config: EmailConfig, templates?: Partial<EmailTemplates>);
-    send(options: EmailOptions): Promise<SentMessageInfo>;
+    constructor(config: EmailConfig$1, templates?: Partial<EmailTemplates>);
+    send(options: EmailOptions): Promise<any>;
+    private sendViaResend;
+    private sendViaSendGrid;
+    private sendViaMailgun;
     getTemplates(): EmailTemplates;
     verifyConnection(): Promise<boolean>;
+    static fromConfig(db: any): Promise<EmailTransport | null>;
     static fromEnv(): EmailTransport | null;
 }
 
@@ -460,17 +398,7 @@ interface BootstrapConfig {
     adminPassword: string;
     adminRole?: string;
     tenantId?: string;
-    emailConfig?: {
-        host: string;
-        port: number;
-        secure: boolean;
-        auth: {
-            user: string;
-            pass: string;
-        };
-        from: string;
-        fromName?: string;
-    };
+    emailConfig?: EmailConfig$1;
     sendWelcomeEmail?: boolean;
 }
 interface BootstrapResult {
@@ -511,138 +439,6 @@ declare class PasswordPolicy {
     getConfig(): PasswordPolicyConfig;
 }
 
-interface LockoutConfig {
-    maxAttempts: number;
-    lockDuration: number;
-    notifyUser: boolean;
-    notifyAdmin: boolean;
-    adminNotifyAfter: number;
-}
-interface LockoutStatus {
-    locked: boolean;
-    attemptsRemaining: number;
-    lockedUntil?: Date;
-    totalAttempts: number;
-}
-declare class AccountLockout {
-    private redis;
-    private prefix;
-    private config;
-    constructor(redis: Redis, config?: Partial<LockoutConfig>, prefix?: string);
-    private lockKey;
-    private historyKey;
-    checkLockout(userId: string): Promise<LockoutStatus>;
-    recordFailedAttempt(userId: string): Promise<LockoutStatus>;
-    lockAccount(userId: string, duration?: number): Promise<void>;
-    unlockAccount(userId: string): Promise<void>;
-    resetAttempts(userId: string): Promise<void>;
-    getLockoutHistory(userId: string, limit?: number): Promise<Date[]>;
-    getLockoutStats(userId: string): Promise<{
-        totalFailedAttempts: number;
-        lockoutCount: number;
-        lastLockout: Date | null;
-        averageAttemptsBeforeLockout: number;
-    }>;
-    shouldNotifyAdmin(currentAttempts: number): boolean;
-    getConfig(): LockoutConfig;
-    setConfig(config: Partial<LockoutConfig>): void;
-}
-
-interface RateLimitConfig {
-    window: number;
-    max: number;
-}
-interface RateLimitResult {
-    allowed: boolean;
-    remaining: number;
-    resetAt: number;
-    retryAfter?: number;
-}
-declare class RateLimiter {
-    private redis;
-    private prefix;
-    private limits;
-    private userLimits;
-    constructor(redis: Redis, limits?: Record<string, RateLimitConfig>, userLimits?: Record<string, RateLimitConfig>, prefix?: string);
-    private getKey;
-    check(type: string, identifier: string): Promise<RateLimitResult>;
-    checkUser(type: string, userId: string, identifier: string): Promise<RateLimitResult>;
-    reset(type: string, identifier: string): Promise<void>;
-    resetUser(type: string, userId: string, identifier: string): Promise<void>;
-    getStatus(type: string, identifier: string): Promise<{
-        count: number;
-        limit: number;
-        remaining: number;
-        resetAt: number;
-    }>;
-    setLimit(type: string, config: RateLimitConfig): void;
-    setUserLimit(type: string, config: RateLimitConfig): void;
-}
-
-type AuditAction = "login" | "logout" | "login_failed" | "register" | "verify_email" | "password_change" | "password_reset" | "password_reset_request" | "role_change" | "permission_change" | "document_create" | "document_update" | "document_delete" | "settings_change" | "user_lockout" | "user_unlock" | "user_create" | "user_update" | "user_delete" | "api_request" | "api_key_create" | "api_key_delete" | "tenant_create" | "tenant_delete";
-interface AuditLog {
-    id: string;
-    timestamp: Date;
-    action: AuditAction;
-    userId?: string;
-    userEmail?: string;
-    role?: string;
-    resource: string;
-    resourceId?: string;
-    changes?: {
-        field: string;
-        old: any;
-        new: any;
-    }[];
-    ipAddress?: string;
-    userAgent?: string;
-    success: boolean;
-    error?: string;
-    metadata?: Record<string, any>;
-}
-interface AuditLogFilter {
-    userId?: string;
-    action?: AuditAction | AuditAction[];
-    resource?: string;
-    resourceId?: string;
-    success?: boolean;
-    startDate?: Date;
-    endDate?: Date;
-    limit?: number;
-    offset?: number;
-}
-declare class AuditLogger {
-    private redis;
-    private prefix;
-    private retentionDays;
-    constructor(redis: Redis, retentionDays?: number, prefix?: string);
-    log(data: Omit<AuditLog, "id" | "timestamp">): Promise<string>;
-    get(id: string): Promise<AuditLog | null>;
-    query(filter?: AuditLogFilter): Promise<{
-        logs: AuditLog[];
-        total: number;
-    }>;
-    getRecent(limit?: number): Promise<AuditLog[]>;
-    getUserActivity(userId: string, limit?: number): Promise<AuditLog[]>;
-    getStats(startDate?: Date, endDate?: Date): Promise<{
-        totalEvents: number;
-        byAction: Record<string, number>;
-        successRate: number;
-        failedLogins: number;
-        uniqueUsers: Set<string>;
-    }>;
-    cleanup(): Promise<number>;
-    private getKeyForDate;
-    private getKeysForDateRange;
-    private matchesFilter;
-    private serializeLog;
-    private deserializeLog;
-}
-declare function createAuditContext(req: Request): {
-    ipAddress: string;
-    userAgent: string;
-};
-
 declare class InMemoryRateLimiter {
     private storage;
     private userStorage;
@@ -774,13 +570,14 @@ declare class InMemoryAuthAdapter implements AuthAdapter {
     private refreshTokens;
     private emailToUserId;
     private passwordHistory;
+    private auditLogs;
     private externalDb;
     constructor();
     connect(): Promise<void>;
     disconnect(): Promise<void>;
     createUser(data: {
         email: string;
-        passwordHash: string;
+        password: string;
         role?: UserRole;
         tenantId?: string;
     }): Promise<AuthUser>;
@@ -789,7 +586,7 @@ declare class InMemoryAuthAdapter implements AuthAdapter {
     updateUser(userId: string, data: Partial<AuthUser>): Promise<AuthUser | null>;
     deleteUser(userId: string): Promise<boolean>;
     hashPassword(password: string): Promise<string>;
-    verifyPassword(password: string, hash: string): Promise<boolean>;
+    verifyPassword(email: string, password: string): Promise<AuthUser | null>;
     createSession(userId: string, data?: {
         ipAddress?: string;
         userAgent?: string;
@@ -801,6 +598,18 @@ declare class InMemoryAuthAdapter implements AuthAdapter {
     getPasswordHistory(userId: string, count?: number): Promise<string[]>;
     isPasswordInHistory(password: string, userId: string, historyCount?: number): Promise<boolean>;
     hasAnyUsers(): Promise<boolean>;
+    findAuditLogs(filter: {
+        userId?: string;
+        action?: string | string[];
+        resource?: string;
+        success?: boolean;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        logs: any[];
+        total: number;
+    }>;
+    createAuditLog(data: any): Promise<any>;
 }
 
 declare class Auth {
@@ -857,7 +666,7 @@ declare class SQLiteAuthAdapter implements AuthAdapter {
     }>;
     createUser(data: {
         email: string;
-        passwordHash: string;
+        password: string;
         role?: UserRole;
         tenantId?: string;
     }): Promise<AuthUser>;
@@ -866,7 +675,7 @@ declare class SQLiteAuthAdapter implements AuthAdapter {
     updateUser(userId: string, data: Partial<AuthUser>): Promise<AuthUser | null>;
     deleteUser(userId: string): Promise<boolean>;
     hashPassword(password: string): Promise<string>;
-    verifyPassword(password: string, hash: string): Promise<boolean>;
+    verifyPassword(email: string, password: string): Promise<AuthUser | null>;
     createSession(userId: string, data?: {
         ipAddress?: string;
         userAgent?: string;
@@ -928,6 +737,11 @@ declare class SQLiteAuthAdapter implements AuthAdapter {
     }>;
     private rowToUser;
     private rowToSession;
+    findAuditLogs(filter: AuditLogFilter): Promise<{
+        logs: AuditLog[];
+        total: number;
+    }>;
+    createAuditLog(data: Omit<AuditLog, "id" | "timestamp">): Promise<AuditLog>;
 }
 
 type VersionStatus = 'draft' | 'published' | 'archived';
@@ -1029,6 +843,251 @@ declare function isPublished(status: VersionStatus): boolean;
 declare function isDraft(status: VersionStatus): boolean;
 declare function isArchived(status: VersionStatus): boolean;
 
+interface S3CompatibleConfig {
+    bucket?: string;
+    region?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    endpoint?: string;
+    cdnUrl?: string;
+    prefix?: string;
+}
+interface R2Config {
+    accountId?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    bucket?: string;
+    cdnUrl?: string;
+    prefix?: string;
+    publicDevUrl?: string;
+}
+interface GCSConfig {
+    bucket?: string;
+    projectId?: string;
+    clientEmail?: string;
+    privateKey?: string;
+    cdnUrl?: string;
+    prefix?: string;
+}
+interface BackblazeConfig {
+    bucket?: string;
+    accountId?: string;
+    applicationKeyId?: string;
+    applicationKey?: string;
+    cdnUrl?: string;
+    prefix?: string;
+}
+interface BunnyConfig {
+    storageZone?: string;
+    apiKey?: string;
+    cdnUrl?: string;
+    prefix?: string;
+}
+interface FTPConfig {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    secure?: boolean;
+    baseUrl?: string;
+    prefix?: string;
+}
+interface StorageConfig {
+    type: string;
+    s3: S3CompatibleConfig;
+    r2: R2Config;
+    gcs: GCSConfig;
+    digitalocean: S3CompatibleConfig;
+    backblaze: BackblazeConfig;
+    wasabi: S3CompatibleConfig;
+    bunny: BunnyConfig;
+    ftp: FTPConfig;
+    cloudinary: {
+        cloudName?: string;
+        apiKey?: string;
+        apiSecret?: string;
+        folder?: string;
+    };
+    imgix: {
+        domain?: string;
+        signKey?: string;
+    };
+    local: {
+        uploadDir?: string;
+        baseUrl?: string;
+    };
+}
+interface EmailConfig {
+    provider?: string;
+    host?: string;
+    port?: number;
+    secure?: boolean;
+    user?: string;
+    pass?: string;
+    from?: string;
+    fromName?: string;
+    replyTo?: string;
+}
+declare class ConfigService {
+    private db;
+    private cache;
+    private static readonly SENSITIVE_KEYS;
+    constructor(db: any);
+    /**
+     * Initialize the service by loading all settings from the database
+     */
+    load(): Promise<void>;
+    /**
+     * Get a settings value with environment fallback
+     */
+    get(key: string, envKey?: string, defaultValue?: string): string | undefined;
+    /**
+     * Get storage configuration
+     */
+    getStorageConfig(): StorageConfig;
+    /**
+     * Get email configuration
+     */
+    getEmailConfig(): EmailConfig;
+    /**
+     * Mask sensitive values for display
+     */
+    maskSensitive(key: string, value: string | undefined): string | undefined;
+    /**
+     * Update a setting in the database
+     */
+    set(key: string, value: string, description?: string): Promise<void>;
+}
+
+interface LocalStorageConfig {
+    uploadDir: string;
+    baseUrl?: string;
+}
+declare function createLocalStorage(config: LocalStorageConfig): StorageProvider;
+
+interface UploadOptions {
+    folder?: string;
+    filename?: string;
+    mimeType?: string;
+    metadata?: Record<string, unknown>;
+}
+interface UploadedFile {
+    id: string;
+    filename: string;
+    originalName: string;
+    mimeType: string;
+    size: number;
+    url: string;
+    thumbnailUrl?: string;
+    width?: number;
+    height?: number;
+    folder?: string;
+    provider: string;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+}
+interface ImageTransforms {
+    width?: number;
+    height?: number;
+    fit?: "clip" | "crop" | "fill" | "fillmax" | "scale" | "max" | "min";
+    format?: "webp" | "avif" | "jpeg" | "jpg" | "png" | "gif";
+    quality?: number;
+    blur?: number;
+    sharpen?: number;
+}
+interface StorageProvider {
+    name: string;
+    displayName: string;
+    supportsDynamicResize: boolean;
+    upload(file: File, options?: UploadOptions): Promise<UploadedFile>;
+    uploadFromUrl(url: string, options?: UploadOptions): Promise<UploadedFile>;
+    delete(url: string): Promise<void>;
+    rename(oldUrl: string, newKey: string): Promise<string>;
+    getImageUrl(url: string, transforms?: ImageTransforms): string;
+    generateThumbnail(file: UploadedFile, size: {
+        width: number;
+        height: number;
+    }): Promise<string>;
+    list(prefix?: string): Promise<UploadedFile[]>;
+    exists(url: string): Promise<boolean>;
+}
+
+declare function resolveProvider(configService: ConfigService): Promise<StorageProvider>;
+
+interface MediaSearchParams {
+    page?: number;
+    limit?: number;
+    search?: string;
+    type?: string;
+    folder?: string;
+    sortBy?: string;
+    sortDir?: "asc" | "desc";
+}
+interface MediaRow {
+    id: string;
+    filename: string;
+    title: string | null;
+    originalName: string;
+    mimeType: string;
+    fileSize: number;
+    width: number | null;
+    height: number | null;
+    url: string;
+    thumbnailUrl: string | null;
+    folder: string | null;
+    provider: string;
+    alt: string | null;
+    caption: string | null;
+    metadata: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+declare class MediaService {
+    private db;
+    private storage;
+    private dialect;
+    private genId;
+    private mediaTable;
+    private foldersTable;
+    constructor(db: any, storage: StorageProvider, options?: {
+        dialect?: Dialect;
+        genId?: () => string;
+    });
+    static init(db: any, options?: {
+        dialect?: Dialect;
+        genId?: () => string;
+        storageConfig?: any;
+    }): Promise<MediaService>;
+    private now;
+    private buildFindConditions;
+    private rowToMedia;
+    private sqliteRun;
+    private sqliteGet;
+    upload(file: File, folder?: string): Promise<MediaRow>;
+    delete(id: string): Promise<void>;
+    deleteFile(url: string): Promise<void>;
+    rename(id: string, newKey: string): Promise<MediaRow | null>;
+    find(params?: MediaSearchParams): Promise<{
+        docs: MediaRow[];
+        totalDocs: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+    }>;
+    update(id: string, data: {
+        title?: string;
+        alt?: string;
+        caption?: string;
+        folder?: string;
+    }): Promise<MediaRow | null>;
+    updateMany(ids: string[], data: {
+        folder?: string;
+    }): Promise<void>;
+    listFolders(): Promise<string[]>;
+    createFolder(name: string, parentPath?: string): Promise<void>;
+    deleteFolder(folder: string): Promise<void>;
+}
+
 declare function defineConfig(config: {
     collections?: CollectionConfig[] | Record<string, CollectionConfig>;
     globals?: GlobalConfig[] | Record<string, GlobalConfig>;
@@ -1045,4 +1104,4 @@ declare function defineConfig(config: {
     debug?: KyroConfig["debug"];
 }): KyroConfig;
 
-export { AbstractBaseAdapter, AccountLockout, type AdapterOptions, type AdminStylingConfig, AnalyticsPlugin, type AuditAction, type AuditLog, type AuditLogFilter, AuditLogger, Auth, AuthAdapter, AuthResult, Session as AuthSession, AuthTokenConfig, AuthUser, BaseAdapter, CSSGenerator, CollectionConfig, CommentsPlugin, type CompareVersionsOptions, ConfigValidationError, CreateArgs, type CreateVersionOptions, type DatabaseConnectionOptions, type DatabaseType, type DatabaseType$1 as DbAdapterType, DeleteArgs, type DraftPublishConfig, type DrizzleAdapterOptions, EmailTransport, Field, type FieldStyling, FindArgs, FindByIDArgs, FindResult, GlobalConfig, Hook, InMemoryAccountLockout, InMemoryAuditLogger, InMemoryAuthAdapter, InMemoryRateLimiter, JWTPayload, Kyro, type KyroAuthConfig, KyroConfig, KyroPlugin, KyroPubSub, KyroWSServer, LocalAdapter, LoginCredentials, type MongoDBAdapterOptions, PasswordPolicy, type PluginAPI, type PluginHooks, PluginManager, type PublishVersionOptions, RateLimiter, RedisAuthAdapter, RegisterData, Registry, Request$1 as Request, ReviewsPlugin, SEOPLugin, SQLiteAuthAdapter, type StylingConfig, type StylingMode, type ThemeBorderRadius, type ThemeColors, type ThemeConfig, type ThemeFonts, type ThemeShadows, type ThemeSpacing, UpdateArgs, User, UserRole, type Version, type VersionAdapter, type VersionDiff, type VersionHistoryOptions, VersionManager, type VersionPublishSchedule, type VersionStatus, WishlistPlugin, authConfig, autoBootstrap, bootstrapAdmin, collectionToCreateZod, collectionToUpdateZod, collectionToWhereZod, collectionToZod, createAdminStyling, createAuditContext, createAuth, createAuthConfig, createKyro, createLocalAdapter, createVersionManager, defaultDarkTheme, defaultFieldStyling, defaultLightTheme, defineConfig, ecommerce2026Theme, fieldToZod, generateCSSVariables, generateTailwindConfig, getBootstrapFromEnv, getDefaultDraftPublishConfig, globalToZod, isArchived, isDraft, isPublished, presetPlugins, validateCollection, validateConfig, validateFields, validateGlobal };
+export { AbstractBaseAdapter, type AdapterOptions, AnalyticsPlugin, AuditLog, AuditLogFilter, Auth, AuthAdapter, AuthResult, Session as AuthSession, AuthTokenConfig, AuthUser, BaseAdapter, CollectionConfig, CommentsPlugin, type CompareVersionsOptions, ConfigService, ConfigValidationError, CreateArgs, type CreateVersionOptions, type DatabaseConnectionOptions, type DatabaseType, type DatabaseType$1 as DbAdapterType, DeleteArgs, type DeliveryOptions, type DeliveryResult, Dialect, type DraftPublishConfig, type DrizzleAdapterOptions, type EmailConfig, EmailTransport, Field, FindArgs, FindByIDArgs, FindResult, GlobalConfig, Hook, InMemoryAccountLockout, InMemoryAuditLogger, InMemoryAuthAdapter, InMemoryRateLimiter, JWTPayload, Kyro, type KyroAuthConfig, KyroConfig, KyroPlugin, KyroPubSub, KyroWSServer, LocalAdapter, LoginCredentials, MediaService, type MongoDBAdapterOptions, PasswordPolicy, type PluginAPI, type PluginHooks, PluginManager, type PublishVersionOptions, RegisterData, Registry, Request$1 as Request, ReviewsPlugin, SEOPLugin, SQLiteAuthAdapter, Session, type StorageConfig, UpdateArgs, User, UserRole, type Version, type VersionAdapter, type VersionDiff, type VersionHistoryOptions, VersionManager, type VersionPublishSchedule, type VersionStatus, WebhookConfig, WebhookDelivery, WebhookPayload, WishlistPlugin, authConfig, autoBootstrap, bootstrapAdmin, buildDeliveryRecord, collectionToCreateZod, collectionToUpdateZod, collectionToWhereZod, collectionToZod, createAuth, createAuthConfig, createColumnsNode, createKyro, createLocalAdapter, createLocalStorage, createTestPayload, createVersionManager, defineConfig, deliverWebhook, deliverWithRetry, fieldToZod, generateWebhookSecret, getBootstrapFromEnv, getDefaultDraftPublishConfig, globalToZod, isArchived, isDraft, isPublished, normalizeRichTextDocument, normalizeRichTextValue, presetPlugins, renderRichText, resolveProvider, richTextStyles, signPayload, validateCollection, validateConfig, validateFields, validateGlobal };