import { CreateSandboxOptions, SandboxInterface, RunCommandOptions, CommandResult, SandboxInfo, FileEntry } from 'computesdk';
export { CodeResult, CommandResult, CreateSandboxOptions, FileEntry, RunCommandOptions, SandboxFileSystem, SandboxInfo, SandboxInterface } from 'computesdk';

/**
 * Provider Types
 *
 * Types related to provider configuration, authentication, and resource management
 */

/**
 * Provider Sandbox - what provider implementations return
 *
 * Extends the universal Sandbox interface with provider-specific methods
 */
interface ProviderSandbox<TSandbox = any> extends Omit<SandboxInterface, 'runCode'> {
    /** Get the provider that created this sandbox */
    getProvider(): Provider<TSandbox>;
    /** Get the native provider sandbox instance */
    getInstance(): TSandbox;
    /** Destroy sandbox and clean up resources */
    destroy(): Promise<void>;
}
/**
 * Extract the sandbox type from a provider using generic inference
 */
type ExtractProviderSandboxType<TProvider> = TProvider extends Provider<infer TSandbox, any, any> ? TSandbox : any;
/**
 * Typed provider sandbox interface that preserves the provider's native instance type
 */
type TypedProviderSandbox<TProvider extends Provider> = ProviderSandbox<ExtractProviderSandboxType<TProvider>>;
/**
 * Common options for creating snapshots
 */
interface CreateSnapshotOptions {
    /** Optional name for the snapshot */
    name?: string;
    /** Optional metadata for the snapshot */
    metadata?: Record<string, string>;
}
/**
 * Common options for listing snapshots
 */
interface ListSnapshotsOptions {
    /** Filter by sandbox ID */
    sandboxId?: string;
    /** Limit the number of results */
    limit?: number;
}
/**
 * Common options for creating templates/blueprints
 */
interface CreateTemplateOptions {
    /** Name of the template */
    name: string;
    /** Optional description */
    description?: string;
    /** Optional metadata for the template */
    metadata?: Record<string, string>;
}
/**
 * Common options for listing templates
 */
interface ListTemplatesOptions {
    /** Limit the number of results */
    limit?: number;
}
/**
 * Provider sandbox manager interface - handles sandbox lifecycle
 */
interface ProviderSandboxManager<TSandbox = any> {
    /** Create a new sandbox */
    create(options?: CreateSandboxOptions): Promise<ProviderSandbox<TSandbox>>;
    /** Get an existing sandbox by ID */
    getById(sandboxId: string): Promise<ProviderSandbox<TSandbox> | null>;
    /** List all active sandboxes */
    list(): Promise<ProviderSandbox<TSandbox>[]>;
    /** Destroy a sandbox */
    destroy(sandboxId: string): Promise<void>;
}
/**
 * Provider template manager interface - handles template/blueprint lifecycle
 */
interface ProviderTemplateManager<TTemplate = any, TCreateOptions extends CreateTemplateOptions = CreateTemplateOptions> {
    /** Create a new template */
    create(options: TCreateOptions): Promise<TTemplate>;
    /** List all available templates */
    list(options?: ListTemplatesOptions): Promise<TTemplate[]>;
    /** Delete a template */
    delete(templateId: string): Promise<void>;
}
/**
 * Provider snapshot manager interface - handles snapshot lifecycle
 */
interface ProviderSnapshotManager<TSnapshot = any> {
    /** Create a snapshot from a sandbox */
    create(sandboxId: string, options?: CreateSnapshotOptions): Promise<TSnapshot>;
    /** List all snapshots */
    list(options?: ListSnapshotsOptions): Promise<TSnapshot[]>;
    /** Delete a snapshot */
    delete(snapshotId: string): Promise<void>;
}
/**
 * Provider interface - creates and manages resources
 */
interface Provider<TSandbox = any, TTemplate = any, TSnapshot = any> {
    /** Provider name/type */
    readonly name: string;
    /** Sandbox management operations */
    readonly sandbox: ProviderSandboxManager<TSandbox>;
    /** Optional template management operations */
    readonly template?: ProviderTemplateManager<TTemplate>;
    /** Optional snapshot management operations */
    readonly snapshot?: ProviderSnapshotManager<TSnapshot>;
}
/**
 * Configuration for the compute singleton
 */
interface ComputeConfig<TProvider extends Provider = Provider> {
    /** Default provider to use when none is specified */
    defaultProvider?: TProvider;
    /** @deprecated Use defaultProvider instead. Kept for backwards compatibility */
    provider?: TProvider;
    /** API key for compute CLI authentication */
    apiKey?: string;
    /** Access token for compute CLI authentication */
    accessToken?: string;
    /** @deprecated Use accessToken instead. Kept for backwards compatibility */
    jwt?: string;
}
/**
 * Parameters for compute.sandbox.create()
 */
interface CreateSandboxParams {
    /** Provider instance to use */
    provider: Provider;
    /** Optional sandbox creation options */
    options?: CreateSandboxOptions;
}
/**
 * Parameters for compute.sandbox.create() with optional provider
 */
