import * as hono from 'hono';
import * as hono_types from 'hono/types';
import { R as Registry } from './index-DjhIVdL9.js';
export { c as createRegistry, g as getRegistry, r as resetRegistry } from './index-DjhIVdL9.js';
import { a as StorageProvider, C as CollectionConfig, G as GlobalConfig, B as BaseAdapter, P as PluginManager, h as KyroConfig, i as User, R as Request$1, F as FindArgs, b as FindResult, c as FindByIDArgs, d as CreateArgs, U as UpdateArgs, D as DeleteArgs, e as FindOneArgs, f as FindVersionsArgs, V as VersionRecord, g as CreateVersionArgs } from './types-M2BhNVof.js';
export { A as AccessArgs, j as AccessControl, k as AdapterConfig, l as AdminConfig, m as AuthConfig, n as CollectionAccess, o as CollectionHooks, p as ConfigService, q as CreateResult, E as EmailConfig, r as ExperimentalConfig, s as FieldAccess, t as FieldHooks, u as GlobalAccess, v as GlobalHooks, H as HierarchyConfig, w as Hook, x as HookArgs, I as ImageSize, K as KyroPlugin, O as OrganizationConfig, y as PluginAPI, z as PluginHooks, J as ProjectConfig, L as SEOPlugin, M as SmartViewConfig, S as StorageConfig, N as UploadConfig, Q as VersionConfig, W as WhereClause, X as WishlistPlugin, Y as evaluateAccess, Z as getWhereClause, _ as mergeWhereClauses, $ as presetPlugins, a0 as resolveProvider, a1 as runFieldHooks, a2 as runHooks } from './types-M2BhNVof.js';
import { KyroPubSub, KyroWSServer } from './ws/index.js';
export { PubSub, createWSServer } from './ws/index.js';
import { W as WebhookPayload, D as DeliveryResult, a as WebhookDelivery, b as WebhookConfig, c as DeliveryOptions, d as WebhookService } from './WebhookService-Y-X6GgLL.js';
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-Y-X6GgLL.js';
import { F as Field } from './types-C3QFX0l6.js';
export { A as ALL_FIELD_TYPES, b as ArrayField, B as BaseField, c as Block, f as BlocksField, C as COMPLEX_FIELD_TYPES, h as CheckboxField, i as CodeField, j as CollapsibleField, k as ColorField, D as DateField, E as EmailField, o as FieldAdmin, p as FieldType, G as GroupField, q as ImageField, J as JSONField, L as LAYOUT_FIELD_TYPES, M as MarkdownField, N as NumberField, P as PRIMITIVE_FIELD_TYPES, s as PasswordField, R as RELATIONAL_FIELD_TYPES, t as RadioField, u as RelationshipField, v as RichTextBlock, w as RichTextField, x as RowField, y as SelectField, T as TabsField, z as TextField, O as TextareaField, U as UploadField, V as ValidateOptions, W as isArrayField, X as isBlocksField, Z as isGroupField, $ as isImageField, a0 as isLayoutField, a1 as isNumberField, a2 as isRelationshipField, a3 as isRichTextField, a4 as isSelectField, a5 as isTextField, a6 as isUploadField } from './types-C3QFX0l6.js';
import { ZodTypeAny, z } from 'zod';
export { z } from 'zod';
export { n as normalizeRichTextValue, r as renderRichText, a as richTextStyles } from './richtext-DrhORshE.js';
import { A as AuditLog, a as AuditLogFilter, b as AbstractBaseAdapter, c as AuthAdapter, U as UserRole, d as AuthUser, S as Session, e as AuthTokenConfig, R as RegisterData, f as AuthResult, L as LoginCredentials, J as JWTPayload } from './base-BAApLdlP.js';
export { g as AuditAction } from './base-BAApLdlP.js';
export { A as AdapterOptions, D as DatabaseConnectionOptions, a as DbAdapterType, b as DrizzleAdapterOptions, M as MongoDBAdapter, c as MongoDBAdapterOptions, d as MongoDBAuthAdapter, e as createMongoDBAdapter, g as getMongoClient, f as getMongoDb } from './index-94nxUkEf.js';
import { Dialect } from './drizzle/index.js';
export { DrizzleAdapter, PostgresAuthAdapter, collectionToDrizzleSchema, createDatabase, createDrizzleAdapter, fieldToDrizzleType, runMigrations, seedDefaultRoles } from './drizzle/index.js';
export { createContext, createCountProcedure, createCreateProcedure, createDeleteProcedure, createDynamicRouter, createFindByIDProcedure, createFindProcedure, createKyroServer, createUpdateProcedure } from './trpc/index.js';
export { buildGraphQLSchema, createGraphQLSchema } from './graphql/index.js';
export { createKyroApp, createRESTAPI } from './rest/index.js';
export { TemplateConfig, allGlobalSettings, blogCollections, coreGlobalSettings, createTemplateConfig, ecommerceCollections, ecommerceGlobals, kitchenSinkCollections, mediaCollections, minimalCollections, templateCollections } from './templates/index.js';
export { default as kyro } from './integration.js';
import { Loader } from 'astro/loaders';
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 const FIELD_DEFINITION_KEYS: Set<string>;
declare function isFieldOverrideDefinition(obj: any): boolean;
declare function flattenFieldOverrides(overrides: Record<string, any>, prefix?: string): Record<string, any>;
declare function updateFieldByPath(fields: any[], path: string, updates: Record<string, any>, allowAppend?: boolean): boolean;
declare function applyBlocksOverrides(fields: any[], rawBlocks: any): void;
declare function applyTabsOverrides(fields: any[], rawTabs: any): void;
declare function applyCollectionOverrides(collections: CollectionConfig[], overrides?: Record<string, any>): void;
declare function applyGlobalOverrides(globals: GlobalConfig[], overrides?: Record<string, any>): void;

