import { Brand } from '../shared/type-utils.js';
/**
 * Unique extension identifier
 * Prevents mixing different extension types (compile-time safety)
 */
export type ExtensionId = Brand<string, 'ExtensionId'>;
/**
 * Unique hook identifier
 */
export type HookId = Brand<string, 'HookId'>;
/**
 * Unique component extension identifier
 */
export type ComponentExtensionId = Brand<string, 'ComponentExtensionId'>;
/**
 * Type-safe extension ID constructor
 */
export declare function createExtensionId(id: string): ExtensionId;
/**
 * Type-safe hook ID constructor
 */
export declare function createHookId(id: string): HookId;
/**
 * Extension priority for execution order
 * Higher priority extensions execute first
 */
export type ExtensionPriority = number;
/**
 * Default priority values
 */
export declare const ExtensionPriorities: {
    readonly CRITICAL: 1000;
    readonly HIGH: 500;
    readonly NORMAL: 0;
    readonly LOW: -500;
    readonly LOWEST: -1000;
};
/**
 * Context provided to onInit hook
 */
export interface InitContext {
    /** Extension name */
    extensionName: string;
    /** Configuration passed to the client */
    config: Record<string, unknown>;
    /** Timestamp when initialized */
    timestamp: number;
}
/**
 * Context provided to onMount hook (React lifecycle)
 */
export interface MountContext {
    /** Extension name */
    extensionName: string;
    /** Component or module being mounted */
    component?: string;
    /** Mount-specific data */
    data?: Record<string, unknown>;
    /** Timestamp when mounted */
    timestamp: number;
}
/**
 * Context provided to onUnmount hook (React lifecycle)
 */
export interface UnmountContext {
    /** Extension name */
    extensionName: string;
    /** Component or module being unmounted */
    component?: string;
    /** Cleanup-specific data */
    data?: Record<string, unknown>;
    /** Timestamp when unmounted */
    timestamp: number;
}
/**
 * Context provided to onError hook
 */
export interface ErrorContext {
    /** Extension name where error occurred */
    extensionName: string;
    /** Hook name where error occurred */
    hookName: string;
    /** The error that was thrown */
    error: Error;
    /** Operation that was being performed */
    operation: string;
    /** Retry the failed operation */
    retry: () => Promise<void>;
    /** Timestamp when error occurred */
    timestamp: number;
}
/**
 * Context provided to beforeOperation hook
 */
export interface BeforeOperationContext<TArgs = unknown> {
    /** Extension name */
    extensionName: string;
    /** Operation name (e.g., 'fetch', 'mutate', 'render') */
    operation: string;
    /** Operation arguments (mutable) */
    args: TArgs;
    /** Modify arguments before execution */
    modify: (changes: Partial<TArgs>) => void;
    /** Cancel the operation */
    cancel: () => void;
    /** Operation metadata */
    metadata?: Record<string, unknown>;
    /** Timestamp */
    timestamp: number;
}
/**
 * Context provided to afterOperation hook
 */
export interface AfterOperationContext<TArgs = unknown, TResult = unknown> {
    /** Extension name */
    extensionName: string;
    /** Operation name */
    operation: string;
    /** Original operation arguments */
    args: TArgs;
    /** Operation result (mutable) */
    result: TResult;
    /** Modify result before returning */
    modify: (changes: Partial<TResult>) => void;
    /** Operation duration in ms */
    duration: number;
    /** Operation metadata */
    metadata?: Record<string, unknown>;
    /** Timestamp */
    timestamp: number;
}
/**
 * Extension lifecycle hook function types
 */
export type InitHook = (context: InitContext) => Promise<void> | void;
export type MountHook = (context: MountContext) => Promise<void> | void;
export type UnmountHook = (context: UnmountContext) => Promise<void> | void;
export type ErrorHook = (context: ErrorContext) => Promise<void> | void;
export type BeforeOperationHook<TArgs = unknown> = (context: BeforeOperationContext<TArgs>) => Promise<void> | void;
export type AfterOperationHook<TArgs = unknown, TResult = unknown> = (context: AfterOperationContext<TArgs, TResult>) => Promise<void> | void;
/**
 * Lifecycle hooks configuration
 */
export interface LifecycleHooks {
    /** Called when extension is registered */
    onInit?: InitHook;
    /** Called when component/module mounts (React lifecycle) */
    onMount?: MountHook;
    /** Called when component/module unmounts (React lifecycle) */
    onUnmount?: UnmountHook;
    /** Called when an error occurs in any hook */
    onError?: ErrorHook;
    /** Called before any operation (middleware pattern) */
    beforeOperation?: BeforeOperationHook;
    /** Called after any operation (middleware pattern) */
    afterOperation?: AfterOperationHook;
}
/**
 * Component enhancer function type
 * Used to wrap or enhance React components
 */