interface CreateSandboxParamsWithOptionalProvider {
    /** Provider instance to use (optional if default is set) */
    provider?: Provider;
    /** Optional sandbox creation options */
    options?: CreateSandboxOptions;
}
/**
 * Base Compute API interface (non-generic)
 *
 * Returns ProviderSandbox which is the common interface for all sandboxes.
 */
interface ComputeAPI$1 {
    /** Configuration management */
    setConfig<TProvider extends Provider>(config: ComputeConfig<TProvider>): void;
    getConfig(): ComputeConfig | null;
    clearConfig(): void;
    sandbox: {
        /** Create a sandbox from a provider (or default provider if configured) */
        create(params?: CreateSandboxParams | CreateSandboxParamsWithOptionalProvider): Promise<ProviderSandbox>;
        /** Get an existing sandbox by ID from a provider (or default provider if configured) */
        getById(providerOrSandboxId: Provider | string, sandboxId?: string): Promise<ProviderSandbox | null>;
        /** List all active sandboxes from a provider (or default provider if configured) */
        list(provider?: Provider): Promise<ProviderSandbox[]>;
        /** Destroy a sandbox via a provider (or default provider if configured) */
        destroy(providerOrSandboxId: Provider | string, sandboxId?: string): Promise<void>;
    };
}
/**
 * Typed Compute API interface that preserves provider type information
 */
interface TypedComputeAPI<TProvider extends Provider> extends Omit<ComputeAPI$1, 'sandbox' | 'setConfig'> {
    /** Configuration management that returns typed compute instance */
    setConfig<T extends Provider>(config: ComputeConfig<T>): TypedComputeAPI<T>;
    sandbox: {
        /** Create a sandbox from the configured provider with proper typing */
        create(params?: Omit<CreateSandboxParamsWithOptionalProvider, 'provider'>): Promise<TypedProviderSandbox<TProvider>>;
        /** Get an existing sandbox by ID from the configured provider with proper typing */
        getById(sandboxId: string): Promise<TypedProviderSandbox<TProvider> | null>;
        /** List all active sandboxes from the configured provider with proper typing */
        list(): Promise<TypedProviderSandbox<TProvider>[]>;
        /** Destroy a sandbox via the configured provider */
        destroy(sandboxId: string): Promise<void>;
    };
}
/**
 * E2B provider configuration for explicit compute mode
 */
interface E2BProviderConfig {
    /** E2B API key */
    apiKey?: string;
    /** E2B project ID */
    projectId?: string;
    /** E2B environment/template ID */
    templateId?: string;
}
/**
 * Modal provider configuration for explicit compute mode
 */
interface ModalProviderConfig {
    /** Modal token ID */
    tokenId?: string;
    /** Modal token secret */
    tokenSecret?: string;
}
/**
 * Railway provider configuration for explicit compute mode
 */
interface RailwayProviderConfig {
    /** Railway API token */
    apiToken?: string;
    /** Railway project ID */
    projectId?: string;
    /** Railway environment ID */
    environmentId?: string;
}
/**
 * Daytona provider configuration for explicit compute mode
 */
interface DaytonaProviderConfig {
    /** Daytona API key */
    apiKey?: string;
}
/**
 * Vercel provider configuration for explicit compute mode
 */
interface VercelProviderConfig {
    /** Vercel OIDC token (preferred, simpler auth) */
    oidcToken?: string;
    /** Vercel API token (traditional auth) */
    token?: string;
    /** Vercel team ID (required with token) */
    teamId?: string;
    /** Vercel project ID (required with token) */
    projectId?: string;
}
/**
 * Runloop provider configuration for explicit compute mode
 */
interface RunloopProviderConfig {
    /** Runloop API key */
    apiKey?: string;
}
/**
 * Cloudflare provider configuration for explicit compute mode
 */
interface CloudflareProviderConfig {
    /** Cloudflare API token */
    apiToken?: string;
    /** Cloudflare account ID */
    accountId?: string;
}
/**
 * CodeSandbox provider configuration for explicit compute mode
 */
interface CodesandboxProviderConfig {
    /** CodeSandbox API key */
    apiKey?: string;
}
/**
 * Blaxel provider configuration for explicit compute mode
 */
interface BlaxelProviderConfig {
    /** Blaxel API key */
    apiKey?: string;
    /** Blaxel workspace */
    workspace?: string;
}
/**
 * Storage Provider Types
 *
 * Unified interface for object storage providers (S3, R2, Tigris, etc.)
 */
/**
 * Storage object metadata
 */
interface StorageObject {
    /** Bucket name */
    bucket: string;
    /** Object key/path */
    key: string;
    /** Object size in bytes */
    size: number;
    /** ETag (entity tag) for the object */
    etag?: string;
    /** Last modified date */
    lastModified?: Date;
    /** Optional metadata */
    metadata?: Record<string, string>;
}
/**
 * Options for uploading objects
 */
