import { c as RBACAdapter, R as Role, P as Permission, b as RoleDocument } from '../index-CEh-y2dx.mjs';
export { M as MongoDBAdapter, a as MongoDBAdapterConfig } from '../mongodb-D2e0SZRJ.mjs';
import 'mongodb';

interface CacheConfig {
    enabled?: boolean;
    ttl?: number;
}
/**
 * Base adapter with common functionality like caching
 * All adapters should extend this class
 */
declare abstract class BaseAdapter implements RBACAdapter {
    protected cache?: Map<string, {
        data: any;
        expires: number;
    }>;
    protected cacheConfig: CacheConfig;
    constructor(cacheConfig?: CacheConfig);
    /**
     * Get from cache or fetch and cache
     */
    protected withCache<T>(key: string, fetcher: () => Promise<T>): Promise<T>;
    /**
     * Clear cache for a specific key or all cache
     */
    clearCache(key?: string): void;
    abstract findRole(roleName: Role): Promise<any>;
    abstract getUserRole(userId: string): Promise<Role | null>;
    abstract getRolePermissions(roleName: Role): Promise<Permission[]>;
}

interface PrismaAdapterConfig extends CacheConfig {
    /**
     * Prisma client instance
     */
    prisma: any;
    /**
     * Name of the roles model in your Prisma schema
     * @default 'role'
     */
    roleModel?: string;
    /**
     * Name of the users model in your Prisma schema
     * @default 'user'
     */
    userModel?: string;
    /**
     * Field name for role name in roles table
     * @default 'name'
     */
    roleNameField?: string;
    /**
     * Field name for permissions array in roles table
     * @default 'permissions'
     */
    rolePermissionsField?: string;
    /**
     * Field name for role in users table
     * @default 'role'
     */
    userRoleField?: string;
    /**
     * Field name for deleted_at (soft delete)
     * @default 'deleted_at'
     */
    deletedAtField?: string;
}
/**
 * Prisma adapter for RBAC
 *
 * Works with any database supported by Prisma:
 * - PostgreSQL
 * - MySQL
 * - SQLite
 * - SQL Server
 * - MongoDB
 * - CockroachDB
 *
 * @example
 * ```typescript
 * import { PrismaClient } from '@prisma/client';
 * import { PrismaAdapter } from '@khannara/next-rbac/adapters';
 *
 * const prisma = new PrismaClient();
 *
 * const adapter = new PrismaAdapter({
 *   prisma,
 *   roleModel: 'role',
 *   userModel: 'user',
 *   enabled: true, // Enable caching
 *   ttl: 300 // Cache for 5 minutes
 * });
 * ```
 *
 * Required Prisma schema:
 * ```prisma
 * model Role {
 *   id          String   @id @default(auto()) @map("_id") @db.ObjectId
 *   name        String   @unique
 *   permissions String[]
 *   deleted_at  DateTime?
 *   created_at  DateTime  @default(now())
 *   updated_at  DateTime  @updatedAt
 * }
 *
 * model User {
 *   id    String @id @default(auto()) @map("_id") @db.ObjectId
 *   email String @unique
 *   role  String
 *   // ... other fields
 * }
 * ```
 */
declare class PrismaAdapter extends BaseAdapter {
    private prisma;
    private roleModel;
    private userModel;
    private roleNameField;
    private rolePermissionsField;
    private userRoleField;
    private deletedAtField;
    constructor(config: PrismaAdapterConfig);
    /**
     * Find a role by name
     */
    findRole(roleName: Role): Promise<RoleDocument | null>;
    /**
     * Get user's role
     */
    getUserRole(userId: string): Promise<Role | null>;
    /**
     * Get all permissions for a role
     */
    getRolePermissions(roleName: Role): Promise<Permission[]>;
}

interface MemoryAdapterConfig {
    /**
     * Initial roles data
     */
    roles?: Array<{
        name: string;
        permissions: string[];
    }>;
    /**
     * Initial users data
     */
    users?: Array<{
        id: string;
        role: string;
    }>;
}
/**
 * In-memory adapter for RBAC
 *
 * Perfect for:
 * - Unit testing
 * - Development/demos
 * - Documentation examples
 * - Prototyping
 *
 * @example
 * ```typescript
 * import { InMemoryAdapter } from '@khannara/next-rbac/adapters';
 *
 * const adapter = new InMemoryAdapter({
 *   roles: [
 *     {
 *       name: 'admin',
 *       permissions: ['users.create', 'users.read', 'users.update', 'users.delete']
 *     },
 *     {
 *       name: 'user',
 *       permissions: ['users.read']
 *     }
 *   ],
 *   users: [
 *     { id: '1', role: 'admin' },
 *     { id: '2', role: 'user' }
 *   ]
 * });
 * ```
 */
declare class InMemoryAdapter extends BaseAdapter {
    private roles;
    private users;
    constructor(config?: MemoryAdapterConfig);
    /**
     * Find a role by name
     */
    findRole(roleName: Role): Promise<RoleDocument | null>;
    /**
     * Get user's role
     */
    getUserRole(userId: string): Promise<Role | null>;
    /**
     * Get all permissions for a role
     */
    getRolePermissions(roleName: Role): Promise<Permission[]>;
    /**
     * Add or update a role (useful for testing)
     */
    setRole(name: string, permissions: string[]): void;
    /**
     * Add or update a user (useful for testing)
     */
    setUser(id: string, role: string): void;
    /**
     * Remove a role (useful for testing)
     */
    deleteRole(name: string): void;
    /**
     * Remove a user (useful for testing)
     */
    deleteUser(id: string): void;
    /**
     * Clear all data (useful for test cleanup)
     */
    clear(): void;
}

export { BaseAdapter, type CacheConfig, InMemoryAdapter, type MemoryAdapterConfig, PrismaAdapter, type PrismaAdapterConfig };