import { Principal } from '@icp-sdk/core/principal';
import { IDL } from '@icp-sdk/core/candid';
import { ActorInterface, Actor } from './pocket-ic-actor.js';
import { CanisterFixture, CreateCanisterOptions, CreateInstanceOptions, InstallCodeOptions, ReinstallCodeOptions, SetupCanisterOptions, UpgradeCanisterOptions, SubnetTopology, UpdateCanisterSettingsOptions, StartCanisterOptions, StopCanisterOptions, QueryCallOptions, UpdateCallOptions, PendingHttpsOutcall, MockPendingHttpsOutcallOptions } from './pocket-ic-types.js';
import { DeferredActor } from './pocket-ic-deferred-actor.js';
/**
 * This class represents the main PocketIC client.
 * It is responsible for interacting with the PocketIC server via the REST API.
 * See {@link PocketIcServer} for details on the server to use with this client.
 *
 * @category API
 *
 * @example
 * The easist way to use PocketIC is to use {@link setupCanister} convenience method:
 * ```ts
 * import { PocketIc, PocketIcServer } from '@dfinity/pic';
 * import { _SERVICE, idlFactory } from '../declarations';
 *
 * const wasmPath = resolve('..', '..', 'canister.wasm');
 *
 * const picServer = await PocketIcServer.start();
 * const pic = await PocketIc.create(picServer.getUrl());
 *
 * const fixture = await pic.setupCanister<_SERVICE>({ idlFactory, wasmPath });
 * const { actor } = fixture;
 *
 * // perform tests...
 *
 * await pic.tearDown();
 * await picServer.stop();
 * ```
 *
 * If more control is needed, then the {@link createCanister}, {@link installCode} and
 * {@link createActor} methods can be used directly:
 * ```ts
 * import { PocketIc, PocketIcServer } from '@dfinity/pic';
 * import { _SERVICE, idlFactory } from '../declarations';
 *
 * const wasm = resolve('..', '..', 'canister.wasm');
 *
 * const picServer = await PocketIcServer.start();
 * const pic = await PocketIc.create(picServer.getUrl());
 *
 * const canisterId = await pic.createCanister();
 * await pic.installCode({ canisterId, wasm });
 * const actor = pic.createActor<_SERVICE>({ idlFactory, canisterId });
 *
 * // perform tests...
 *
 * await pic.tearDown();
 * await picServer.stop();
 * ```
 */