interface UploadOptions {
    /** MIME content type */
    contentType?: string;
    /** Custom metadata */
    metadata?: Record<string, string>;
}
/**
 * Result from a download operation
 */
interface DownloadResult {
    /** Object data as Uint8Array (cross-platform compatible) */
    data: Uint8Array;
    /** Object size in bytes */
    size: number;
    /** MIME content type */
    contentType?: string;
    /** ETag (entity tag) */
    etag?: string;
    /** Last modified date */
    lastModified?: Date;
    /** Custom metadata */
    metadata?: Record<string, string>;
}
/**
 * Options for listing objects
 */
interface ListOptions {
    /** Prefix to filter objects */
    prefix?: string;
    /** Maximum number of keys to return */
    maxKeys?: number;
    /** Continuation token for pagination */
    continuationToken?: string;
}
/**
 * Result from a list operation
 */
interface ListResult {
    /** List of objects */
    objects: StorageObject[];
    /** Whether there are more results */
    truncated: boolean;
    /** Continuation token for next page */
    continuationToken?: string;
}
/**
 * Base storage provider interface
 *
 * All storage providers (S3, R2, Tigris) implement this interface
 */
interface StorageProvider {
    /** Upload data to storage */
    upload(bucket: string, key: string, data: Uint8Array | string, options?: UploadOptions): Promise<StorageObject>;
    /** Download data from storage */
    download(bucket: string, key: string): Promise<DownloadResult>;
    /** Delete object from storage */
    delete(bucket: string, key: string): Promise<void>;
    /** List objects in bucket */
    list(bucket: string, options?: ListOptions): Promise<ListResult>;
}

/**
 * Browser Provider Types
 *
 * Types for browser providers (Browserbase, Kernel, etc.)
 * Browser providers manage cloud browser sessions, distinct from sandbox providers
 * which manage code execution environments.
 */
/**
 * Browser session info returned from provider APIs
 */
interface BrowserSession {
    /** Unique session identifier */
    sessionId: string;
    /**
     * CDP or WebSocket connection URL.
     *
     * Always set for sessions returned by `create()` and `getById()`. May be
     * absent for entries returned by `list()` when the underlying provider's
     * list endpoint omits the connect URL — in that case, call
     * `provider.getConnectUrl(sessionId)` to obtain a connectable URL.
     */
    connectUrl?: string;
    /** Current session status */
    status: 'created' | 'running' | 'completed' | 'failed' | 'timed_out';
    /** Session creation timestamp */
    createdAt?: Date;
    /** Provider-specific metadata */
    metadata?: Record<string, unknown>;
}
/**
 * Options for creating a browser session
 */
interface CreateBrowserSessionOptions {
    /** Proxy configuration — true for provider default, or detailed config */
    proxies?: boolean | ProxyConfig[];
    /** Browser viewport dimensions */
    viewport?: {
        width: number;
        height: number;
    };
    /** Session timeout in seconds */
    timeout?: number;
    /** Keep session alive after script disconnects */
    keepAlive?: boolean;
    /** Enable session recording (default: true) */
    recording?: boolean;
    /** Enable session logging (default: true) */
    logging?: boolean;
    /** Enable stealth/anti-detection mode */
    stealth?: boolean;
    /** Browser profile/context ID for session persistence */
    profileId?: string;
    /** Extension IDs to load */
    extensionIds?: string[];
    /** Region/datacenter preference */
    region?: string;
    /** Custom user metadata */
    userMetadata?: Record<string, string>;
}
/**
 * Proxy configuration for browser sessions
 */
interface ProxyConfig {
    /** Proxy type */
    type: 'residential' | 'isp' | 'datacenter' | 'custom';
    /** Proxy server URL (for custom type) */
    server?: string;
    /** Proxy username */
    username?: string;
    /** Proxy password */
    password?: string;
    /** Geolocation targeting */
    geolocation?: {
        country?: string;
        state?: string;
        city?: string;
    };
    /** Domain pattern to route through this proxy */
    domainPattern?: string;
}
/**
 * Browser profile (persistent context — cookies, storage, etc.)
 */
interface BrowserProfile {
    /** Unique profile identifier */
    profileId: string;
    /** Human-readable name */
    name?: string;
    /** Creation timestamp */
    createdAt?: Date;
    /** Provider-specific metadata */
    metadata?: Record<string, unknown>;
}
/**
 * Options for creating a browser profile
 */
interface CreateBrowserProfileOptions {
    /** Human-readable name */
    name?: string;
    /** Custom metadata */
    metadata?: Record<string, string>;
}
/**
 * Browser extension
 */
interface BrowserExtension {
    /** Unique extension identifier */
    extensionId: string;
    /** Extension name */
    name?: string;
}
/**
 * Options for uploading/creating a browser extension
 */
interface CreateBrowserExtensionOptions {
    /** Extension file data */
    file: Uint8Array | string;
    /** Extension name */
    name?: string;
}
/**
 * Browser pool — pre-warmed browser instances for instant acquisition
 */
