import { PaymentPlanContract, AdapterConfigurationError, DbAdapter, StorageAdapter, CacheAdapter, QueueAdapter, EventsAdapter, AuthProviderAdapter, PaymentsProviderAdapter, DeployAdapter } from '@geenius/adapters';
export { AuthContractError, AuthIdentitySchema, AuthProviderAdapter, AuthSessionContractSchema, CacheAdapter, CacheContractError, CacheEntrySchema, DeployAdapter, DeployContractError, DeploymentResultSchema, DeploymentTargetSchema, EventEnvelopeSchema, EventsAdapter, EventsContractError, PaymentCheckoutInputSchema, PaymentPlanContractSchema, PaymentSubscriptionContractSchema, PaymentsContractError, PaymentsProviderAdapter, QueueAdapter, QueueContractError, QueueJobSchema, StorageAdapter, StorageContractError, StorageObjectSchema } from '@geenius/adapters';

/**
 * @module index
 * @package @geenius/adapters/memory
 * @description Implements the launch memory DB provider as an in-process
 * `Map`-backed adapter for tests, Storybook fixtures, and local development.
 */

/** In-memory record shape stored by the Memory DB adapter. */
type MemoryDbRecord = Record<string, unknown> & {
    id: string;
};
/**
 * Configuration accepted by {@link createMemoryDbAdapter}.
 *
 * The adapter is intended for tests, Storybook fixtures, and local development.
 * It refuses production-like runtimes when `environment` or `NODE_ENV` is
 * `"production"` unless `allowProduction: true` is supplied explicitly.
 * Process-less browser, Storybook, and edge test runtimes are treated as
 * development-like unless callers pass `environment: "production"`. Use `seed`
 * for deterministic in-memory collections and `idFactory` for stable generated
 * ids in tests.
 */
interface MemoryDbAdapterOptions {
    allowProduction?: boolean;
    environment?: string;
    idFactory?: () => string;
    seed?: Record<string, readonly MemoryDbRecord[]>;
}
/** Binding object accepted by {@link withMemoryDb} for existing adapters. */
interface MemoryDbAdapterBinding {
    adapter: DbAdapter;
}
/** Accepted input for creating or binding a Memory DB adapter. */
type MemoryDbAdapterInput = DbAdapter | MemoryDbAdapterBinding | MemoryDbAdapterOptions | undefined;
/** Error thrown when Memory adapter configuration is invalid. */
declare class MemoryBindingError extends AdapterConfigurationError {
    readonly memoryCode: "INVALID_MEMORY_ADAPTER";
    /**
     * Creates a typed Memory adapter binding error.
     *
     * @param message Human-readable validation failure.
     */
    constructor(message: string);
}
/**
 * Creates an in-process DB adapter for tests, Storybook, and local development.
 *
 * By default this factory rejects production-like runtimes, while allowing
 * process-less browser, Storybook, and edge test runtimes where `process.env`
 * cannot be observed. Pass `environment: "production"` with
 * `allowProduction: true` only when an ephemeral process-local store is
 * intentionally acceptable in a production-like smoke test.
 * For deterministic smoke tests, pass both `seed` and `idFactory` so generated
 * records are stable across runs:
 *
 * ```ts
 * const adapter = createMemoryDbAdapter({
 *   environment: "test",
 *   seed: { users: [{ id: "user_1", name: "Ada" }] },
 *   idFactory: () => "user_2",
 * });
 * ```
 *
 * @param options Optional seed data, id factory, and environment guard settings.
 * @returns A DB adapter backed by an isolated in-memory collection store.
 */
declare function createMemoryDbAdapter(options?: MemoryDbAdapterOptions): DbAdapter;
/**
 * Normalizes Memory adapter input into a shared DB adapter instance.
 *
 * @param config Existing DB adapter, adapter binding, Memory options, or undefined.
 * @returns A DB adapter suitable for the shared adapters contract.
 */
declare function withMemoryDb(config?: MemoryDbAdapterInput): DbAdapter;
/** Minimal localStorage-compatible persistence surface used by memory mocks. */
interface MemoryContractStorage {
    readonly length: number;
    clear(): void;
    getItem(key: string): string | null;
    key(index: number): string | null;
    removeItem(key: string): void;
    setItem(key: string, value: string): void;
}
/** Options shared by localStorage-backed memory contract adapters. */
interface MemoryContractAdapterOptions {
    allowProduction?: boolean;
    environment?: string;
    idFactory?: () => string;
    namespace?: string;
    now?: () => string;
    storage?: MemoryContractStorage;
}
/** Options for the memory auth contract adapter. */
interface MemoryAuthAdapterOptions extends MemoryContractAdapterOptions {
    sessionTtlSeconds?: number;
}
/** Options for the memory payments contract adapter. */
interface MemoryPaymentsAdapterOptions extends MemoryContractAdapterOptions {
    plans?: readonly PaymentPlanContract[];
}
/** Options accepted by the aggregate memory contract adapter bundle. */
interface MemoryAdaptersOptions extends MemoryAuthAdapterOptions, MemoryPaymentsAdapterOptions {
}
/**
 * Creates a localStorage-backed object storage mock for tests, Storybook, and
 * offline prototypes.
 *
 * @param options Optional storage, namespace, id, clock, and environment guard
 * settings used to isolate deterministic local state.
 * @returns A storage adapter implementing object get/put/delete/list and
 * health checks without importing a provider SDK.
 */