export declare class PocketIc {
    private readonly client;
    private constructor();
    /**
     * Creates a PocketIC instance.
     *
     * @param url The URL of an existing PocketIC server to connect to.
     * @param options Options for creating the PocketIC instance see {@link CreateInstanceOptions}.
     * @returns A new PocketIC instance.
     *
     * @example
     * ```ts
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * const fixture = await pic.setupCanister<_SERVICE>({ idlFactory, wasmPath });
     * const { actor } = fixture;
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    static create(url: string, options?: CreateInstanceOptions): Promise<PocketIc>;
    /**
     * A convenience method that creates a new canister,
     * installs the given WASM module to it and returns a typesafe {@link Actor}
     * that implements the Candid interface of the canister.
     * To just create a canister, see {@link createCanister}.
     * To just install code to an existing canister, see {@link installCode}.
     * To just create an Actor for an existing canister, see {@link createActor}.
     *
     * @param options Options for setting up the canister, see {@link SetupCanisterOptions}.
     * @returns The {@link Actor} instance.
     *
     * @see [Candid](https://internetcomputer.org/docs/current/references/candid-ref)
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     *
     * @example
     * ```ts
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     * import { _SERVICE, idlFactory } from '../declarations';
     *
     * const wasmPath = resolve('..', '..', 'canister.wasm');
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * const fixture = await pic.setupCanister<_SERVICE>({ idlFactory, wasmPath });
     * const { actor } = fixture;
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    setupCanister<T extends ActorInterface<T> = ActorInterface>({ sender, arg, wasm, idlFactory, computeAllocation, controllers, cycles, freezingThreshold, memoryAllocation, targetCanisterId, targetSubnetId, reservedCyclesLimit, }: SetupCanisterOptions): Promise<CanisterFixture<T>>;
    /**
     * Creates a new canister.
     * For a more convenient way of creating a PocketIC instance,
     * creating a canister and installing code, see {@link setupCanister}.
     *
     * @param options Options for creating the canister, see {@link CreateCanisterOptions}.
     * @returns The Principal of the newly created canister.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     *
     * @example
     * ```ts
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * const canisterId = await pic.createCanister();
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    createCanister({ sender, cycles, controllers, computeAllocation, freezingThreshold, memoryAllocation, reservedCyclesLimit, targetCanisterId, targetSubnetId, }?: CreateCanisterOptions): Promise<Principal>;
    /**
     * Starts the given canister.
     *
     * @param options Options for starting the canister, see {@link StartCanisterOptions}.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * await pic.startCanister({ canisterId });
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    startCanister({ canisterId, sender, targetSubnetId, }: StartCanisterOptions): Promise<void>;
    /**
     * Stops the given canister.
     *
     * @param options Options for stopping the canister, see {@link StopCanisterOptions}.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * await pic.stopCanister({ canisterId });
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    stopCanister({ canisterId, sender, targetSubnetId, }: StopCanisterOptions): Promise<void>;
    /**
     * Installs the given WASM module to the provided canister.
     * To create a canister to install code to, see {@link createCanister}.
     * For a more convenient way of creating a PocketIC instance,
     * creating a canister and installing code, see {@link setupCanister}.
     *
     * @param options Options for installing the code, see {@link InstallCodeOptions}.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     * import { resolve } from 'node:path';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     * const wasm = resolve('..', '..', 'canister.wasm');
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * await pic.installCode({ canisterId, wasm });
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    installCode({ arg, sender, canisterId, wasm, targetSubnetId, }: InstallCodeOptions): Promise<void>;
    /**
     * Reinstalls the given WASM module to the provided canister.
     * This will reset both the canister's heap and its stable memory.
     * To create a canister to upgrade, see {@link createCanister}.
     * To install the initial WASM module to a new canister, see {@link installCode}.
     *
     * @param options Options for reinstalling the code, see {@link ReinstallCodeOptions}.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     * import { resolve } from 'node:path';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     * const wasm = resolve('..', '..', 'canister.wasm');
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * await pic.reinstallCode({ canisterId, wasm });
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    reinstallCode({ sender, arg, canisterId, wasm, }: ReinstallCodeOptions): Promise<void>;
    /**
     * Upgrades the given canister with the given WASM module.
     * This will reset the canister's heap, but preserve stable memory.
     * To create a canister to upgrade to, see {@link createCanister}.
     * To install the initial WASM module to a new canister, see {@link installCode}.
     *
     * @param options Options for upgrading the canister, see {@link UpgradeCanisterOptions}.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     * import { resolve } from 'node:path';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     * const wasm = resolve('..', '..', 'canister.wasm');
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * await pic.upgradeCanister({ canisterId, wasm });
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    upgradeCanister({ sender, arg, canisterId, wasm, }: UpgradeCanisterOptions): Promise<void>;
    /**
     * Updates the settings of the given canister.
     *
     * @param options Options for updating the canister settings, see {@link UpdateCanisterSettingsOptions}.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * await pic.updateCanisterSettings({
     *  canisterId,
     *  controllers: [Principal.fromUint8Array(new Uint8Array([1]))],
     * });
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    updateCanisterSettings({ canisterId, computeAllocation, controllers, freezingThreshold, memoryAllocation, reservedCyclesLimit, sender, }: UpdateCanisterSettingsOptions): Promise<void>;
    /**
     * Creates an {@link Actor} for the given canister.
     * An {@link Actor} is a typesafe class that implements the Candid interface of a canister.
     * To create a canister for the {@link Actor}, see {@link createCanister}.
     * For a more convenient way of creating a PocketIC instance,
     * creating a canister and installing code, see {@link setupCanister}.
     *
     * @param interfaceFactory The InterfaceFactory to use for the {@link Actor}.
     * @param canisterId The Principal of the canister to create the {@link Actor} for.
     * @typeparam T The type of the {@link Actor}. Must implement {@link ActorInterface}.
     * @returns The {@link Actor} instance.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     * @see [InterfaceFactory](https://agent-js.icp.xyz/candid/modules/IDL.html#InterfaceFactory)
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     * import { _SERVICE, idlFactory } from '../declarations';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     * const wasm = resolve('..', '..', 'canister.wasm');
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * const canisterId = await pic.createCanister();
     * await pic.installCode({ canisterId, wasm });
     * const actor = pic.createActor<_SERVICE>({ idlFactory, canisterId });
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    createActor<T extends ActorInterface<T> = ActorInterface>(interfaceFactory: IDL.InterfaceFactory, canisterId: Principal): Actor<T>;
    /**
     * Creates a {@link DeferredActor} for the given canister.
     * A {@link DeferredActor} is a typesafe class that implements the Candid interface of a canister.
     *
     * A {@link DeferredActor} in contrast to a normal {@link Actor} will submit the call to the PocketIc replica,
     * but the call will not be executed immediately. Instead, the calls are queued and a `Promise` is returned
     * by the {@link DeferredActor} that can be awaited to process the pending canister call.
     *
     * To create a canister for the {@link DeferredActor}, see {@link createCanister}.
     * For a more convenient way of creating a PocketIC instance,
     * creating a canister and installing code, see {@link setupCanister}.
     *
     * @param interfaceFactory The InterfaceFactory to use for the {@link DeferredActor}.
     * @param canisterId The Principal of the canister to create the {@link DeferredActor} for.
     * @typeparam T The type of the {@link DeferredActor}. Must implement {@link ActorInterface}.
     * @returns The {@link DeferredActor} instance.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     * @see [InterfaceFactory](https://agent-js.icp.xyz/candid/modules/IDL.html#InterfaceFactory)
     *
     * @example
     */
    createDeferredActor<T extends ActorInterface<T> = ActorInterface>(interfaceFactory: IDL.InterfaceFactory, canisterId: Principal): DeferredActor<T>;
    /**
     * Makes a query call to the given canister.
     *
     * @param options Options for making the query call, see {@link QueryCallOptions}.
     * @returns The Candid-encoded response of the query call.
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     * import { _SERVICE, idlFactory } from '../declarations';
     *
     * const wasm = resolve('..', '..', 'canister.wasm');
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * canisterId = await pic.createCanister({
     *   sender: controllerIdentity.getPrincipal(),
     * });
     * await pic.installCode({ canisterId, wasm });
     *
     * const res = await pic.queryCall({
     *  canisterId,
     *  method: 'greet',
     * });
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    queryCall({ canisterId, method, arg, sender, targetSubnetId, }: QueryCallOptions): Promise<ArrayBufferLike>;
    /**
     * Makes an update call to the given canister.
     *
     * @param options Options for making the update call, see {@link UpdateCallOptions}.
     * @returns The Candid-encoded response of the update call.
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     * import { _SERVICE, idlFactory } from '../declarations';
     *
     * const wasm = resolve('..', '..', 'canister.wasm');
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * canisterId = await pic.createCanister({
     *   sender: controllerIdentity.getPrincipal(),
     * });
     * await pic.installCode({ canisterId, wasm });
     *
     * const res = await pic.updateCall({
     *  canisterId,
     *  method: 'greet',
     * });
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    updateCall({ canisterId, method, arg, sender, targetSubnetId, }: UpdateCallOptions): Promise<ArrayBufferLike>;
    /**
     * Deletes the PocketIC instance.
     *
     * @example
     * ```ts
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    tearDown(): Promise<void>;
    /**
     * Make the IC produce and progress by one block. Accepts a parameter `times` to tick multiple times,
     * the default is `1`.
     *
     * @param times The number of new blocks to produce and progress by. Defaults to `1`.
     *
     * ```ts
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * await pic.tick();
     *
     * // or to tick multiple times
     * await pic.tick(3);
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    tick(times?: number): Promise<void>;
    /**
     * Get the controllers of the specified canister.
     *
     * @param canisterId The Principal of the canister to get the controllers of.
     * @returns The controllers of the specified canister.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * const controllers = await pic.getControllers(canisterId);
     *
     * await pic.tearDown();
     * await picServer.stop();
     */
    getControllers(canisterId: Principal): Promise<Principal[]>;
    /**
     * Get the current time of the IC in milliseconds since the Unix epoch.
     *
     * @returns The current time in milliseconds since the UNIX epoch.
     *
     * @example
     * ```ts
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * const time = await pic.getTime();
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    getTime(): Promise<number>;
    /**
     * Reset the time of the IC to the current time.
     * {@link tick} should be called after calling this method in order for query calls
     * and read state request to reflect the new time.
     *
     * Use {@link resetCertifiedTime} to set time and immediately have query calls and
     * read state requests reflect the new time.
     *
     * @example
     * ```ts
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * await pic.resetTime();
     * await pic.tick();
     *
     * const time = await pic.getTime();
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    resetTime(): Promise<void>;
    /**
     * Reset the time of the IC to the current time and immediately have query calls and
     * read state requests reflect the new time.
     *
     * Use {@link resetTime} to reset time without immediately reflecting the new time.
     *
     * @example
     * ```ts
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * await pic.resetCertifiedTime();
     *
     * const time = await pic.getTime();
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    resetCertifiedTime(): Promise<void>;
    /**
     * Set the current time of the IC.
     * {@link tick} should be called after calling this method in order for query calls
     * and read state request to reflect the new time.
     *
     * Use {@link setCertifiedTime} to set time and immediately have query calls and
     * read state requests reflect the new time.
     *
     * @param time The time to set in milliseconds since the Unix epoch.
     *
     * @example
     * ```ts
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const pic = await PocketIc.create();
     *
     * const date = new Date();
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * await pic.setTime(date);
     * // or
     * await pic.setTime(date.getTime());
     *
     * await pic.tick();
     *
     * const time = await pic.getTime();
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    setTime(time: Date | number): Promise<void>;
    /**
     * Set the current time of the IC and immediately have query calls and
     * read state requests reflect the new time.
     *
     * Use {@link setTime} to set time without immediately reflecting the new time.
     *
     * @param time The time to set in milliseconds since the Unix epoch.
     *
     * @example
     * ```ts
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const pic = await PocketIc.create();
     *
     * const date = new Date();
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * await pic.setCertifiedTime(date);
     * // or
     * await pic.setCertifiedTime(date.getTime());
     *
     * const time = await pic.getTime();
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    setCertifiedTime(time: Date | number): Promise<void>;
    /**
     * Advance the time of the IC by the given duration in milliseconds.
     * {@link tick} should be called after calling this method in order for query calls
     * and read state requests to reflect the new time.
     *
     * Use {@link advanceCertifiedTime} to advance time and immediately have query calls and
     * read state requests reflect the new time.
     *
     * @param duration The duration to advance the time by.
     *
     * @example
     * ```ts
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * const initialTime = await pic.getTime();
     * await pic.advanceTime(1_000);
     * await pic.tick();
     *
     * const newTime = await pic.getTime();
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    advanceTime(duration: number): Promise<void>;
    /**
     * Advance the time of the IC by the given duration in milliseconds and
     * immediately have query calls and read state requests reflect the new time.
     *
     * Use {@link advanceTime} to advance time without immediately reflecting the new time.
     *
     * @param duration The duration to advance the time by.
     *
     * @example
     * ```ts
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * const initialTime = await pic.getTime();
     * await pic.advanceCertifiedTime(1_000);
     *
     * const newTime = await pic.getTime();
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    advanceCertifiedTime(duration: number): Promise<void>;
    /**
     * Fetch the public key of the specified subnet.
     *
     * @param subnetId The Principal of the subnet to fetch the public key of.
     * @returns The public key of the specified subnet.
     *
     * @example
     * ```ts
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * const subnets = pic.getApplicationSubnets();
     * const pubKey = await pic.getPubKey(subnets[0].id);
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    getPubKey(subnetId: Principal): Promise<ArrayBufferLike>;
    /**
     * Gets the subnet Id of the provided canister Id.
     *
     * @param canisterId The Principal of the canister to get the subnet Id of.
     * @returns The canister's subnet Id if the canister exists, `null` otherwise.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     *
     * @example
     * ```ts
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * const subnetId = await pic.getCanisterSubnetId(canisterId);
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    getCanisterSubnetId(canisterId: Principal): Promise<Principal | null>;
    /**
     * Get the topology of this instance's network.
     * The topology is a list of subnets, each with a type and a list of canister ID ranges
     * that can be deployed to that subnet.
     * The instance network topology is configured via the {@link create} method.
     *
     * @returns An array of subnet topologies, see {@link SubnetTopology}.
     */
    getTopology(): Promise<SubnetTopology[]>;
    /**
     * Get the Bitcoin subnet topology for this instance's network.
     * The instance network topology is configured via the {@link create} method.
     *
     * @returns The subnet topology for the Bitcoin subnet,
     * if it exists on this instance's network.
     */
    getBitcoinSubnet(): Promise<SubnetTopology | undefined>;
    /**
     * Get the Fiduciary subnet topology for this instance's network.
     * The instance network topology is configured via the {@link create} method.
     *
     * @returns The subnet topology for the Fiduciary subnet,
     * if it exists on this instance's network.
     */
    getFiduciarySubnet(): Promise<SubnetTopology | undefined>;
    /**
     * Get the Internet Identity subnet topology for this instance's network.
     * The instance network topology is configured via the {@link create} method.
     *
     * @returns The subnet topology for the Internet Identity subnet,
     * if it exists on this instance's network.
     */
    getInternetIdentitySubnet(): Promise<SubnetTopology | undefined>;
    /**
     * Get the NNS subnet topology for this instance's network.
     * The instance network topology is configured via the {@link create} method.
     *
     * @returns The subnet topology for the NNS subnet,
     * if it exists on this instance's network.
     */
    getNnsSubnet(): Promise<SubnetTopology | undefined>;
    /**
     * Get the SNS subnet topology for this instance's network.
     * The instance network topology is configured via the {@link create} method.
     *
     * @returns The subnet topology for the SNS subnet,
     * if it exists on this instance's network.
     */
    getSnsSubnet(): Promise<SubnetTopology | undefined>;
    /**
     * Get all application subnet topologies for this instance's network.
     * The instance network topology is configured via the {@link create} method.
     *
     * @returns An array of subnet topologies for each application subnet
     * that exists on this instance's network.
     */
    getApplicationSubnets(): Promise<SubnetTopology[]>;
    /**
     * Get all system subnet topologies for this instance's network.
     * The instance network topology is configured via the {@link create} method.
     *
     * @returns An array of subnet topologies for each system subnet
     * that exists on this instance's network.
     */
    getSystemSubnets(): Promise<SubnetTopology[]>;
    /**
     * Gets the current cycle balance of the specified canister.
     *
     * @param canisterId The Principal of the canister to check.
     * @returns The current cycles balance of the canister.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * const cyclesBalance = await pic.getCyclesBalance(canisterId);
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    getCyclesBalance(canisterId: Principal): Promise<number>;
    /**
     * Add cycles to the specified canister.
     *
     * @param canisterId The Principal of the canister to add cycles to.
     * @param amount The amount of cycles to add.
     * @returns The new cycle balance of the canister.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * const newCyclesBalance = await pic.addCycles(canisterId, 10_000_000);
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    addCycles(canisterId: Principal, amount: number): Promise<number>;
    /**
     * Set the stable memory of a given canister.
     *
     * @param canisterId The Principal of the canister to set the stable memory of.
     * @param stableMemory A blob containing the stable memory to set.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     * const stableMemory = new Uint8Array([0, 1, 2, 3, 4]);
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * await pic.setStableMemory(canisterId, stableMemory);
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    setStableMemory(canisterId: Principal, stableMemory: ArrayBufferLike): Promise<void>;
    /**
     * Get the stable memory of a given canister.
     *
     * @param canisterId The Principal of the canister to get the stable memory of.
     * @returns A blob containing the canister's stable memory.
     *
     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * const stableMemory = await pic.getStableMemory(canisterId);
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    getStableMemory(canisterId: Principal): Promise<ArrayBufferLike>;
    /**
     * Get all pending HTTPS Outcalls across all subnets on this
     * PocketIC instance.
     *
     * @returns An array of pending HTTPS Outcalls.
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * // queue the canister message that will send the HTTPS Outcall
     * const executeGoogleSearch = await deferredActor.google_search();
     *
     * // tick for two rounds to allow the canister message to be processed
     * // and for the HTTPS Outcall to be queued
     * await pic.tick(2);
     *
     * // get all queued HTTPS Outcalls
     * const pendingHttpsOutcalls = await pic.getPendingHttpsOutcalls();
     *
     * // get the first pending HTTPS Outcall
     * const pendingGoogleSearchOutcall = pendingHttpsOutcalls[0];
     *
     * // mock the HTTPS Outcall
     * await pic.mockPendingHttpsOutcall({
     *   requestId: pendingGoogleSearchOutcall.requestId,
     *   subnetId: pendingGoogleSearchOutcall.subnetId,
     *   response: {
     *     type: 'success',
     *     body: new TextEncoder().encode('Google search result'),
     *     statusCode: 200,
     *     headers: [],
     *   },
     * });
     *
     * // finish executing the message, including the HTTPS Outcall
     * const result = await executeGoogleSearch();
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    getPendingHttpsOutcalls(): Promise<PendingHttpsOutcall[]>;
    /**
     * Mock a pending HTTPS Outcall.
     *
     * @param options Options for mocking the pending HTTPS Outcall, see {@link MockPendingHttpsOutcallOptions}.
     *
     * @example
     * ```ts
     * import { Principal } from '@icp-sdk/core/principal';
     * import { PocketIc, PocketIcServer } from '@dfinity/pic';
     *
     * const canisterId = Principal.fromUint8Array(new Uint8Array([0]));
     *
     * const picServer = await PocketIcServer.start();
     * const pic = await PocketIc.create(picServer.getUrl());
     *
     * // queue the canister message that will send the HTTPS Outcall
     * const executeGoogleSearch = await deferredActor.google_search();
     *
     * // tick for two rounds to allow the canister message to be processed
     * // and for the HTTPS Outcall to be queued
     * await pic.tick(2);
     *
     * // get all queued HTTPS Outcalls
     * const pendingHttpsOutcalls = await pic.getPendingHttpsOutcalls();
     *
     * // get the first pending HTTPS Outcall
     * const pendingGoogleSearchOutcall = pendingHttpsOutcalls[0];
     *
     * // mock the HTTPS Outcall
     * await pic.mockPendingHttpsOutcall({
     *   requestId: pendingGoogleSearchOutcall.requestId,
     *   subnetId: pendingGoogleSearchOutcall.subnetId,
     *   response: {
     *     type: 'success',
     *     body: new TextEncoder().encode('Google search result'),
     *     statusCode: 200,
     *     headers: [],
     *   },
     * });
     *
     * // finish executing the message, including the HTTPS Outcall
     * const result = await executeGoogleSearch();
     *
     * await pic.tearDown();
     * await picServer.stop();
     * ```
     */
    mockPendingHttpsOutcall({ requestId, response, subnetId, additionalResponses, }: MockPendingHttpsOutcallOptions): Promise<void>;
}