type Redis$2 = any;

declare class AuditLogger {
    private redis;
    private prefix;
    private retentionDays;
    constructor(redis: Redis$2, 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 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;
    }): Promise<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 function createKyroHandler(config: KyroConfig): (req: Request$1 | any, context?: any) => Promise<Response>;

interface BrandConfig$1 {
    siteName?: string;
    logoUrl?: string;
    logoDarkUrl?: string;
    appUrl?: string;
    primaryColor?: string;
    address?: string;
}
interface BaseEmailOptions {
    brand?: BrandConfig$1;
    title: string;
    badge?: string;
    previewText?: string;
    bodyHtml: string;
    ctaText?: string;
    ctaUrl?: string;
    secondaryCtaText?: string;
    secondaryCtaUrl?: string;
}
declare function renderBaseLayout(options: BaseEmailOptions): string;

declare function renderVerifyEmail(link: string, userName?: string, brandConfig?: BrandConfig$1): {
    subject: string;
    html: string;
    text: string;
};

declare function renderResetPassword(link: string, userName?: string, brandConfig?: BrandConfig$1): {
    subject: string;
    html: string;
    text: string;
};

declare function renderWelcome(userName?: string, appUrl?: string, brandConfig?: BrandConfig$1): {
    subject: string;
    html: string;
    text: string;
};

declare function renderPasswordChanged(userName?: string, brandConfig?: BrandConfig$1, ipAddress?: string, device?: string): {
    subject: string;
    html: string;
    text: string;
};

declare function renderMagicLink(link: string, code?: string, userName?: string, brandConfig?: BrandConfig$1): {
    subject: string;
    html: string;
    text: string;
};

declare function renderAccountLocked(attempts: number, durationMinutes: number, userName?: string, brandConfig?: BrandConfig$1, ipAddress?: string, device?: string): {
    subject: string;
    html: string;
    text: string;
};

declare function renderUserInvite(inviteUrl: string, roleName?: string, inviterName?: string, brandConfig?: BrandConfig$1): {
    subject: string;
    html: string;
    text: string;
};

declare function renderNewLogin(location: string, time: string, userName?: string, brandConfig?: BrandConfig$1, device?: string): {
    subject: string;
    html: string;
    text: string;
};