export type ComponentEnhancer<TProps = unknown> = (Component: React.ComponentType<TProps>) => React.ComponentType<TProps>;
/**
 * Component hook type
 * Custom hooks provided by extensions
 */
export type ComponentHook<TResult = unknown> = (...args: unknown[]) => TResult;
/**
 * Component extensions configuration
 */
export interface ComponentExtensions {
    /** Component enhancers (HOCs) */
    enhancers?: Record<string, ComponentEnhancer>;
    /** Custom React hooks */
    hooks?: Record<string, ComponentHook>;
    /** Component-level utilities */
    utils?: Record<string, (...args: unknown[]) => unknown>;
}
/**
 * State selector function type
 */
export type StateSelector<TState = unknown, TResult = unknown> = (state: TState) => TResult;
/**
 * State action creator type
 */
export type StateActionCreator<TPayload = unknown> = (payload: TPayload) => {
    type: string;
    payload: TPayload;
};
/**
 * State middleware function type
 */
export type StateMiddleware<TState = unknown> = (state: TState, action: {
    type: string;
    payload?: unknown;
}) => TState;
/**
 * State extensions configuration
 */
export interface StateExtensions {
    /** State selectors */
    selectors?: Record<string, StateSelector>;
    /** Action creators */
    actions?: Record<string, StateActionCreator>;
    /** State middleware */
    middleware?: StateMiddleware[];
    /** Initial state contributions */
    initialState?: Record<string, unknown>;
}
/**
 * API endpoint definition
 */
export interface ApiEndpoint<TArgs = unknown, TResult = unknown> {
    /** HTTP method or operation type */
    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | string;
    /** Endpoint path or operation name */
    path?: string;
    /** Endpoint handler */
    handler: (args: TArgs) => Promise<TResult> | TResult;
    /** Request transformer */
    transformRequest?: (args: TArgs) => unknown;
    /** Response transformer */
    transformResponse?: (response: unknown) => TResult;
    /** Error transformer */
    transformError?: (error: unknown) => Error;
}
/**
 * API interceptor for request/response modification
 */
export interface ApiInterceptor {
    /** Request interceptor */
    request?: (config: RequestConfig) => Promise<RequestConfig> | RequestConfig;
    /** Response interceptor */
    response?: <T>(response: T) => Promise<T> | T;
    /** Error interceptor */
    error?: (error: Error) => Promise<never> | never;
}
/**
 * Request configuration
 */
export interface RequestConfig {
    url?: string;
    method?: string;
    headers?: Record<string, string>;
    params?: Record<string, unknown>;
    data?: unknown;
    timeout?: number;
    metadata?: Record<string, unknown>;
}
/**
 * API extensions configuration
 */
export interface ApiExtensions {
    /** Custom API endpoints */
    endpoints?: Record<string, ApiEndpoint>;
    /** Request/response interceptors */
    interceptors?: ApiInterceptor[];
    /** API-level utilities */
    utils?: Record<string, (...args: unknown[]) => unknown>;
}
/**
 * Complete Enzyme Extension definition
 * Inspired by Prisma's extension architecture
 *
 * @example
 * ```ts
 * const loggingExtension: EnzymeExtension = {
 *   name: 'logging',
 *   version: '1.0.0',
 *   description: 'Logs all operations',
 *   priority: ExtensionPriorities.HIGH,
 *   hooks: {
 *     beforeOperation: async (ctx) => {
 *       console.log(`[${ctx.operation}] Starting...`);
 *     },
 *     afterOperation: async (ctx) => {
 *       console.log(`[${ctx.operation}] Completed in ${ctx.duration}ms`);
 *     },
 *   },
 * };
 * ```
 */
export interface EnzymeExtension {
    /** Extension name (required, must be unique) */
    name: string;
    /** Extension version (semver recommended) */
    version?: string;
    /** Extension description */
    description?: string;
    /** Execution priority (higher = earlier execution) */
    priority?: ExtensionPriority;
    /** Lifecycle hooks */
    hooks?: LifecycleHooks;
    /** Component-level extensions */
    component?: ComponentExtensions;
    /** State management extensions */
    state?: StateExtensions;
    /** API/network extensions */
    api?: ApiExtensions;
    /** Client-level methods and utilities */
    client?: Record<string, (...args: any[]) => any>;
    /** Extension metadata */
    metadata?: Record<string, unknown>;
}
/**
 * Extension manager interface
 */