declare function createMemoryStorageAdapter(options?: MemoryContractAdapterOptions): StorageAdapter;
/**
 * Creates a localStorage-backed key/value cache mock for tests, Storybook, and
 * offline prototypes.
 *
 * @param options Optional storage, namespace, id, clock, and environment guard
 * settings used to isolate deterministic local state.
 * @returns A cache adapter implementing get/set/delete/has/clear and health
 * checks without importing Redis, KV, or provider SDKs.
 */
declare function createMemoryCacheAdapter(options?: MemoryContractAdapterOptions): CacheAdapter;
/**
 * Creates a localStorage-backed job queue mock for tests, Storybook, and
 * offline prototypes.
 *
 * @param options Optional storage, namespace, id, clock, and environment guard
 * settings used to isolate deterministic local state.
 * @returns A queue adapter implementing enqueue, schedule, complete, fail,
 * listJobs, and health checks without importing a queue provider SDK.
 */
declare function createMemoryQueueAdapter(options?: MemoryContractAdapterOptions): QueueAdapter;
/**
 * Creates a localStorage-backed pub/sub and webhook event mock for tests,
 * Storybook, and offline prototypes.
 *
 * @param options Optional storage, namespace, id, clock, and environment guard
 * settings used to isolate deterministic local state.
 * @returns An events adapter implementing publish, subscribe, emitWebhook,
 * listEvents, and health checks without importing an event bus SDK.
 */
declare function createMemoryEventsAdapter(options?: MemoryContractAdapterOptions): EventsAdapter;
/**
 * Creates a localStorage-backed identity and session mock for tests, Storybook,
 * and offline prototypes.
 *
 * @param options Optional storage, namespace, id, clock, session TTL, and
 * environment guard settings used to isolate deterministic local state.
 * @returns An auth provider adapter implementing identity/session lifecycle and
 * health checks without importing an auth provider SDK.
 */
declare function createMemoryAuthAdapter(options?: MemoryAuthAdapterOptions): AuthProviderAdapter;
/**
 * Creates a localStorage-backed payments mock for tests, Storybook, and
 * offline prototypes.
 *
 * @param options Optional storage, namespace, id, clock, plan fixtures, and
 * environment guard settings used to isolate deterministic local state.
 * @returns A payments provider adapter implementing plans, checkout,
 * subscription, feature-gate, and health methods without importing Stripe or
 * another payment SDK.
 */
declare function createMemoryPaymentsAdapter(options?: MemoryPaymentsAdapterOptions): PaymentsProviderAdapter;
/**
 * Creates a localStorage-backed deployment-platform mock for tests, Storybook,
 * and offline prototypes.
 *
 * @param options Optional storage, namespace, id, clock, and environment guard
 * settings used to isolate deterministic local state.
 * @returns A deploy adapter implementing deploy, rollback, lookup, list, and
 * health methods without importing Cloudflare, Vercel, Netlify, or Heroku SDKs.
 */
declare function createMemoryDeployAdapter(options?: MemoryContractAdapterOptions): DeployAdapter;
/**
 * Creates the aggregate local/dev adapter bundle for every memory contract
 * domain.
 *
 * @param options Optional shared storage, namespace, id, clock, auth session,
 * payment plan, and environment guard settings passed to each domain factory.
 * @returns A bundled set of storage, cache, queue, events, auth, payments, and
 * deploy memory adapters for tests, Storybook, and offline prototypes.
 */
declare function createMemoryAdapters(options?: MemoryAdaptersOptions): {
    storage: StorageAdapter;
    cache: CacheAdapter;
    queue: QueueAdapter;
    events: EventsAdapter;
    auth: AuthProviderAdapter;
    payments: PaymentsProviderAdapter;
    deploy: DeployAdapter;
};

export { type MemoryAdaptersOptions, type MemoryAuthAdapterOptions, MemoryBindingError, type MemoryContractAdapterOptions, type MemoryContractStorage, type MemoryDbAdapterBinding, type MemoryDbAdapterInput, type MemoryDbAdapterOptions, type MemoryDbRecord, type MemoryPaymentsAdapterOptions, createMemoryAdapters, createMemoryAuthAdapter, createMemoryCacheAdapter, createMemoryDbAdapter, createMemoryDeployAdapter, createMemoryEventsAdapter, createMemoryPaymentsAdapter, createMemoryQueueAdapter, createMemoryStorageAdapter, withMemoryDb };