declare function renderOrderConfirmation(orderId: string, customerName: string | undefined, totalAmount: string, trackingUrl?: string, brandConfig?: BrandConfig$1): {
    subject: string;
    html: string;
    text: string;
};

declare function renderOrderShipped(orderId: string, customerName: string | undefined, trackingNumber: string, trackingUrl: string, brandConfig?: BrandConfig$1): {
    subject: string;
    html: string;
    text: string;
};

declare function renderOrderDelivered(orderId: string, customerName: string | undefined, reviewUrl: string, brandConfig?: BrandConfig$1): {
    subject: string;
    html: string;
    text: string;
};

declare function renderOrderRefunded(orderId: string, customerName: string | undefined, refundAmount: string, brandConfig?: BrandConfig$1): {
    subject: string;
    html: string;
    text: string;
};

declare function renderAbandonedCart(customerName: string | undefined, checkoutUrl: string, brandConfig?: BrandConfig$1): {
    subject: string;
    html: string;
    text: string;
};

/**
 * Returns complete EmailTemplates registry for EmailTransport
 */
declare function getEmailTemplates(brandConfig?: BrandConfig$1): {
    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, appUrl?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    passwordChanged: (userName?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    magicLink: (link: string, code?: string, userName?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    accountLocked: (attempts: number, durationMinutes: number, userName?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    newLogin: (location: string, time: string, userName?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    userInvite: (inviteUrl: string, roleName?: string, inviterName?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    orderConfirmation: (orderId: string, customerName?: string, totalAmount?: string, trackingUrl?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    orderShipped: (orderId: string, customerName?: string, trackingNumber?: string, trackingUrl?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    orderDelivered: (orderId: string, customerName?: string, reviewUrl?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    orderRefunded: (orderId: string, customerName?: string, refundAmount?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    abandonedCart: (customerName?: string, checkoutUrl?: string) => {
        subject: string;
        html: string;
        text: string;
    };
};

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;

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 resolveCol;
    private col;
    private fieldToSQL;
    private parseGlobalsSlug;
    private buildWhere;
    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: FindOneArgs): 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 NeonAdapterOptions {
    connectionString: string;
}
/**
 * Edge-Native Neon HTTP PostgreSQL Database Adapter for Kyro CMS.
 * Uses Web-standard `fetch` HTTP requests to execute SQL queries on V8 Edge Isolates.
 */
declare class NeonAdapter extends AbstractBaseAdapter {
    private connectionString;
    constructor(options: NeonAdapterOptions);
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    query<T = any>(sql: string, params?: any[]): Promise<T[]>;
    find(args: any): Promise<any>;
    findByID(args: any): Promise<any>;
    create(args: any): Promise<any>;
    update(args: any): Promise<any>;
    delete(args: any): Promise<any>;
    count(args: {
        collection: string;
        where?: Record<string, any>;
        tenantId?: string;
    }): Promise<number>;
    findOne(args: FindOneArgs): Promise<any>;
    findVersions(args: any): Promise<any>;
    findVersionByID(args: {
        collection: string;
        versionId: string;
        tenantId?: string;
    }): Promise<any>;
    createVersion<T = Record<string, any>>(args: any): Promise<any>;
    updateLatestVersion<T = Record<string, any>>(args: any): Promise<any>;
    deleteVersions(args: {
        collection: string;
        documentId: string;
        keepLatest?: number;
        tenantId?: string;
    }): Promise<void>;
}
declare function createNeonAdapter(options: NeonAdapterOptions): NeonAdapter;

interface TursoAdapterOptions {
    url: string;
    authToken?: string;
}
/**
 * Edge-Native Turso / libSQL HTTP Database Adapter for Kyro CMS.
 * Executes SQL queries over Web-standard `fetch` HTTP requests on V8 Edge Isolates.
 */
declare class TursoAdapter extends AbstractBaseAdapter {
    private url;
    private authToken?;
    constructor(options: TursoAdapterOptions);
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    query<T = any>(sql: string, params?: any[]): Promise<T[]>;
    find(args: any): Promise<any>;
    findByID(args: any): Promise<any>;
    create(args: any): Promise<any>;
    update(args: any): Promise<any>;
    delete(args: any): Promise<any>;
    count(args: {
        collection: string;
        where?: Record<string, any>;
        tenantId?: string;
    }): Promise<number>;
    findOne(args: FindOneArgs): Promise<any>;
    findVersions(args: any): Promise<any>;
    findVersionByID(args: {
        collection: string;
        versionId: string;
        tenantId?: string;
    }): Promise<any>;
    createVersion<T = Record<string, any>>(args: any): Promise<any>;
    updateLatestVersion<T = Record<string, any>>(args: any): Promise<any>;
    deleteVersions(args: {
        collection: string;
        documentId: string;
        keepLatest?: number;
        tenantId?: string;
    }): Promise<void>;
}
declare function createTursoAdapter(options: TursoAdapterOptions): TursoAdapter;

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;
    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 BrandConfig {
    siteName?: string;
    logoUrl?: string;
    logoDarkUrl?: string;
    appUrl?: string;
}
interface EmailConfig {
    provider: "smtp" | "resend" | "sendgrid" | "mailgun" | "ses";
    from: string;
    brand?: BrandConfig;
    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, brandConfig?: any, ipAddress?: string, device?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    passwordChanged: (userName?: string, brandConfig?: any, ipAddress?: string, device?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    newLogin: (location: string, time: string, userName?: string, brandConfig?: any, device?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    magicLink: (link: string, code?: string, userName?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    userInvite: (inviteUrl: string, roleName?: string, inviterName?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    orderConfirmation: (orderId: string, customerName?: string, totalAmount?: string, trackingUrl?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    orderShipped: (orderId: string, customerName?: string, trackingNumber?: string, trackingUrl?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    orderDelivered: (orderId: string, customerName?: string, reviewUrl?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    orderRefunded: (orderId: string, customerName?: string, refundAmount?: string) => {
        subject: string;
        html: string;
        text: string;
    };
    abandonedCart: (customerName?: string, checkoutUrl?: 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>;
    private static fetchBrandConfig;
    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;
}

type Redis$1 = any;
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$1, 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;
}

type Redis = any;
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;
    private jwtSecret;
    constructor(config: AuthRoutesConfig);
    private getBaseUrl;
    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>;
    resetPassword(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;
    requestMagicLink(req: Request): Promise<Response>;
    verifyMagicLink(req: Request): Promise<Response>;
    inviteUser(req: Request): Promise<Response>;
}

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;
        name?: string;
        role?: UserRole;
        avatar?: string;
        tenantId?: string;
        metadata?: Record<string, unknown>;
    }): 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>;
}

type UserKyroConfig = Omit<KyroConfig, "collections" | "globals"> & {
    collections?: CollectionConfig[] | Record<string, CollectionConfig>;
    globals?: GlobalConfig[] | Record<string, GlobalConfig>;
};
declare function defineConfig(config: UserKyroConfig): 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;
};

interface KyroLoaderOptions {
    collection: string;
    drafts?: boolean;
    limit?: number;
    configPath?: string;
}
/**
 * Native Astro 5+ Content Layer Loader for Kyro CMS.
 * Feeds Kyro CMS collection documents directly into Astro's `getCollection()` store.
 */
declare function kyroLoader(options: KyroLoaderOptions): Loader;

interface KyroActionOptions<TInput extends z.ZodTypeAny> {
    collection: string;
    action: 'create' | 'update' | 'delete' | 'find';
    schema?: TInput;
    access?: 'public' | 'authenticated' | 'admin';
}
/**
 * Type-safe Astro Actions handler for Kyro CMS collections.
 * Automatically validates incoming form submissions or RPC inputs against collection schemas.
 */
declare function kyroAction<TInput extends z.ZodTypeAny = z.ZodObject<any>>(options: KyroActionOptions<TInput>): {
    input: TInput | z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
    handler: (input: z.infer<TInput>, context: any) => Promise<{
        success: boolean;
        collection: string;
        action: "create" | "update" | "delete" | "find";
        data: z.TypeOf<TInput>;
        timestamp: string;
        error?: undefined;
    } | {
        success: boolean;
        error: any;
        collection?: undefined;
        action?: undefined;
        data?: undefined;
        timestamp?: undefined;
    }>;
};

interface KyroAuthMiddlewareOptions {
    protectedRoutes?: string[];
    loginPath?: string;
    cookieName?: string;
}
/**
 * Native Astro Middleware for Kyro CMS authentication & session management.
 * Populates `Astro.locals.kyroUser` and handles protected route authorization.
 */
declare function kyroAuthMiddleware(options?: KyroAuthMiddlewareOptions): (context: any, next: () => Promise<Response>) => Promise<any>;

/**
 * Helper to generate TypeScript declarations for Kyro CMS collections.
 * Can be invoked automatically during `npx astro sync` or dev server startup.
 */
declare function generateKyroAstroTypes(config: Record<string, any>): string;

interface KyroEnvSchemaOptions {
    requireDatabase?: boolean;
}
/**
 * Type-safe environment variable schema helper for Astro 5 (`astro:env`).
 */
declare function kyroEnvSchema(options?: KyroEnvSchemaOptions): {
    APP_SECRET: {
        context: "server";
        access: "secret";
        type: "string";
        optional: boolean;
    };
    DATABASE_URL: {
        context: "server";
        access: "secret";
        type: "string";
        optional: boolean;
    };
    PUBLIC_KYRO_URL: {
        context: "client";
        access: "public";
        type: "string";
        optional: boolean;
        default: string;
    };
};

/**
 * Edge Runtime detection utility for Kyro CMS.
 * Detects V8 Isolate runtimes (Vercel Edge, Cloudflare Workers, Deno Deploy, Netlify Edge).
 */
declare function isEdgeRuntime(): boolean;

type LogLevel = "debug" | "info" | "warn" | "error" | "none";
declare class Logger {
    private level;
    constructor();
    setLevel(level: LogLevel): void;
    getLevel(): LogLevel;
    private shouldLog;
    debug(...args: any[]): void;
    info(...args: any[]): void;
    warn(...args: any[]): void;
    error(...args: any[]): void;
}
declare const logger: Logger;

interface HierarchyNode<T = Record<string, any>> {
    doc: T;
    id: string | number;
    slug?: string;
    depth: number;
    path: string;
    fullPath: string;
    children: HierarchyNode<T>[];
}
interface BuildTreeOptions {
    idField?: string;
    parentField?: string;
    slugField?: string;
    slugPrefix?: boolean;
    basePath?: string;
    maxDepth?: number;
}
interface BreadcrumbItem {
    id: string | number;
    label: string;
    slug?: string;
    path?: string;
}
/**
 * Builds a nested hierarchical tree from a flat list of collection documents.
 */
declare function buildDocumentTree<T extends Record<string, any>>(docs: T[], options?: BuildTreeOptions): HierarchyNode<T>[];
/**
 * Returns breadcrumb trail for a given document within a collection.
 * Supports both getBreadcrumbs(docs, docId, options) and getBreadcrumbs(docId, docs, options).
 */
declare function getBreadcrumbs<T extends Record<string, any>>(arg1: T[] | string | number, arg2: T[] | string | number, options?: {
    idField?: string;
    parentField?: string;
    labelField?: string;
    slugField?: string;
    basePath?: string;
}): BreadcrumbItem[];
/**
 * Resolves the full URL path for a document in a hierarchical collection.
 */
declare function getNestedPath<T extends Record<string, any>>(docId: string | number, docs: T[], options?: {
    idField?: string;
    parentField?: string;
    slugField?: string;
    basePath?: string;
}): string;
/**
 * Flattens a document hierarchy tree with depth indicators (useful for admin select dropdowns and indented lists).
 */
declare function flattenDocumentTree<T extends Record<string, any>>(nodes: HierarchyNode<T>[]): Array<{
    doc: T;
    id: string | number;
    depth: number;
    path: string;
    fullPath: string;
    hasChildren: boolean;
}>;

export { AbstractBaseAdapter, AccountLockout, type AdminStylingConfig, AuditLog, AuditLogFilter, AuditLogger, Auth, AuthAdapter, AuthResult, Session as AuthSession, AuthTokenConfig, AuthUser, BaseAdapter, type BaseEmailOptions, type BrandConfig$1 as BrandConfig, type BuildTreeOptions, CSSGenerator, CollectionConfig, type CompareVersionsOptions, ConfigValidationError, CreateArgs, type CreateStorageResult, type CreateVersionOptions, type DatabaseType, DeleteArgs, DeliveryOptions, DeliveryResult, Dialect, type DraftPublishConfig, EmailTransport, type EncryptionConfig, type Environment, FIELD_DEFINITION_KEYS, Field, type FieldStyling, FindArgs, FindByIDArgs, FindResult, GlobalConfig, type HierarchyNode, InMemoryAccountLockout, InMemoryAuditLogger, InMemoryAuthAdapter, InMemoryRateLimiter, JWTPayload, Kyro, type KyroActionOptions, type KyroAuthConfig, type KyroAuthMiddlewareOptions, KyroConfig, type KyroEnvSchemaOptions, type KyroLoaderOptions, KyroPubSub, KyroWSServer, LocalAdapter, type LogLevel, Logger, LoginCredentials, MediaService, NeonAdapter, type NeonAdapterOptions, 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, type StylingConfig, type StylingMode, type ThemeBorderRadius, type ThemeColors, type ThemeConfig, type ThemeFonts, type ThemeShadows, type ThemeSpacing, TursoAdapter, type TursoAdapterOptions, UpdateArgs, User, UserRole, type Version, type VersionAdapter, type VersionDiff, type VersionHistoryOptions, VersionManager, type VersionPublishSchedule, type VersionStatus, WebhookConfig, WebhookDelivery, WebhookPayload, WebhookService, applyBlocksOverrides, applyCollectionOverrides, applyGlobalOverrides, applyTabsOverrides, authConfig, autoBootstrap, bootstrapAdmin, bootstrapWithRetry, buildDeliveryRecord, buildDocumentTree, collectionToCreateZod, collectionToUpdateZod, collectionToWhereZod, collectionToZod, createAdminStyling, createAuditContext, createAuth, createAuthConfig, createAuthStorage, createKyro, createKyroHandler, createLocalAdapter, createLocalStorage, createNeonAdapter, createStorage, createTestPayload, createTursoAdapter, createVersionManager, defaultDarkTheme, defaultFieldStyling, defaultLightTheme, defineConfig, defineKyroConfig, deliverWebhook, deliverWithRetry, ecommerce2026Theme, fieldToZod, flattenDocumentTree, flattenFieldOverrides, generateAnalyticsTags, generateCSSVariables, generateKyroAstroTypes, generateSeoTags, generateTailwindConfig, generateWebhookSecret, getAppSecret, getBootstrapFromEnv, getBreadcrumbs, getDefaultDraftPublishConfig, getEmailTemplates, getEncryptionKey, getNestedPath, getPaymentConfig, getPaymentConfigFromSettings, getSessionConfig, getSocialLinks, getSocialLinksFromSettings, getStoreConfig, getStoreConfigFromSettings, globalToZod, isArchived, isDraft, isEdgeRuntime, isFieldOverrideDefinition, isPublished, kyroAction, kyroAuthMiddleware, kyroEnvSchema, kyroLoader, loadSecrets, logger, renderAbandonedCart, renderAccountLocked, renderBaseLayout, renderMagicLink, renderNewLogin, renderOrderConfirmation, renderOrderDelivered, renderOrderRefunded, renderOrderShipped, renderPasswordChanged, renderResetPassword, renderUserInvite, renderVerifyEmail, renderWelcome, setDbAdapter, signPayload, updateFieldByPath, validateCollection, validateConfig, validateFields, validateGlobal };