interface BrowserPool {
    /** Unique pool identifier */
    poolId: string;
    /** Pool name */
    name?: string;
    /** Number of idle instances ready */
    idleCount?: number;
    /** Number of active instances in use */
    activeCount?: number;
}
/**
 * Options for creating a browser pool
 */
interface CreateBrowserPoolOptions {
    /** Pool name */
    name: string;
    /** Desired number of pre-warmed instances */
    size: number;
    /** Default session options for pool instances */
    sessionDefaults?: CreateBrowserSessionOptions;
}
/**
 * Browser session log entry
 */
interface BrowserLog {
    /** Timestamp */
    timestamp: Date;
    /** Log level */
    level: 'info' | 'warn' | 'error' | 'debug';
    /** Log message */
    message: string;
    /** Additional structured data */
    data?: Record<string, unknown>;
}
/**
 * Browser session recording
 */
interface BrowserRecording {
    /** Recording identifier */
    recordingId: string;
    /** Session this recording belongs to */
    sessionId: string;
    /** Recording format */
    format: 'rrweb' | 'mp4' | string;
    /** URL to access the recording */
    url?: string;
    /** Raw recording data */
    data?: unknown;
}
/**
 * Screenshot options
 */
interface ScreenshotOptions {
    /** Image format */
    format?: 'png' | 'jpeg' | 'webp';
    /** Quality (0-100, for jpeg/webp) */
    quality?: number;
    /** Capture full scrollable page */
    fullPage?: boolean;
    /** CSS selector to capture */
    selector?: string;
}
/**
 * PDF generation options
 */
interface PdfOptions {
    /** Paper format */
    format?: 'letter' | 'legal' | 'a4' | 'a3';
    /** Print background graphics */
    printBackground?: boolean;
    /** Landscape orientation */
    landscape?: boolean;
}
/**
 * Browser session manager — core lifecycle operations
 */
interface BrowserSessionManager<TSession = any> {
    /** Create a new browser session */
    create(options?: CreateBrowserSessionOptions): Promise<ProviderBrowserSession<TSession>>;
    /** Get an existing session by ID */
    getById(sessionId: string): Promise<ProviderBrowserSession<TSession> | null>;
    /** List active sessions */
    list(): Promise<ProviderBrowserSession<TSession>[]>;
    /** Destroy/terminate a session */
    destroy(sessionId: string): Promise<void>;
}
/**
 * Browser profile manager
 */
interface BrowserProfileManager {
    /** Create a new profile */
    create(options?: CreateBrowserProfileOptions): Promise<BrowserProfile>;
    /** Get an existing profile */
    get(profileId: string): Promise<BrowserProfile | null>;
    /** List profiles */
    list(): Promise<BrowserProfile[]>;
    /** Delete a profile */
    delete(profileId: string): Promise<void>;
}
/**
 * Browser extension manager
 */
interface BrowserExtensionManager {
    /** Upload/create an extension */
    create(options: CreateBrowserExtensionOptions): Promise<BrowserExtension>;
    /** Get an extension by ID */
    get(extensionId: string): Promise<BrowserExtension | null>;
    /** Delete an extension */
    delete(extensionId: string): Promise<void>;
}
/**
 * Browser pool manager (pre-warmed instances)
 */
interface BrowserPoolManager<TSession = any> {
    /** Create a new pool */
    create(options: CreateBrowserPoolOptions): Promise<BrowserPool>;
    /** Get pool by ID */
    get(poolId: string): Promise<BrowserPool | null>;
    /** List pools */
    list(): Promise<BrowserPool[]>;
    /** Acquire a browser from the pool */
    acquire(poolId: string): Promise<ProviderBrowserSession<TSession>>;
    /** Release a browser back to the pool */
    release(poolId: string, sessionId: string): Promise<void>;
    /** Delete a pool */
    delete(poolId: string): Promise<void>;
}
/**
 * Browser log manager
 */
interface BrowserLogManager {
    /** Get logs for a session */
    list(sessionId: string): Promise<BrowserLog[]>;
}
/**
 * Browser recording manager
 */
interface BrowserRecordingManager {
    /** Get recording for a session */
    get(sessionId: string): Promise<BrowserRecording | null>;
}
/**
 * Browser page operations — native browser control (optional, provider-dependent)
 */
interface BrowserPageOperations<TSession = any> {
    /** Navigate to a URL */
    navigate(session: TSession, url: string): Promise<void>;
    /** Take a screenshot */
    screenshot(session: TSession, options?: ScreenshotOptions): Promise<Uint8Array>;
    /** Generate a PDF */
    pdf?(session: TSession, options?: PdfOptions): Promise<Uint8Array>;
    /** Evaluate JavaScript in the page context */
    evaluate(session: TSession, script: string): Promise<unknown>;
    /** Get the current page HTML */
    getContent(session: TSession): Promise<string>;
}
/**
 * Provider browser session — wraps raw session with provider methods
 * Analogous to ProviderSandbox for sandbox providers.
 */
