/// <reference types="node" />
/// <reference types="koa-joi-router" />
/// <reference types="koa-bodyparser" />
/// <reference types="pino-http" />
/// <reference types="koa-pino-logger" />
import Koa, { Middleware } from 'koa';
import { Router } from './services/router';
import { IlpPacketMiddlewareOptions, RafikiPrepare } from './middleware/ilp-packet';
import { PeerMiddlewareOptions } from './middleware/peer';
import { PeersService, Peer } from './services/peers';
import { AuthState } from './middleware/auth';
import { TokenAuthConfig } from './middleware/token-auth';
import { AccountSnapshot, AccountsService } from './services/accounts';
import { LoggingService } from './services/logger';
import { IncomingMessage, ServerResponse } from 'http';
import { IlpReply, IlpReject, IlpFulfill } from 'ilp-packet';
import { AccountMiddlewareOptions } from './middleware/account';
export interface RafikiServices {
    router: Router;
    peers: PeersService;
    accounts: AccountsService;
    logger: LoggingService;
}
export interface RafikiIlpConfig extends IlpPacketMiddlewareOptions, PeerMiddlewareOptions, AccountMiddlewareOptions {
    path?: string;
}
export declare type RafikiState<T> = T & AuthState;
export declare type RafikiRequestMixin = {
    prepare: RafikiPrepare;
    rawPrepare: Buffer;
};
export declare type RafikiResponseMixin = {
    reject?: IlpReject;
    rawReject?: Buffer;
    fulfill?: IlpFulfill;
    rawFulfill?: Buffer;
    reply?: IlpReply;
    rawReply?: Buffer;
};
export declare type RafikiRequest = Koa.Request & RafikiRequestMixin;
export declare type RafikiResponse = Koa.Response & RafikiResponseMixin;
export declare type RafikiContextMixin = {
    services: RafikiServices;
    peers: {
        readonly incoming: Promise<Peer>;
        readonly outgoing: Promise<Peer>;
    };
    accounts: {
        readonly incoming: Promise<AccountSnapshot>;
        readonly outgoing: Promise<AccountSnapshot>;
    };
    request: RafikiRequest;
    response: RafikiResponse;
    req: IncomingMessage & RafikiRequestMixin;
    res: ServerResponse & RafikiResponseMixin;
};
export declare type RafikiContext<T = any> = Koa.ParameterizedContext<T, RafikiContextMixin>;
export declare type RafikiMiddleware<T = any> = Middleware<T, RafikiContextMixin>;
export declare class Rafiki<T = any> extends Koa<T, RafikiContextMixin> {
    private _router?;
    private _peers?;
    private _accounts?;
    constructor(config?: Partial<RafikiServices>);
    router: Router | undefined;
    peers: PeersService | undefined;
    accounts: AccountsService | undefined;
    logger: LoggingService;
    useIlp(config?: RafikiIlpConfig): void;
}
interface RafikiCreateAppServices extends RafikiServices {
    auth: RafikiMiddleware<AuthState> | Partial<TokenAuthConfig>;
}
export declare function createAuthMiddleware(auth?: RafikiMiddleware<AuthState> | Partial<TokenAuthConfig>): RafikiMiddleware;
export declare function createApp({ auth, peers, accounts, router, logger }: Partial<RafikiCreateAppServices>, config?: RafikiIlpConfig): Rafiki;
export declare class RafikiRouter {
    private _router;
    constructor();
    ilpRoute(ilpAddressPattern: string, handler: RafikiMiddleware<any>): void;
    routes(): RafikiMiddleware<any>;
}
export {};