export interface IExtensionManager {
    /** Register an extension */
    register(extension: EnzymeExtension): void;
    /** Unregister an extension by name */
    unregister(name: string): boolean;
    /** Get all registered extensions */
    getExtensions(): EnzymeExtension[];
    /** Get extension by name */
    getExtension(name: string): EnzymeExtension | undefined;
    /** Check if extension is registered */
    hasExtension(name: string): boolean;
    /** Get extension count */
    readonly count: number;
    /** Execute lifecycle hooks */
    executeHooks<T = void>(hookName: keyof LifecycleHooks, context: unknown): Promise<T | void>;
    /** Clear all extensions */
    clear(): void;
}
/**
 * Exact type matching for strict checking
 * Prevents excess properties in extension definitions
 */
export type Exact<Input, Shape> = Input extends Shape ? Exclude<keyof Input, keyof Shape> extends never ? Input : never : never;
/**
 * Deep partial type for configuration
 */
export type DeepPartial<T> = T extends object ? {
    [P in keyof T]?: DeepPartial<T[P]>;
} : T;
/**
 * Extract extension client methods
 */
export type ExtensionClientMethods<T extends EnzymeExtension> = T['client'] extends Record<string, (...args: unknown[]) => unknown> ? T['client'] : Record<string, never>;
/**
 * Merge multiple extension client methods
 */
export type MergeExtensionMethods<T extends EnzymeExtension[]> = T extends [
    infer First extends EnzymeExtension,
    ...infer Rest extends EnzymeExtension[]
] ? ExtensionClientMethods<First> & MergeExtensionMethods<Rest> : Record<string, never>;
/**
 * Extension client type with merged methods
 */
export type ExtendedClient<TBase, TExtensions extends EnzymeExtension[]> = TBase & MergeExtensionMethods<TExtensions>;
/**
 * Enzyme namespace for extension utilities
 */
export declare namespace Enzyme {
    /**
     * Define an extension with type inference and validation
     *
     * @example
     * ```ts
     * const myExtension = Enzyme.defineExtension({
     *   name: 'my-extension',
     *   version: '1.0.0',
     *   hooks: {
     *     onInit: async (ctx) => {
     *       console.log('Initialized!');
     *     },
     *   },
     * });
     * ```
     */
    function defineExtension<T extends EnzymeExtension>(extension: T): T;
    /**
     * Create a typed hook context
     */
    function createHookContext<T extends keyof LifecycleHooks>(_hookName: T, data: unknown): unknown;
    /**
     * Type guard for extension validation
     */
    function isValidExtension(value: unknown): value is EnzymeExtension;
    /**
     * Extension builder for fluent API
     *
     * @example
     * ```ts
     * const ext = Enzyme.extension('my-ext')
     *   .version('1.0.0')
     *   .priority(ExtensionPriorities.HIGH)
     *   .onInit(async (ctx) => { ... })
     *   .build();
     * ```
     */
    function extension(name: string): ExtensionBuilder;
}
/**
 * Fluent extension builder
 */
export declare class ExtensionBuilder {
    private ext;
    constructor(name: string);
    version(v: string): this;
    description(d: string): this;
    priority(p: ExtensionPriority): this;
    onInit(hook: InitHook): this;
    onMount(hook: MountHook): this;
    onUnmount(hook: UnmountHook): this;
    onError(hook: ErrorHook): this;
    beforeOperation(hook: BeforeOperationHook): this;
    afterOperation(hook: AfterOperationHook): this;
    withComponent(component: ComponentExtensions): this;
    withState(state: StateExtensions): this;
    withApi(api: ApiExtensions): this;
    withClient(client: Record<string, (...args: unknown[]) => unknown>): this;
    withMetadata(metadata: Record<string, unknown>): this;
    build(): EnzymeExtension;
}
/**
 * Extension event for pub/sub communication between extensions
 */
export interface ExtensionEvent<TPayload = unknown> {
    /** Event type/name */
    type: string;
    /** Event payload */
    payload: TPayload;
    /** Source extension */
    source: string;
    /** Timestamp */
    timestamp: number;
    /** Event metadata */
    metadata?: Record<string, unknown>;
}
/**
 * Extension event handler
 */
export type ExtensionEventHandler<TPayload = unknown> = (event: ExtensionEvent<TPayload>) => Promise<void> | void;
/**
 * Extension event emitter interface
 */
export interface IExtensionEventEmitter {
    /** Emit an event */
    emit<T>(type: string, payload: T, metadata?: Record<string, unknown>): void;
    /** Subscribe to events */
    on<T>(type: string, handler: ExtensionEventHandler<T>): () => void;
    /** Subscribe to events (once) */
    once<T>(type: string, handler: ExtensionEventHandler<T>): () => void;
    /** Unsubscribe from events */
    off<T>(type: string, handler: ExtensionEventHandler<T>): void;
}