interface ProviderBrowserSession<TSession = any> extends BrowserSession {
    /** Get the provider that created this session */
    getProvider(): BrowserProvider<TSession>;
    /** Get the native provider session instance */
    getInstance(): TSession;
    /** Destroy this session */
    destroy(): Promise<void>;
    /** Take a screenshot (delegates to provider page ops or throws) */
    screenshot(options?: ScreenshotOptions): Promise<Uint8Array>;
    /** Get session logs */
    getLogs(): Promise<BrowserLog[]>;
    /** Get session recording */
    getRecording(): Promise<BrowserRecording | null>;
}
/**
 * Browser provider interface — creates and manages browser sessions
 *
 * This is the top-level interface for browser providers, analogous to
 * the Provider interface for sandbox providers.
 */
interface BrowserProvider<TSession = any> {
    /** Provider name/type */
    readonly name: string;
    /** Session lifecycle management */
    readonly session: BrowserSessionManager<TSession>;
    /** Get CDP/WebSocket connection URL for a session */
    getConnectUrl(sessionId: string): Promise<string>;
    /** Optional profile management (Browserbase contexts, Kernel profiles) */
    readonly profile?: BrowserProfileManager;
    /** Optional extension management */
    readonly extension?: BrowserExtensionManager;
    /** Optional pool management (pre-warmed instances) */
    readonly pool?: BrowserPoolManager<TSession>;
    /** Optional log access */
    readonly logs?: BrowserLogManager;
    /** Optional recording access */
    readonly recording?: BrowserRecordingManager;
    /** Optional native page operations */
    readonly page?: BrowserPageOperations<TSession>;
}

/**
 * Provider Factory - Creates providers from method definitions
 *
 * Eliminates boilerplate by auto-generating Provider/Sandbox classes
 * from simple method definitions with automatic feature detection.
 */

/**
 * Flat sandbox method implementations - all operations in one place
 */
interface SandboxMethods<TSandbox = any, TConfig = any> {
    create: (config: TConfig, options?: CreateSandboxOptions) => Promise<{
        sandbox: TSandbox;
        sandboxId: string;
    }>;
    getById: (config: TConfig, sandboxId: string) => Promise<{
        sandbox: TSandbox;
        sandboxId: string;
    } | null>;
    list: (config: TConfig) => Promise<Array<{
        sandbox: TSandbox;
        sandboxId: string;
    }>>;
    destroy: (config: TConfig, sandboxId: string) => Promise<void>;
    runCommand: (sandbox: TSandbox, command: string, options?: RunCommandOptions) => Promise<CommandResult>;
    getInfo: (sandbox: TSandbox) => Promise<SandboxInfo>;
    getUrl: (sandbox: TSandbox, options: {
        port: number;
        protocol?: string;
    }) => Promise<string>;
    getInstance?: (sandbox: TSandbox) => TSandbox;
    filesystem?: {
        readFile: (sandbox: TSandbox, path: string, runCommand: (sandbox: TSandbox, command: string, options?: RunCommandOptions) => Promise<CommandResult>) => Promise<string>;
        writeFile: (sandbox: TSandbox, path: string, content: string, runCommand: (sandbox: TSandbox, command: string, options?: RunCommandOptions) => Promise<CommandResult>) => Promise<void>;
        mkdir: (sandbox: TSandbox, path: string, runCommand: (sandbox: TSandbox, command: string, options?: RunCommandOptions) => Promise<CommandResult>) => Promise<void>;
        readdir: (sandbox: TSandbox, path: string, runCommand: (sandbox: TSandbox, command: string, options?: RunCommandOptions) => Promise<CommandResult>) => Promise<FileEntry[]>;
        exists: (sandbox: TSandbox, path: string, runCommand: (sandbox: TSandbox, command: string, options?: RunCommandOptions) => Promise<CommandResult>) => Promise<boolean>;
        remove: (sandbox: TSandbox, path: string, runCommand: (sandbox: TSandbox, command: string, options?: RunCommandOptions) => Promise<CommandResult>) => Promise<void>;
    };
}
/**
 * Template method implementations
 */
interface TemplateMethods<TTemplate = any, TConfig = any, TCreateOptions extends CreateTemplateOptions = CreateTemplateOptions> {
    create: (config: TConfig, options: TCreateOptions) => Promise<TTemplate>;
    list: (config: TConfig, options?: ListTemplatesOptions) => Promise<TTemplate[]>;
    delete: (config: TConfig, templateId: string) => Promise<void>;
}
/**
 * Snapshot method implementations
 */
interface SnapshotMethods<TSnapshot = any, TConfig = any> {
    create: (config: TConfig, sandboxId: string, options?: CreateSnapshotOptions) => Promise<TSnapshot>;
    list: (config: TConfig, options?: ListSnapshotsOptions) => Promise<TSnapshot[]>;
    delete: (config: TConfig, snapshotId: string) => Promise<void>;
}
/**
 * Provider configuration for defineProvider()
 */
