import { IAsyncProvider } from "@hyperledger/cactus-common";
import { ConsortiumDatabase, Ledger } from "@hyperledger/cactus-core-api";
import { Configuration, BaseAPI } from "@hyperledger/cactus-core-api";
/**
 * Class responsible for providing additional functionality to the `DefaultApi`
 * classes of the generated clients (OpenAPI generator / typescript-axios).
 *
 * Each package (plugin) can define it's own OpenAPI spec which means that they
 * all can ship with their own `DefaultApi` class that is generated directly
 * from the respective OpenAPI spec of the package/plugin.
 *
 * The functionality provided by this class is meant to be common traits that
 * can be useful for all of those different `DefaultApi` implementations.
 *
 * One such common trait is the client side component of the routing that
 * decides which Cactus node to point the `ApiClient` towards (which is in
 * itself ends up being the act of routing).
 *
 * @see https://github.com/OpenAPITools/openapi-generator/blob/v5.0.0-beta2/modules/openapi-generator/src/main/resources/typescript-axios/apiInner.mustache#L337
 * @see https://github.com/OpenAPITools/openapi-generator/blob/v5.0.0/docs/generators/typescript-axios.md
 */
export declare class ApiClient extends BaseAPI {
    /**
     *
     * @param ctor
     */
    extendWith<T>(ctor: new (configuration?: Configuration) => T): T & this;
    /**
     * Builds the default `Consortium` provider that can be used by this object
     * to retrieve the Cactus Consortium metadata object when necessary (one such
     * case is when we need information about the consortium nodes to perform
     * routing requests to a specific ledger via a connector plugin, but later
     * other uses could be added as well).
     *
     * The `DefaultConsortiumProvider` class leverages the simplest consortium
     * plugin that we have at the time of this writing:
     * `@hyperledger/cactus-plugin-consortium-manual` which holds the consortium
     * metadata as pre-configured by the consortium operators.
     *
     * The pattern we use in the `ApiClient` class is that you can inject your
     * own `IAsyncProvider<Consortium>` implementation which then will be used
     * for routing information and in theory you can implement completely arbitrary
     * consortium management in your own consortium plugins which then Cactus
     * can use and leverage for the routing.
     * This allows us to support any exotic consortium management algorithms
     * that people may come up with such as storing the consortium definition in
     * a multi-sig smart contract or have the list of consortium nodes be powered
     * by some sort of automatic service discovery or anything else that people
     * might think of.
     *
     * @see {DefaultConsortiumProvider}
     */
    get defaultConsortiumDbProvider(): IAsyncProvider<ConsortiumDatabase>;
    ofLedger<T>(ledgerOrId: string | Ledger, ctor: new (configuration?: Configuration) => T, ctorArgs: Record<string, unknown>): Promise<ApiClient & T>;
}
