@kyro-cms/core 0.12.15 → 0.12.16

package/dist/index.d.cts

@@ -0,0 +1,1246 @@
+import * as hono from 'hono';
+import * as hono_types from 'hono/types';
+import { S as StorageProvider, R as Registry } from './index-DNy8jbA2.cjs';
+export { C as ConfigService, E as EmailConfig, a as StorageConfig, c as createRegistry, g as getRegistry, r as resetRegistry, b as resolveProvider } from './index-DNy8jbA2.cjs';
+import { B as BaseAdapter, P as PluginManager, K as KyroConfig, j as User, R as Request$1, C as CollectionConfig, G as GlobalConfig, F as FindArgs, b as FindResult, c as FindByIDArgs, d as CreateArgs, e as UpdateArgs, D as DeleteArgs, f as FindVersionsArgs, g as VersionRecord, h as CreateVersionArgs } from './types-BcZiluXL.cjs';
+export { k as AccessArgs, l as AccessControl, m as AdapterConfig, A as AdminConfig, n as AnalyticsPlugin, a as AuthConfig, o as CollectionAccess, p as CollectionHooks, q as CommentsPlugin, r as CreateResult, s as FieldAccess, t as FieldHooks, u as GlobalAccess, v as GlobalHooks, H as Hook, w as HookArgs, I as ImageSize, i as KyroPlugin, x as PluginAPI, y as PluginHooks, z as ReviewsPlugin, S as SEOPlugin, U as UploadConfig, V as VersionConfig, W as WhereClause, E as WishlistPlugin, J as evaluateAccess, L as getWhereClause, M as mergeWhereClauses, N as presetPlugins, O as runFieldHooks, Q as runHooks } from './types-BcZiluXL.cjs';
+import { KyroPubSub, KyroWSServer } from './ws/index.cjs';
+export { PubSub, createWSServer } from './ws/index.cjs';
+import { W as WebhookPayload, D as DeliveryResult, a as WebhookDelivery, b as WebhookConfig, c as DeliveryOptions, d as WebhookService } from './WebhookService-i-Kl3dvf.cjs';
+export { A as ALL_WEBHOOK_EVENTS, C as CreateWebhookData, U as UpdateWebhookData, e as WEBHOOK_COLLECTION, f as WEBHOOK_DELIVERY_COLLECTION, g as WEBHOOK_EVENTS, h as WebhookEvent, i as WebhookTriggerResult, j as createWebhookService } from './WebhookService-i-Kl3dvf.cjs';
+import { F as Field } from './types-euTszc-1.cjs';
+export { A as ALL_FIELD_TYPES, a as ArrayField, B as BaseField, b as Block, e as BlocksField, v as COMPLEX_FIELD_TYPES, C as CheckboxField, f as CodeField, g as CollapsibleField, h as ColorField, D as DateField, E as EmailField, j as FieldAdmin, k as FieldType, G as GroupField, l as ImageField, J as JSONField, L as LAYOUT_FIELD_TYPES, M as MarkdownField, N as NumberField, x as PRIMITIVE_FIELD_TYPES, P as PasswordField, y as RELATIONAL_FIELD_TYPES, R as RadioField, m as RelationshipField, n as RichTextBlock, o as RichTextField, p as RowField, q as SelectField, T as TabsField, r as TextField, s as TextareaField, U as UploadField, V as ValidateOptions, O as isArrayField, Q as isBlocksField, W as isGroupField, Y as isImageField, Z as isLayoutField, _ as isNumberField, $ as isRelationshipField, a0 as isRichTextField, a1 as isSelectField, a2 as isTextField, a3 as isUploadField } from './types-euTszc-1.cjs';
+import { ZodTypeAny } from 'zod';
+export { z } from 'zod';
+export { n as normalizeRichTextValue, r as renderRichText, a as richTextStyles } from './richtext-DrhORshE.cjs';
+import { A as AbstractBaseAdapter } from './base-iyJTfH-3.cjs';
+import { Dialect } from './drizzle/index.cjs';
+export { DrizzleAdapter, PostgresAuthAdapter, collectionToDrizzleSchema, createDatabase, createDrizzleAdapter, fieldToDrizzleType, runMigrations, seedDefaultRoles } from './drizzle/index.cjs';
+export { MongoDBAdapter, MongoDBAuthAdapter, createMongoDBAdapter } from './mongodb/index.cjs';
+export { createContext, createCountProcedure, createCreateProcedure, createDeleteProcedure, createDynamicRouter, createFindByIDProcedure, createFindProcedure, createKyroServer, createUpdateProcedure } from './trpc/index.cjs';
+export { buildGraphQLSchema, createGraphQLSchema } from './graphql/index.cjs';
+export { createHonoApp, createRESTAPI } from './rest/index.cjs';
+export { A as AdminStylingConfig, C as CSSGenerator, F as FieldStyling, S as StylingConfig, a as StylingMode, T as ThemeBorderRadius, b as ThemeColors, c as ThemeConfig, d as ThemeFonts, e as ThemeShadows, f as ThemeSpacing, g as createAdminStyling, h as defaultDarkTheme, i as defaultFieldStyling, j as defaultLightTheme, k as ecommerce2026Theme, l as generateCSSVariables, m as generateTailwindConfig } from './index-Bz9JqRGI.cjs';
+import { d as AuditLog, e as AuditLogFilter, A as AuthAdapter, U as UserRole, c as AuthUser, S as Session, b as AuthTokenConfig, R as RegisterData, a as AuthResult, L as LoginCredentials, J as JWTPayload } from './types-CpjuXbe7.cjs';
+export { f as AuditAction } from './types-CpjuXbe7.cjs';
+export { TemplateConfig, allSettingsGlobals, blogCollections, blogGlobals, coreSettingsGlobals, createTemplateConfig, ecommerceCollections, ecommerceGlobals, kitchenSinkCollections, mediaCollections, minimalCollections, templateCollections } from './templates/index.cjs';
+export { default as kyro } from './integration.cjs';
+import { Redis } from 'ioredis';
+import 'ws';
+import 'drizzle-orm/postgres-js';
+import 'graphql';
+import 'astro';
+
+interface LocalStorageConfig {
+    uploadDir: string;
+    baseUrl?: string;
+}
+declare function createLocalStorage(config: LocalStorageConfig): StorageProvider;
+
+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;
+
+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 function applyCollectionOverrides(collections: CollectionConfig[], overrides?: Record<string, any>): void;
+declare class Kyro {
+    registry: Registry;
+    db: BaseAdapter;
+    pubsub: KyroPubSub;
+    webhookService: WebhookService;
+    settings?: Record<string, any>;
+    pluginManager: PluginManager;
+    private wsServer?;
+    private config;
+    constructor(config: KyroConfig);
+    init(): Promise<void>;
+    loadSettings(): Promise<Record<string, any>>;
+    loadPluginState(): Promise<void>;
+    getREST(options?: {
+        user?: User;
+        req?: Request$1;
+        tenantId?: string;
+    }): hono.Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">;
+    getGraphQL(options?: {
+        user?: User;
+        req?: Request$1;
+        tenantId?: string;
+    }): {
+        fetch: (request: any, locals?: any) => Promise<Response>;
+        schema: any;
+    };
+    getTRPC(options?: {
+        user?: User;
+        req?: Request$1;
+        tenantId?: string;
+    }): {
+        fetch: (request: any, locals?: any) => Promise<Response>;
+        router: any;
+    };
+    getWS(): KyroWSServer | undefined;
+    startWebSocket(options?: {
+        port?: number;
+        requireAuth?: boolean;
+        verifyToken?: (token: string) => Promise<any>;
+    }): Promise<KyroWSServer | null>;
+    shutdown(): Promise<void>;
+}
+declare function createKyro(config: KyroConfig): Kyro;
+
+declare class ConfigValidationError extends Error {
+    errors: string[];
+    constructor(errors: string[]);
+}
+declare function validateCollection(config: CollectionConfig): string[];
+declare function validateGlobal(config: GlobalConfig): string[];
+declare function validateFields(fields: Field[], context: string): string[];
+declare function validateConfig(collections: CollectionConfig[], globals?: GlobalConfig[]): void;
+
+declare function fieldToZod(field: Field): ZodTypeAny;
+declare function collectionToZod(collection: CollectionConfig): ZodTypeAny;
+declare function collectionToCreateZod(collection: CollectionConfig): ZodTypeAny;
+declare function collectionToUpdateZod(collection: CollectionConfig): ZodTypeAny;
+declare function collectionToWhereZod(collection: CollectionConfig): ZodTypeAny;
+declare function globalToZod(global: GlobalConfig): ZodTypeAny;
+
+type DatabaseType$1 = 'postgres' | 'sqlite' | 'mongodb';
+interface DatabaseConnectionOptions {
+    type: DatabaseType$1;
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    url?: string;
+    ssl?: boolean | Record<string, any>;
+    maxConnections?: number;
+    connectionTimeout?: number;
+}
+interface DrizzleAdapterOptions {
+    type?: 'postgres' | 'sqlite';
+    client?: any;
+    schema?: any;
+    connectionString?: string;
+    connectionOptions?: DatabaseConnectionOptions;
+}
+interface MongoDBAdapterOptions {
+    type: 'mongodb';
+    client?: any;
+    database?: string;
+    connectionString?: string;
+    connectionOptions?: DatabaseConnectionOptions;
+}
+type AdapterOptions = DrizzleAdapterOptions | MongoDBAdapterOptions;
+
+declare class LocalAdapter extends AbstractBaseAdapter {
+    private db;
+    private path?;
+    private migrations;
+    private readonly versionsTableName;
+    constructor(options: {
+        db?: any;
+        path?: string;
+    });
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private ensureTable;
+    private ensureVersionsTable;
+    private col;
+    private fieldToSQL;
+    private parseGlobalsSlug;
+    find<T>(args: FindArgs): Promise<FindResult<T>>;
+    findByID<T>(args: FindByIDArgs): Promise<T | null>;
+    create<T>(args: CreateArgs): Promise<T>;
+    update<T>(args: UpdateArgs): Promise<T>;
+    delete<T>(args: DeleteArgs): Promise<T>;
+    count(args: {
+        collection: string;
+        where?: Record<string, any>;
+        tenantId?: string;
+    }): Promise<number>;
+    findOne(args: {
+        collection: string;
+        where: Record<string, any>;
+        tenantId?: string;
+        draft?: boolean;
+    }): Promise<any>;
+    findVersions(args: FindVersionsArgs): Promise<FindResult<VersionRecord>>;
+    findVersionByID(args: {
+        collection: string;
+        versionId: string;
+        tenantId?: string;
+    }): Promise<VersionRecord | null>;
+    createVersion<T = Record<string, any>>(args: CreateVersionArgs<T>): Promise<VersionRecord<T>>;
+    updateLatestVersion<T = Record<string, any>>(args: CreateVersionArgs<T>): Promise<VersionRecord<T>>;
+    deleteVersions(args: {
+        collection: string;
+        documentId: string;
+        keepLatest?: number;
+        tenantId?: string;
+    }): Promise<void>;
+    private rowToVersion;
+    protected prepareData(data: Record<string, any>, config: CollectionConfig | GlobalConfig): Record<string, any>;
+    private rowToDoc;
+    private generateId;
+    private getMediaById;
+    private getTableNameFor;
+    migrate(): Promise<void>;
+    rollback(): Promise<void>;
+    transaction<T>(fn: (tx: any) => Promise<T>): Promise<T>;
+    getDatabase(): any;
+    exec(sql: string): void;
+    prepare(sql: string): any;
+}
+declare function createLocalAdapter(options?: {
+    db?: any;
+    path?: string;
+}): LocalAdapter;
+
+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;
+    private options;
+    constructor(options?: RedisAuthAdapterOptions);
+    private getRedis;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private userKey;
+    private sessionKey;
+    private refreshKey;
+    private userByEmailKey;
+    private passwordHistoryKey;
+    createUser(data: {
+        email: string;
+        password: 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(email: string, password: string): Promise<AuthUser | null>;
+    createSession(userId: string, data?: {
+        ipAddress?: string;
+        userAgent?: string;
+    }): Promise<Session>;
+    findSessionByToken(token: string): Promise<Session | null>;
+    findSessionByRefreshToken(refreshToken: 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;
+    private tokenKey;
+    createEmailVerificationToken(userId: string): Promise<{
+        token: string;
+        expiresAt: Date;
+    }>;
+    verifyEmailToken(token: string): Promise<{
+        success: boolean;
+        userId?: string;
+        error?: string;
+    }>;
+    createPasswordResetToken(email: string): Promise<{
+        token: string;
+        expiresAt: Date;
+        error?: string;
+    }>;
+    resetPasswordWithToken(token: string, newPassword: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    private auditLogKey;
+    private auditLogIndexKey;
+    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>;
+}
+
+interface EmailConfig {
+    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) => {
+        subject: string;
+        html: string;
+        text: string;
+    };
+    resetPassword: (link: string, userName?: string) => {
+        subject: string;
+        html: string;
+        text: string;
+    };
+    welcome: (userName?: string) => {
+        subject: string;
+        html: string;
+        text: string;
+    };
+    accountLocked: (attempts: number, duration: number, userName?: string) => {
+        subject: string;
+        html: string;
+        text: string;
+    };
+    passwordChanged: (userName?: string) => {
+        subject: string;
+        html: string;
+        text: string;
+    };
+    newLogin: (location: string, time: string, userName?: string) => {
+        subject: string;
+        html: string;
+        text: string;
+    };
+}
+declare class EmailTransport {
+    private transporter?;
+    private config;
+    private templates;
+    private transporterInitialized;
+    constructor(config: EmailConfig, templates?: Partial<EmailTemplates>);
+    private ensureTransporter;
+    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;
+}
+
+interface BootstrapConfig {
+    authAdapter?: AuthAdapter;
+    authDbPath?: string;
+    adminEmail: string;
+    adminPassword: string;
+    adminRole?: string;
+    tenantId?: string;
+    emailConfig?: EmailConfig;
+    sendWelcomeEmail?: boolean;
+}
+interface BootstrapResult {
+    success: boolean;
+    user?: AuthUser;
+    error?: string;
+}
+declare function bootstrapAdmin(config: BootstrapConfig): Promise<BootstrapResult>;
+declare function getBootstrapFromEnv(): BootstrapConfig | null;
+declare function autoBootstrap(authAdapter?: AuthAdapter): Promise<BootstrapResult | null>;
+declare function bootstrapWithRetry(config: BootstrapConfig, maxRetries?: number, retryDelayMs?: number): Promise<BootstrapResult>;
+
+interface PasswordPolicyConfig {
+    minLength: number;
+    requireUppercase: boolean;
+    requireLowercase: boolean;
+    requireNumbers: boolean;
+    requireSpecialChars: boolean;
+    preventReuse: number;
+    maxLength?: number;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+declare class PasswordPolicy {
+    private config;
+    constructor(config?: Partial<PasswordPolicyConfig>);
+    validate(password: string): ValidationResult;
+    checkReuse(passwordHash: string, history: string[], verifyFn: (password: string, hash: string) => Promise<boolean>): Promise<ValidationResult>;
+    isInHistory(password: string, history: string[], verifyFn: (password: string, hash: string) => Promise<boolean>): Promise<boolean>;
+    generatePassword(length?: number): string;
+    getStrength(password: string): {
+        score: number;
+        label: string;
+        feedback: string[];
+    };
+    setConfig(config: Partial<PasswordPolicyConfig>): void;
+    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;
+}
+
+declare class InMemoryRateLimiter {
+    private storage;
+    private userStorage;
+    private limits;
+    private userLimits;
+    constructor(limits?: Record<string, RateLimitConfig>, userLimits?: Record<string, RateLimitConfig>);
+    private getKey;
+    private getUserKey;
+    private cleanupOldEntries;
+    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;
+}
+
+declare class InMemoryAccountLockout {
+    private storage;
+    private history;
+    private config;
+    constructor(config?: Partial<LockoutConfig>);
+    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;
+}
+
+declare class InMemoryAuditLogger {
+    private logs;
+    private retentionDays;
+    constructor(retentionDays?: number);
+    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 cleanupOldLogs;
+}
+
+interface AuthRoutesConfig {
+    redis: AuthAdapter;
+    jwtSecret?: string;
+    jwtExpiresIn?: string;
+    jwtIssuer?: string;
+    jwtAudience?: string;
+    email?: EmailTransport;
+    passwordPolicy?: PasswordPolicy;
+    lockout?: InMemoryAccountLockout;
+    rateLimiter?: InMemoryRateLimiter;
+    auditLogger?: InMemoryAuditLogger;
+    baseUrl?: string;
+    emailVerificationRequired?: boolean;
+}
+declare class AuthRoutes {
+    private authAdapter;
+    private email?;
+    private passwordPolicy;
+    private lockout?;
+    private rateLimiter?;
+    private auditLogger?;
+    private baseUrl;
+    private emailVerificationRequired;
+    constructor(config: AuthRoutesConfig);
+    register(req: Request): Promise<Response>;
+    login(req: Request): Promise<Response>;
+    logout(req: Request): Promise<Response>;
+    refresh(req: Request): Promise<Response>;
+    me(req: Request): Promise<Response>;
+    changePassword(req: Request): Promise<Response>;
+    forgotPassword(req: Request): Promise<Response>;
+    verifyEmail(req: Request): Promise<Response>;
+    private recordFailedLogin;
+    private sanitizeUser;
+    private jsonResponse;
+    listSessions(req: Request): Promise<Response>;
+    revokeSession(req: Request, sessionId: string): Promise<Response>;
+    revokeOtherSessions(req: Request): Promise<Response>;
+    renameSession(req: Request, sessionId: string): Promise<Response>;
+    refreshSession(req: Request): Promise<Response>;
+    private errorResponse;
+    private rateLimitResponse;
+}
+
+type DatabaseType = "sqlite" | "postgres" | "mongodb" | "memory";
+interface KyroAuthConfig {
+    authAdapter: AuthAdapter;
+    databaseType?: string;
+    email?: EmailTransport;
+    passwordPolicy: PasswordPolicy;
+    lockout?: InMemoryAccountLockout;
+    rateLimiter?: InMemoryRateLimiter;
+    auditLogger?: InMemoryAuditLogger;
+    routes: AuthRoutes;
+}
+declare function createAuthConfig(databaseType?: string, db?: any): Promise<KyroAuthConfig>;
+declare const authConfig: Promise<any>;
+
+declare class InMemoryAuthAdapter implements AuthAdapter {
+    private users;
+    private sessions;
+    private refreshTokens;
+    private emailToUserId;
+    private passwordHistory;
+    private emailVerificationTokens;
+    private passwordResetTokens;
+    private auditLogs;
+    private externalDb;
+    constructor();
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    createUser(data: {
+        email: string;
+        password: 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(email: string, password: string): Promise<AuthUser | null>;
+    createSession(userId: string, data?: {
+        ipAddress?: string;
+        userAgent?: string;
+    }): Promise<Session>;
+    findSessionByToken(token: string): Promise<Session | null>;
+    findSessionByRefreshToken(refreshToken: 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>;
+    createEmailVerificationToken(userId: string): Promise<{
+        token: string;
+        expiresAt: Date;
+    }>;
+    verifyEmailToken(token: string): Promise<{
+        success: boolean;
+        userId?: string;
+        error?: string;
+    }>;
+    createPasswordResetToken(email: string): Promise<{
+        token: string;
+        expiresAt: Date;
+        error?: string;
+    }>;
+    resetPasswordWithToken(token: string, newPassword: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    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 {
+    private adapter;
+    private config;
+    constructor(adapter: AuthAdapter, config: AuthTokenConfig);
+    register(data: RegisterData): Promise<AuthResult>;
+    login(credentials: LoginCredentials): Promise<AuthResult>;
+    logout(token: string): Promise<void>;
+    refreshToken(refreshToken: string): Promise<AuthResult>;
+    verifyToken(token: string): Promise<JWTPayload | null>;
+    getUserFromToken(token: string): Promise<AuthUser | null>;
+    changePassword(userId: string, currentPassword: string, newPassword: string): Promise<AuthResult>;
+    resetPassword(email: string, newPassword: string): Promise<AuthResult>;
+    sendEmailVerification(userId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    verifyEmail(token: string): Promise<{
+        success: boolean;
+        userId?: string;
+        error?: string;
+    }>;
+    requestPasswordReset(email: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    resetPasswordWithToken(token: string, newPassword: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    deleteAccount(userId: string): Promise<AuthResult>;
+    private createSessionForUser;
+    private generateToken;
+    private hashPassword;
+    private parseExpiresIn;
+}
+declare function createAuth(adapter: AuthAdapter, config: AuthTokenConfig): Auth;
+
+interface SQLiteAuthAdapterOptions {
+    path?: string;
+    db?: any;
+    saltRounds?: number;
+    busyTimeout?: number;
+    walAutoCheckpoint?: number;
+    cacheSize?: number;
+    mmapSize?: number;
+}
+declare class SQLiteAuthAdapter implements AuthAdapter {
+    private db;
+    private path;
+    private saltRounds;
+    private externalDb;
+    private busyTimeout;
+    private walAutoCheckpoint;
+    private cacheSize;
+    private mmapSize;
+    private preparedStatements;
+    constructor(options?: SQLiteAuthAdapterOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private ensureConnected;
+    private ensureTables;
+    private prepareStatements;
+    private stmt;
+    cleanupExpiredSessions(): Promise<number>;
+    cleanupOldAuditLogs(retentionDays?: number): Promise<number>;
+    getStats(): Promise<{
+        userCount: number;
+        activeSessionCount: number;
+        auditLogCount: number;
+    }>;
+    createUser(data: {
+        email: string;
+        password: string;
+        name?: string;
+        role?: UserRole;
+        avatar?: string;
+        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(email: string, password: string): Promise<AuthUser | null>;
+    createSession(userId: string, data?: {
+        ipAddress?: string;
+        userAgent?: string;
+    }): Promise<Session>;
+    findSessionByToken(token: string): Promise<Session | null>;
+    findSessionByRefreshToken(refreshToken: string): Promise<Session | null>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    deleteUserSessions(userId: string): Promise<number>;
+    hasAnyUsers(): Promise<boolean>;
+    findUsers(options?: {
+        page?: number;
+        limit?: number;
+        search?: string;
+    }): Promise<{
+        users: AuthUser[];
+        total: number;
+    }>;
+    addPasswordToHistory(userId: string, passwordHash: string): Promise<void>;
+    getPasswordHistory(userId: string, count?: number): Promise<string[]>;
+    isPasswordInHistory(password: string, userId: string, historyCount?: number): Promise<boolean>;
+    recordFailedAttempt(userId: string): Promise<void>;
+    resetAttempts(userId: string): Promise<void>;
+    checkLockout(userId: string): Promise<{
+        locked: boolean;
+        attemptsRemaining: number;
+        lockedUntil?: Date;
+        totalAttempts: number;
+    }>;
+    logAudit(data: {
+        action: string;
+        userId?: string;
+        userEmail?: string;
+        role?: string;
+        resource: string;
+        resourceId?: string;
+        ipAddress?: string;
+        userAgent?: string;
+        success: boolean;
+        error?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<string>;
+    queryAuditLogs(options?: {
+        action?: string;
+        userId?: string;
+        resource?: string;
+        success?: boolean;
+        startDate?: Date;
+        endDate?: Date;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        logs: Array<{
+            id: string;
+            timestamp: Date;
+            action: string;
+            userId?: string;
+            userEmail?: string;
+            resource: string;
+            resourceId?: string;
+            ipAddress?: string;
+            userAgent?: string;
+            success: boolean;
+            error?: string;
+            metadata?: Record<string, unknown>;
+        }>;
+        total: number;
+    }>;
+    private rowToUser;
+    private rowToSession;
+    findAuditLogs(filter: AuditLogFilter): Promise<{
+        logs: AuditLog[];
+        total: number;
+    }>;
+    createAuditLog(data: Omit<AuditLog, "id" | "timestamp">): Promise<AuditLog>;
+    createEmailVerificationToken(userId: string): Promise<{
+        token: string;
+        expiresAt: Date;
+    }>;
+    verifyEmailToken(token: string): Promise<{
+        success: boolean;
+        userId?: string;
+        error?: string;
+    }>;
+    createPasswordResetToken(email: string): Promise<{
+        token: string;
+        expiresAt: Date;
+        error?: string;
+    }>;
+    resetPasswordWithToken(token: string, newPassword: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+
+type VersionStatus = 'draft' | 'published' | 'archived';
+interface Version<T = Record<string, unknown>> {
+    id: string;
+    collection: string;
+    documentId: string;
+    version: number;
+    status: VersionStatus;
+    data: T;
+    createdBy: string;
+    createdAt: Date;
+    publishedAt?: Date;
+    changeDescription?: string;
+}
+interface VersionDiff {
+    field: string;
+    oldValue: unknown;
+    newValue: unknown;
+}
+interface VersionHistoryOptions {
+    collection: string;
+    documentId: string;
+    limit?: number;
+    offset?: number;
+}
+interface CreateVersionOptions<T = Record<string, unknown>> {
+    collection: string;
+    documentId: string;
+    data: T;
+    status?: VersionStatus;
+    createdBy: string;
+    changeDescription?: string;
+}
+interface PublishVersionOptions {
+    collection: string;
+    documentId: string;
+    versionId: string;
+    publishedBy: string;
+}
+interface CompareVersionsOptions {
+    collection: string;
+    documentId: string;
+    versionA: string | number;
+    versionB: string | number;
+}
+interface VersionAdapter {
+    createVersion<T>(options: CreateVersionOptions<T>): Promise<Version<T>>;
+    getVersion<T>(collection: string, versionId: string): Promise<Version<T> | null>;
+    getVersions<T>(options: VersionHistoryOptions): Promise<Version<T>[]>;
+    getLatestVersion<T>(collection: string, documentId: string): Promise<Version<T> | null>;
+    getPublishedVersion<T>(collection: string, documentId: string): Promise<Version<T> | null>;
+    publishVersion(options: PublishVersionOptions): Promise<void>;
+    revertToVersion<T>(options: {
+        collection: string;
+        documentId: string;
+        versionId: string;
+        userId: string;
+    }): Promise<Version<T>>;
+    compareVersions<T>(options: CompareVersionsOptions): Promise<VersionDiff[]>;
+    deleteVersions(collection: string, documentId: string): Promise<void>;
+}
+interface DraftPublishConfig {
+    enabled?: boolean;
+    draftsEnabled?: boolean;
+    publishEnabled?: boolean;
+    scheduleEnabled?: boolean;
+    versioningEnabled?: boolean;
+    maxVersionsPerDocument?: number;
+    autoPublish?: boolean;
+    requirePublishPermission?: boolean;
+}
+interface VersionPublishSchedule {
+    versionId: string;
+    scheduledFor: Date;
+    status: 'pending' | 'published' | 'cancelled';
+}
+declare function getDefaultDraftPublishConfig(): Required<DraftPublishConfig>;
+
+declare class VersionManager<T = Record<string, unknown>> {
+    private adapter;
+    private config;
+    constructor(adapter: VersionAdapter, config?: DraftPublishConfig);
+    createVersion(options: Omit<CreateVersionOptions<T>, 'version'>): Promise<Version<T>>;
+    publishVersion(options: PublishVersionOptions): Promise<void>;
+    unpublishDocument(collection: string, documentId: string): Promise<void>;
+    revertToVersion(collection: string, documentId: string, versionId: string, userId: string): Promise<Version<T>>;
+    getVersionHistory(collection: string, documentId: string, limit?: number, offset?: number): Promise<Version<T>[]>;
+    compareTwoVersions(collection: string, documentId: string, versionA: string | number, versionB: string | number): Promise<VersionDiff[]>;
+    getLatestDraft(collection: string, documentId: string): Promise<Version<T> | null>;
+    getPublishedVersion(collection: string, documentId: string): Promise<Version<T> | null>;
+    getVersion(collection: string, versionId: string): Promise<Version<T> | null>;
+    schedulePublish(collection: string, documentId: string, versionId: string, scheduledFor: Date): Promise<void>;
+    deleteVersionHistory(collection: string, documentId: string): Promise<void>;
+    private pruneOldVersions;
+}
+declare function createVersionManager<T>(adapter: VersionAdapter, config?: DraftPublishConfig): VersionManager<T>;
+declare function isPublished(status: VersionStatus): boolean;
+declare function isDraft(status: VersionStatus): boolean;
+declare function isArchived(status: VersionStatus): boolean;
+
+type ExtendedDialect = Dialect | "mongodb";
+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?: ExtendedDialect;
+        genId?: () => string;
+    });
+    static init(db: any, options?: {
+        dialect?: ExtendedDialect;
+        genId?: () => string;
+        storageConfig?: any;
+    }): Promise<MediaService>;
+    private ensureTables;
+    private now;
+    private buildFindConditions;
+    private rowToMedia;
+    static resolveMediaUrl(url: string | null | undefined, origin?: string): string | null;
+    private sqliteRun;
+    private sqliteGet;
+    upload(file: File, folder?: string, origin?: string): Promise<MediaRow>;
+    uploadFromUrl(url: string, folder?: string, origin?: string): Promise<MediaRow>;
+    delete(id: string, origin?: string): Promise<void>;
+    deleteFile(url: string): Promise<void>;
+    rename(id: string, newKey: string, origin?: string): Promise<MediaRow | null>;
+    findById(id: string, origin?: string): Promise<MediaRow | null>;
+    find(params?: MediaSearchParams, origin?: string): Promise<{
+        docs: MediaRow[];
+        totalDocs: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+    }>;
+    update(id: string, data: {
+        title?: string;
+        alt?: string;
+        caption?: string;
+        folder?: string;
+        metadata?: any;
+        originalName?: string;
+    }, origin?: 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>;
+    adapter: KyroConfig["adapter"];
+    plugins?: KyroConfig["plugins"];
+    auth?: KyroConfig["auth"];
+    cors?: KyroConfig["cors"];
+    admin?: KyroConfig["admin"];
+    upload?: KyroConfig["upload"];
+    graphQL?: KyroConfig["graphQL"];
+    typescript?: KyroConfig["typescript"];
+    localization?: KyroConfig["localization"];
+    rateLimit?: KyroConfig["rateLimit"];
+    debug?: KyroConfig["debug"];
+}): KyroConfig;
+declare const defineKyroConfig: typeof defineConfig;
+
+interface SeoTagsOptions {
+    siteSettings: any;
+    seoSettings?: any;
+    title?: string;
+    description?: string;
+    image?: string;
+    url?: string;
+}
+/**
+ * Generates standard SEO meta tags based on global site settings and page overrides.
+ */
+declare function generateSeoTags(options: SeoTagsOptions): string;
+/**
+ * Generates analytics script tags based on global site settings.
+ */
+declare function generateAnalyticsTags(siteSettings: any): string;
+
+interface SocialLink {
+    platform: string;
+    url: string;
+    label: string;
+}
+declare function getSocialLinksFromSettings(socialSettings: any): SocialLink[];
+declare function getSocialLinks(db: BaseAdapter, options?: {
+    draft?: boolean;
+}): Promise<SocialLink[]>;
+
+interface StoreConfig {
+    storeName?: string;
+    storeEmail?: string;
+    storePhone?: string;
+    address?: {
+        street?: string;
+        city?: string;
+        state?: string;
+        postalCode?: string;
+        country?: string;
+    };
+    currency?: {
+        code?: string;
+        symbol?: string;
+        position?: "before" | "after";
+        decimals?: number;
+    };
+    tax?: {
+        enabled?: boolean;
+        rate?: number;
+        includedInPrice?: boolean;
+        taxId?: string;
+    };
+    shipping?: {
+        enableLocalPickup?: boolean;
+        flatRate?: number;
+        freeShippingThreshold?: number;
+    };
+    orders?: {
+        orderNumberPrefix?: string;
+        allowGuestCheckout?: boolean;
+        requirePhone?: boolean;
+    };
+}
+declare function getStoreConfigFromSettings(settings: any): StoreConfig;
+declare function getStoreConfig(db: BaseAdapter, options?: {
+    draft?: boolean;
+}): Promise<StoreConfig>;
+
+interface PaymentConfig {
+    testMode?: boolean;
+    provider?: "stripe" | "paypal" | "square" | "manual";
+    stripe?: {
+        enabled?: boolean;
+        publishableKey?: string;
+        secretKey?: string;
+        webhookSecret?: string;
+    };
+    paypal?: {
+        enabled?: boolean;
+        clientId?: string;
+        clientSecret?: string;
+        mode?: "sandbox" | "live";
+    };
+    square?: {
+        enabled?: boolean;
+        applicationId?: string;
+        accessToken?: string;
+        locationId?: string;
+    };
+    methods?: {
+        cod?: boolean;
+        bankTransfer?: boolean;
+        cash?: boolean;
+        check?: boolean;
+    };
+    bankTransfer?: {
+        bankName?: string;
+        accountName?: string;
+        accountNumber?: string;
+        routingNumber?: string;
+        iban?: string;
+        swift?: string;
+    };
+}
+declare function getPaymentConfigFromSettings(settings: any): PaymentConfig;
+declare function getPaymentConfig(db: BaseAdapter, options?: {
+    draft?: boolean;
+}): Promise<PaymentConfig>;
+
+type StorageAdapter = 'indexeddb' | 'fs' | 'redis' | 'sqlite' | 'postgres';
+type Environment = 'browser' | 'node';
+interface EncryptionConfig {
+    enabled: boolean;
+    algorithm?: 'AES-256-GCM' | 'ChaCha20-Poly1305';
+}
+interface StorageConfig {
+    environment: Environment;
+    adapter?: StorageAdapter;
+    connectionString?: string;
+    encryption?: EncryptionConfig;
+}
+interface StorageOptions {
+    namespace?: string;
+    ttl?: number;
+}
+type CreateStorageResult = {
+    storage: {
+        getItem: (name: string) => string | null | Promise<string | null>;
+        setItem: (name: string, value: string) => void | Promise<void>;
+        removeItem: (name: string) => void | Promise<void>;
+    };
+    cleanup?: () => Promise<void>;
+};
+
+declare function createStorage(config: StorageConfig): Promise<CreateStorageResult & {
+    storage: _StateStorage;
+}>;
+type _StateStorage = {
+    getItem: (name: string) => string | null | Promise<string | null>;
+    setItem: (name: string, value: string) => void | Promise<void>;
+    removeItem: (name: string) => void | Promise<void>;
+};
+declare function createAuthStorage(config: StorageConfig): Promise<CreateStorageResult>;
+
+declare function setDbAdapter(adapter: any): void;
+declare function loadSecrets(): Promise<void>;
+declare function getAppSecret(): string;
+declare function getEncryptionKey(): string;
+declare function getSessionConfig(): {
+    maxAge: number;
+    maxSessionsPerUser: number;
+};
+
+export { AbstractBaseAdapter, AccountLockout, type AdapterOptions, AuditLog, AuditLogFilter, AuditLogger, Auth, AuthAdapter, AuthResult, Session as AuthSession, AuthTokenConfig, AuthUser, BaseAdapter, CollectionConfig, type CompareVersionsOptions, ConfigValidationError, CreateArgs, type CreateStorageResult, type CreateVersionOptions, type DatabaseConnectionOptions, type DatabaseType, type DatabaseType$1 as DbAdapterType, DeleteArgs, DeliveryOptions, DeliveryResult, Dialect, type DraftPublishConfig, type DrizzleAdapterOptions, EmailTransport, type EncryptionConfig, type Environment, Field, FindArgs, FindByIDArgs, FindResult, GlobalConfig, InMemoryAccountLockout, InMemoryAuditLogger, InMemoryAuthAdapter, InMemoryRateLimiter, JWTPayload, Kyro, type KyroAuthConfig, KyroConfig, KyroPubSub, KyroWSServer, LocalAdapter, LoginCredentials, MediaService, type MongoDBAdapterOptions, PasswordPolicy, type PaymentConfig, PluginManager, type PublishVersionOptions, RateLimiter, RedisAuthAdapter, RegisterData, Registry, Request$1 as Request, SQLiteAuthAdapter, type SeoTagsOptions, Session, type SocialLink, type StorageAdapter, type StorageOptions, type StoreConfig, UpdateArgs, User, UserRole, type Version, type VersionAdapter, type VersionDiff, type VersionHistoryOptions, VersionManager, type VersionPublishSchedule, type VersionStatus, WebhookConfig, WebhookDelivery, WebhookPayload, WebhookService, applyCollectionOverrides, authConfig, autoBootstrap, bootstrapAdmin, bootstrapWithRetry, buildDeliveryRecord, collectionToCreateZod, collectionToUpdateZod, collectionToWhereZod, collectionToZod, createAuditContext, createAuth, createAuthConfig, createAuthStorage, createKyro, createLocalAdapter, createLocalStorage, createStorage, createTestPayload, createVersionManager, defineConfig, defineKyroConfig, deliverWebhook, deliverWithRetry, fieldToZod, generateAnalyticsTags, generateSeoTags, generateWebhookSecret, getAppSecret, getBootstrapFromEnv, getDefaultDraftPublishConfig, getEncryptionKey, getPaymentConfig, getPaymentConfigFromSettings, getSessionConfig, getSocialLinks, getSocialLinksFromSettings, getStoreConfig, getStoreConfigFromSettings, globalToZod, isArchived, isDraft, isPublished, loadSecrets, setDbAdapter, signPayload, validateCollection, validateConfig, validateFields, validateGlobal };