interface ProviderConfig<TSandbox = any, TConfig = any, TTemplate = any, TSnapshot = any> {
    name: string;
    methods: {
        sandbox: SandboxMethods<TSandbox, TConfig>;
        template?: TemplateMethods<TTemplate, TConfig>;
        snapshot?: SnapshotMethods<TSnapshot, TConfig>;
    };
}
/**
 * Create a provider from method definitions
 *
 * Auto-generates all boilerplate classes and provides feature detection
 * based on which methods are implemented.
 */
declare function defineProvider<TSandbox, TConfig = any, TTemplate = any, TSnapshot = any>(providerConfig: ProviderConfig<TSandbox, TConfig, TTemplate, TSnapshot>): (config: TConfig) => Provider<TSandbox, TTemplate, TSnapshot>;

/**
 * Infrastructure Provider Factory
 *
 * Creates infrastructure-only providers that provision compute resources
 * but don't have native sandbox capabilities. Used by gateway server.
 */

/**
 * Infrastructure provider methods - only resource provisioning
 */
interface InfraProviderMethods<TInstance = any, TConfig = any> {
    /** Create a new compute instance */
    create: (config: TConfig, options?: CreateSandboxOptions & {
        daemonConfig?: DaemonConfig;
    }) => Promise<{
        instance: TInstance;
        instanceId: string;
    }>;
    /** Get an existing instance by ID */
    getById: (config: TConfig, instanceId: string) => Promise<{
        instance: TInstance;
        instanceId: string;
    } | null>;
    /** List all instances */
    list: (config: TConfig) => Promise<Array<{
        instance: TInstance;
        instanceId: string;
    }>>;
    /** Destroy an instance */
    destroy: (config: TConfig, instanceId: string) => Promise<void>;
}
/**
 * Daemon configuration passed to infrastructure providers
 */
interface DaemonConfig {
    /** Access token for daemon authentication */
    accessToken: string;
    /** Gateway URL for daemon to connect to */
    gatewayUrl?: string;
    /** Additional daemon environment variables */
    env?: Record<string, string>;
}
/**
 * Infrastructure provider configuration
 */
interface InfraProviderConfig<TInstance = any, TConfig = any> {
    name: string;
    methods: InfraProviderMethods<TInstance, TConfig>;
}
/**
 * Infrastructure provider interface returned by defineInfraProvider
 */
interface InfraProvider<TInstance = any> {
    name: string;
    create: (options?: CreateSandboxOptions & {
        daemonConfig?: DaemonConfig;
    }) => Promise<{
        instance: TInstance;
        instanceId: string;
    }>;
    getById: (instanceId: string) => Promise<{
        instance: TInstance;
        instanceId: string;
    } | null>;
    list: () => Promise<Array<{
        instance: TInstance;
        instanceId: string;
    }>>;
    destroy: (instanceId: string) => Promise<void>;
}
/**
 * Create an infrastructure provider from method definitions
 *
 * Infrastructure providers only handle resource provisioning.
 * The gateway server uses these to create VMs/containers with the ComputeSDK daemon pre-installed.
 *
 * @example
 * ```typescript
 * export const railway = defineInfraProvider<RailwayInstance, RailwayConfig>({
 *   name: 'railway',
 *   methods: {
 *     create: async (config, options) => {
 *       // Create Railway service with daemon docker image
 *       const service = await railwayAPI.createService({
 *         ...config,
 *         image: 'computesdk/daemon:latest',
 *         env: options?.daemonConfig ? {
 *           COMPUTESDK_ACCESS_TOKEN: options.daemonConfig.accessToken,
 *           COMPUTESDK_GATEWAY_URL: options.daemonConfig.gatewayUrl,
 *         } : {}
 *       });
 *       return { instance: service, instanceId: service.id };
 *     },
 *     destroy: async (config, instanceId) => {
 *       await railwayAPI.deleteService(config, instanceId);
 *     },
 *     getById: async (config, instanceId) => {
 *       const service = await railwayAPI.getService(config, instanceId);
 *       return service ? { instance: service, instanceId: service.id } : null;
 *     },
 *     list: async (config) => {
 *       const services = await railwayAPI.listServices(config);
 *       return services.map(s => ({ instance: s, instanceId: s.id }));
 *     }
 *   }
 * });
 *
 * // Gateway server usage:
 * const provider = railway({ apiKey, projectId, environmentId });
 * const { instance, instanceId } = await provider.create({
 *   daemonConfig: { accessToken: 'token_xxx' }
 * });
 * ```
 */
declare function defineInfraProvider<TInstance, TConfig = any>(config: InfraProviderConfig<TInstance, TConfig>): (providerConfig: TConfig) => InfraProvider<TInstance>;

/**
 * Direct Mode Compute API
 *
 * Use this when you want to use providers directly without the gateway.
 * This is the "mother" talking directly to "children" providers.
 */

/**
 * Configuration for creating a compute instance with a provider
 */
interface CreateComputeConfig<TInstance = any> {
    /** The provider instance to use */
    defaultProvider?: Provider<TInstance>;
    /** Legacy alias for defaultProvider */
    provider?: Provider<TInstance>;
}
/**
 * Compute API for direct provider usage
 */
