import type { NormalizedSuperJsonDocument, SecurityValues } from '@superfaceai/ast';
import type { IConfig, ICrypto, IFileSystem, ILogger, ITimers, IUseCase, LogFunction, PerformError } from '../../interfaces';
import { PerformOptions } from '../../interfaces';
import type { ISandbox } from '../../interfaces/sandbox';
import type { NonPrimitive, Result, SuperCache, Variables } from '../../lib';
import { UnexpectedError } from '../../lib';
import type { Events, Interceptable, InterceptableMetadata } from '../events';
import type { AuthCache, IFetch } from '../interpreter';
import type { ProfileBase } from '../profile';
import type { IBoundProfileProvider } from '../profile-provider';
import type { Provider } from '../provider';
export declare function resolveSecurityValues(security?: SecurityValues[] | {
    [id: string]: Omit<SecurityValues, 'id'>;
}, logFunction?: LogFunction): SecurityValues[] | undefined;
export declare type ProviderProvider = {
    getProvider: (provider: string) => Promise<Provider>;
    getProviderForProfile: (profileId: string) => Promise<Provider>;
};
export declare abstract class UseCaseBase implements Interceptable {
    readonly profile: ProfileBase;
    readonly name: string;
    readonly events: Events;
    private readonly config;
    private readonly sandbox;
    private readonly superJson;
    private readonly timers;
    private readonly fileSystem;
    private readonly crypto;
    private readonly boundProfileProviderCache;
    private readonly fetchInstance;
    private readonly logger?;
    metadata: InterceptableMetadata;
    private boundProfileProvider;
    private readonly log;
    constructor(profile: ProfileBase, name: string, events: Events, config: IConfig, sandbox: ISandbox, superJson: NormalizedSuperJsonDocument | undefined, timers: ITimers, fileSystem: IFileSystem, crypto: ICrypto, boundProfileProviderCache: SuperCache<{
        provider: IBoundProfileProvider;
        expiresAt: number;
    }>, fetchInstance: IFetch & Interceptable & AuthCache, logger?: ILogger | undefined);
    private bind;
    private rebind;
    private performBoundUsecase;
    protected bindAndPerform<TInput extends NonPrimitive | undefined = Record<string, Variables | undefined>, TOutput = unknown>(input?: TInput, options?: PerformOptions): Promise<Result<TOutput, PerformError | UnexpectedError>>;
    private checkWarnFailoverMisconfiguration;
    private configureHookContext;
    protected toggleFailover(enabled: boolean): void;
    private instantiateFailurePolicy;
}
export declare class UseCase extends UseCaseBase implements IUseCase {
    perform<TInput extends NonPrimitive | undefined = Record<string, Variables | undefined>, TOutput = unknown>(input?: TInput, options?: PerformOptions): Promise<Result<TOutput, PerformError | UnexpectedError>>;
}