interface ComputeAPI<TInstance = any> {
    /** Sandbox management methods */
    sandbox: Provider<TInstance>['sandbox'];
    /** Get current configuration */
    getConfig(): CreateComputeConfig<TInstance> | null;
    /** Update configuration and return new compute instance */
    setConfig<TNewInstance = any>(config: CreateComputeConfig<TNewInstance>): ComputeAPI<TNewInstance>;
    /** Clear configuration */
    clearConfig(): void;
}
/**
 * Create a compute instance with a provider for direct mode
 *
 * @example
 * ```typescript
 * import { createCompute } from '@computesdk/provider';
 * import { e2bProvider } from '@computesdk/e2b';
 *
 * const provider = e2bProvider({ apiKey: 'your-key' });
 * const compute = createCompute({ defaultProvider: provider });
 *
 * const sandbox = await compute.sandbox.create();
 * ```
 */
declare function createCompute<TInstance = any>(config: CreateComputeConfig<TInstance>): ComputeAPI<TInstance>;

/**
 * Browser Provider Factory - Creates browser providers from method definitions
 *
 * Eliminates boilerplate by auto-generating BrowserProvider/Session classes
 * from simple method definitions with automatic feature detection.
 * Mirrors the sandbox provider factory pattern.
 */

/**
 * Session method implementations that provider authors supply
 */
interface BrowserSessionMethods<TSession = any, TConfig = any> {
    create: (config: TConfig, options?: CreateBrowserSessionOptions) => Promise<{
        session: TSession;
        sessionId: string;
        connectUrl: string;
        status?: BrowserSession['status'];
    }>;
    getById: (config: TConfig, sessionId: string) => Promise<{
        session: TSession;
        sessionId: string;
        connectUrl: string;
        status?: BrowserSession['status'];
    } | null>;
    /**
     * List sessions. `connectUrl` may be omitted on entries when the provider's
     * list endpoint doesn't include it — callers needing a connectable URL
     * should use `provider.getConnectUrl(sessionId)`.
     */
    list: (config: TConfig) => Promise<Array<{
        session: TSession;
        sessionId: string;
        connectUrl?: string;
        status?: BrowserSession['status'];
    }>>;
    destroy: (config: TConfig, sessionId: string) => Promise<void>;
    getConnectUrl: (config: TConfig, sessionId: string) => Promise<string>;
}
/**
 * Profile method implementations
 */
interface BrowserProfileMethods<TConfig = any> {
    create: (config: TConfig, options?: CreateBrowserProfileOptions) => Promise<BrowserProfile>;
    get: (config: TConfig, profileId: string) => Promise<BrowserProfile | null>;
    list: (config: TConfig) => Promise<BrowserProfile[]>;
    delete: (config: TConfig, profileId: string) => Promise<void>;
}
/**
 * Extension method implementations
 */
interface BrowserExtensionMethods<TConfig = any> {
    create: (config: TConfig, options: CreateBrowserExtensionOptions) => Promise<BrowserExtension>;
    get: (config: TConfig, extensionId: string) => Promise<BrowserExtension | null>;
    delete: (config: TConfig, extensionId: string) => Promise<void>;
}
/**
 * Pool method implementations
 */
interface BrowserPoolMethods<TSession = any, TConfig = any> {
    create: (config: TConfig, options: CreateBrowserPoolOptions) => Promise<BrowserPool>;
    get: (config: TConfig, poolId: string) => Promise<BrowserPool | null>;
    list: (config: TConfig) => Promise<BrowserPool[]>;
    acquire: (config: TConfig, poolId: string) => Promise<{
        session: TSession;
        sessionId: string;
        connectUrl: string;
    }>;
    release: (config: TConfig, poolId: string, sessionId: string) => Promise<void>;
    delete: (config: TConfig, poolId: string) => Promise<void>;
}
/**
 * Log method implementations
 */
interface BrowserLogMethods<TConfig = any> {
    list: (config: TConfig, sessionId: string) => Promise<BrowserLog[]>;
}
/**
 * Recording method implementations
 */
interface BrowserRecordingMethods<TConfig = any> {
    get: (config: TConfig, sessionId: string) => Promise<BrowserRecording | null>;
}
/**
 * Page operation method implementations
 */
interface BrowserPageMethods<TSession = any> {
    navigate: (session: TSession, url: string) => Promise<void>;
    screenshot: (session: TSession, options?: ScreenshotOptions) => Promise<Uint8Array>;
    pdf?: (session: TSession, options?: PdfOptions) => Promise<Uint8Array>;
    evaluate: (session: TSession, script: string) => Promise<unknown>;
    getContent: (session: TSession) => Promise<string>;
}
/**
 * Full browser provider configuration for defineBrowserProvider()
 */
interface BrowserProviderConfig<TSession = any, TConfig = any> {
    name: string;
    methods: {
        session: BrowserSessionMethods<TSession, TConfig>;
        profile?: BrowserProfileMethods<TConfig>;
        extension?: BrowserExtensionMethods<TConfig>;
        pool?: BrowserPoolMethods<TSession, TConfig>;
        logs?: BrowserLogMethods<TConfig>;
        recording?: BrowserRecordingMethods<TConfig>;
        page?: BrowserPageMethods<TSession>;
    };
}
/**
 * Create a browser provider from method definitions
 *
 * Auto-generates all boilerplate classes and provides feature detection
 * based on which methods are implemented.
 *
 * @example
 * ```ts
 * export const browserbase = defineBrowserProvider<BrowserbaseSession, BrowserbaseConfig>({
 *   name: 'browserbase',
 *   methods: {
 *     session: { create, getById, list, destroy, getConnectUrl },
 *     profile: { create, get, list, delete },
 *     logs: { list: getLogs },
 *     recording: { get: getRecording },
 *   },
 * });
 *
 * // Usage:
 * const provider = browserbase({ apiKey: 'bb_...' });
 * const session = await provider.session.create({ stealth: true });
 * console.log(session.connectUrl);
 * ```
 */
declare function defineBrowserProvider<TSession, TConfig = any>(providerConfig: BrowserProviderConfig<TSession, TConfig>): (config: TConfig) => BrowserProvider<TSession>;

/**
 * Utility functions for ComputeSDK
 */
/**
 * Calculate exponential backoff delay with jitter
 *
 * Uses exponential backoff (2^attempt) multiplied by base delay,
 * plus random jitter to prevent thundering herd.
 *
 * @param attempt - Current retry attempt (0-indexed)
 * @param baseDelay - Base delay in milliseconds (default: 1000)
 * @param jitterMax - Maximum random jitter in milliseconds (default: 100)
 * @returns Delay in milliseconds
 *
 * @example
 * ```typescript
 * // First retry: 1000-1100ms
 * calculateBackoff(0);
 *
 * // Second retry: 2000-2100ms
 * calculateBackoff(1);
 *
 * // Third retry: 4000-4100ms
 * calculateBackoff(2);
 * ```
 */
declare function calculateBackoff(attempt: number, baseDelay?: number, jitterMax?: number): number;
/**
 * Escapes a string for safe use in shell commands
 *
 * Escapes special shell characters to prevent command injection.
 * Use this when interpolating user-controlled values into shell commands.
 *
 * @param arg - The string to escape
 * @returns Escaped string safe for shell interpolation
 *
 * @example
 * ```typescript
 * const path = '/path/with spaces';
 * const command = `cd "${escapeShellArg(path)}" && ls`;
 * // Result: cd "/path/with\ spaces" && ls
 *
 * const env = { KEY: 'value with $pecial chars' };
 * const command = `KEY="${escapeShellArg(env.KEY)}" npm run build`;
 * // Result: KEY="value with \$pecial chars" npm run build
 * ```
 */
declare function escapeShellArg(arg: string): string;

export { type BlaxelProviderConfig, type BrowserExtension, type BrowserExtensionManager, type BrowserExtensionMethods, type BrowserLog, type BrowserLogManager, type BrowserLogMethods, type BrowserPageMethods, type BrowserPageOperations, type BrowserPool, type BrowserPoolManager, type BrowserPoolMethods, type BrowserProfile, type BrowserProfileManager, type BrowserProfileMethods, type BrowserProvider, type BrowserProviderConfig, type BrowserRecording, type BrowserRecordingManager, type BrowserRecordingMethods, type BrowserSession, type BrowserSessionManager, type BrowserSessionMethods, type CloudflareProviderConfig, type CodesandboxProviderConfig, type ComputeAPI, type ComputeConfig, type CreateBrowserExtensionOptions, type CreateBrowserPoolOptions, type CreateBrowserProfileOptions, type CreateBrowserSessionOptions, type CreateComputeConfig, type CreateSandboxParams, type CreateSandboxParamsWithOptionalProvider, type CreateSnapshotOptions, type CreateTemplateOptions, type DaemonConfig, type DaytonaProviderConfig, type DownloadResult, type E2BProviderConfig, type ExtractProviderSandboxType, type InfraProvider, type InfraProviderConfig, type InfraProviderMethods, type ListOptions, type ListResult, type ListSnapshotsOptions, type ListTemplatesOptions, type ModalProviderConfig, type PdfOptions, type Provider, type ProviderBrowserSession, type ProviderConfig, type ProviderSandbox, type ProviderSandboxManager, type ProviderSnapshotManager, type ProviderTemplateManager, type ProxyConfig, type RailwayProviderConfig, type RunloopProviderConfig, type SandboxMethods, type ScreenshotOptions, type SnapshotMethods, type StorageObject, type StorageProvider, type TemplateMethods, type TypedComputeAPI, type TypedProviderSandbox, type UploadOptions, type VercelProviderConfig, calculateBackoff, createCompute, defineBrowserProvider, defineInfraProvider, defineProvider, escapeShellArg };