@junobuild/admin 0.0.12 → 0.0.14

package/declarations/ledger/ledger.did

@@ -0,0 +1,249 @@
+// This is the official Ledger interface that is guaranteed to be backward compatible.
+
+// Amount of tokens, measured in 10^-8 of a token.
+type Tokens = record {
+     e8s : nat64;
+};
+
+// Number of nanoseconds from the UNIX epoch in UTC timezone.
+type TimeStamp = record {
+    timestamp_nanos: nat64;
+};
+
+// AccountIdentifier is a 32-byte array.
+// The first 4 bytes is big-endian encoding of a CRC32 checksum of the last 28 bytes.
+type AccountIdentifier = blob;
+
+// Subaccount is an arbitrary 32-byte byte array.
+// Ledger uses subaccounts to compute the source address, which enables one
+// principal to control multiple ledger accounts.
+type SubAccount = blob;
+
+// Sequence number of a block produced by the ledger.
+type BlockIndex = nat64;
+
+// An arbitrary number associated with a transaction.
+// The caller can set it in a `transfer` call as a correlation identifier.
+type Memo = nat64;
+
+// Arguments for the `transfer` call.
+type TransferArgs = record {
+    // Transaction memo.
+    // See comments for the `Memo` type.
+    memo: Memo;
+    // The amount that the caller wants to transfer to the destination address.
+    amount: Tokens;
+    // The amount that the caller pays for the transaction.
+    // Must be 10000 e8s.
+    fee: Tokens;
+    // The subaccount from which the caller wants to transfer funds.
+    // If null, the ledger uses the default (all zeros) subaccount to compute the source address.
+    // See comments for the `SubAccount` type.
+    from_subaccount: opt SubAccount;
+    // The destination account.
+    // If the transfer is successful, the balance of this address increases by `amount`.
+    to: AccountIdentifier;
+    // The point in time when the caller created this request.
+    // If null, the ledger uses current IC time as the timestamp.
+    created_at_time: opt TimeStamp;
+};
+
+type TransferError = variant {
+    // The fee that the caller specified in the transfer request was not the one that ledger expects.
+    // The caller can change the transfer fee to the `expected_fee` and retry the request.
+    BadFee : record { expected_fee : Tokens; };
+    // The account specified by the caller doesn't have enough funds.
+    InsufficientFunds : record { balance: Tokens; };
+    // The request is too old.
+    // The ledger only accepts requests created within 24 hours window.
+    // This is a non-recoverable error.
+    TxTooOld : record { allowed_window_nanos: nat64 };
+    // The caller specified `created_at_time` that is too far in future.
+    // The caller can retry the request later.
+    TxCreatedInFuture : null;
+    // The ledger has already executed the request.
+    // `duplicate_of` field is equal to the index of the block containing the original transaction.
+    TxDuplicate : record { duplicate_of: BlockIndex; }
+};
+
+type TransferResult = variant {
+    Ok : BlockIndex;
+    Err : TransferError;
+};
+
+// Arguments for the `account_balance` call.
+type AccountBalanceArgs = record {
+    account: AccountIdentifier;
+};
+
+type TransferFeeArg = record {};
+
+type TransferFee = record {
+    // The fee to pay to perform a transfer
+    transfer_fee: Tokens;
+};
+
+type GetBlocksArgs = record {
+    // The index of the first block to fetch.
+    start : BlockIndex;
+    // Max number of blocks to fetch.
+    length : nat64;
+};
+
+type Operation = variant {
+    Mint : record {
+        to : AccountIdentifier;
+        amount : Tokens;
+    };
+    Burn : record {
+        from : AccountIdentifier;
+        amount : Tokens;
+    };
+    Transfer : record {
+        from : AccountIdentifier;
+        to : AccountIdentifier;
+        amount : Tokens;
+        fee : Tokens;
+    };
+};
+
+type Transaction = record {
+    memo : Memo;
+    operation : opt Operation;
+    created_at_time : TimeStamp;
+};
+
+type Block = record {
+    parent_hash : opt blob;
+    transaction : Transaction;
+    timestamp : TimeStamp;
+};
+
+// A prefix of the block range specified in the [GetBlocksArgs] request.
+type BlockRange = record {
+    // A prefix of the requested block range.
+    // The index of the first block is equal to [GetBlocksArgs.from].
+    //
+    // Note that the number of blocks might be less than the requested
+    // [GetBlocksArgs.len] for various reasons, for example:
+    //
+    // 1. The query might have hit the replica with an outdated state
+    //    that doesn't have the full block range yet.
+    // 2. The requested range is too large to fit into a single reply.
+    //
+    // NOTE: the list of blocks can be empty if:
+    // 1. [GetBlocksArgs.len] was zero.
+    // 2. [GetBlocksArgs.from] was larger than the last block known to the canister.
+    blocks : vec Block;
+};
+
+// An error indicating that the arguments passed to [QueryArchiveFn] were invalid.
+type QueryArchiveError = variant {
+    // [GetBlocksArgs.from] argument was smaller than the first block
+    // served by the canister that received the request.
+    BadFirstBlockIndex : record {
+        requested_index : BlockIndex;
+        first_valid_index : BlockIndex;
+    };
+
+    // Reserved for future use.
+    Other : record {
+        error_code : nat64;
+        error_message : text;
+    };
+};
+
+type QueryArchiveResult = variant {
+    // Successfully fetched zero or more blocks.
+    Ok : BlockRange;
+    // The [GetBlocksArgs] request was invalid.
+    Err : QueryArchiveError;
+};
+
+// A function that is used for fetching archived ledger blocks.
+type QueryArchiveFn = func (GetBlocksArgs) -> (QueryArchiveResult) query;
+
+// The result of a "query_blocks" call.
+//
+// The structure of the result is somewhat complicated because the main ledger canister might
+// not have all the blocks that the caller requested: One or more "archive" canisters might
+// store some of the requested blocks.
+//
+// Note: as of Q4 2021 when this interface is authored, the IC doesn't support making nested 
+// query calls within a query call.
+type QueryBlocksResponse = record {
+    // The total number of blocks in the chain.
+    // If the chain length is positive, the index of the last block is `chain_len - 1`.
+    chain_length : nat64;
+
+    // System certificate for the hash of the latest block in the chain.
+    // Only present if `query_blocks` is called in a non-replicated query context.
+    certificate : opt blob;
+
+    // List of blocks that were available in the ledger when it processed the call.
+    //
+    // The blocks form a contiguous range, with the first block having index
+    // [first_block_index] (see below), and the last block having index
+    // [first_block_index] + len(blocks) - 1.
+    //
+    // The block range can be an arbitrary sub-range of the originally requested range.
+    blocks : vec Block;
+
+    // The index of the first block in "blocks".
+    // If the blocks vector is empty, the exact value of this field is not specified.
+    first_block_index : BlockIndex;
+
+    // Encoding of instructions for fetching archived blocks whose indices fall into the
+    // requested range.
+    //
+    // For each entry `e` in [archived_blocks], `[e.from, e.from + len)` is a sub-range
+    // of the originally requested block range.
+    archived_blocks : vec record {
+        // The index of the first archived block that can be fetched using the callback.
+        start : BlockIndex;
+
+        // The number of blocks that can be fetch using the callback.
+        length : nat64;
+
+        // The function that should be called to fetch the archived blocks.
+        // The range of the blocks accessible using this function is given by [from]
+        // and [len] fields above.
+        callback : QueryArchiveFn;
+    };
+};
+
+type Archive = record {
+    canister_id: principal;
+};
+
+type Archives = record {
+    archives: vec Archive;
+};
+
+service : {
+  // Transfers tokens from a subaccount of the caller to the destination address.
+  // The source address is computed from the principal of the caller and the specified subaccount.
+  // When successful, returns the index of the block containing the transaction.
+  transfer : (TransferArgs) -> (TransferResult);
+
+  // Returns the amount of Tokens on the specified account.
+  account_balance : (AccountBalanceArgs) -> (Tokens) query;
+
+  // Returns the current transfer_fee.
+  transfer_fee : (TransferFeeArg) -> (TransferFee) query;
+
+  // Queries blocks in the specified range.
+  query_blocks : (GetBlocksArgs) -> (QueryBlocksResponse) query;
+
+  // Returns token symbol.
+  symbol : () -> (record { symbol: text }) query;
+
+  // Returns token name.
+  name : () -> (record { name: text }) query;
+
+  // Returns token decimals.
+  decimals : () -> (record { decimals: nat32 }) query;
+
+  // Returns the existing archive canisters information.
+  archives : () -> (Archives) query;
+}

package/declarations/ledger/ledger.did.d.ts

@@ -0,0 +1,100 @@
+import type {ActorMethod} from '@dfinity/agent';
+import type {Principal} from '@dfinity/principal';
+
+export interface AccountBalanceArgs {
+  account: AccountIdentifier;
+}
+export type AccountIdentifier = Uint8Array | number[];
+export interface Archive {
+  canister_id: Principal;
+}
+export interface Archives {
+  archives: Array<Archive>;
+}
+export interface Block {
+  transaction: Transaction;
+  timestamp: TimeStamp;
+  parent_hash: [] | [Uint8Array | number[]];
+}
+export type BlockIndex = bigint;
+export interface BlockRange {
+  blocks: Array<Block>;
+}
+export interface GetBlocksArgs {
+  start: BlockIndex;
+  length: bigint;
+}
+export type Memo = bigint;
+export type Operation =
+  | {
+      Burn: {from: AccountIdentifier; amount: Tokens};
+    }
+  | {Mint: {to: AccountIdentifier; amount: Tokens}}
+  | {
+      Transfer: {
+        to: AccountIdentifier;
+        fee: Tokens;
+        from: AccountIdentifier;
+        amount: Tokens;
+      };
+    };
+export type QueryArchiveError =
+  | {
+      BadFirstBlockIndex: {
+        requested_index: BlockIndex;
+        first_valid_index: BlockIndex;
+      };
+    }
+  | {Other: {error_message: string; error_code: bigint}};
+export type QueryArchiveFn = ActorMethod<[GetBlocksArgs], QueryArchiveResult>;
+export type QueryArchiveResult = {Ok: BlockRange} | {Err: QueryArchiveError};
+export interface QueryBlocksResponse {
+  certificate: [] | [Uint8Array | number[]];
+  blocks: Array<Block>;
+  chain_length: bigint;
+  first_block_index: BlockIndex;
+  archived_blocks: Array<{callback: QueryArchiveFn; start: BlockIndex; length: bigint}>;
+}
+export type SubAccount = Uint8Array | number[];
+export interface TimeStamp {
+  timestamp_nanos: bigint;
+}
+export interface Tokens {
+  e8s: bigint;
+}
+export interface Transaction {
+  memo: Memo;
+  operation: [] | [Operation];
+  created_at_time: TimeStamp;
+}
+export interface TransferArgs {
+  to: AccountIdentifier;
+  fee: Tokens;
+  memo: Memo;
+  from_subaccount: [] | [SubAccount];
+  created_at_time: [] | [TimeStamp];
+  amount: Tokens;
+}
+export type TransferError =
+  | {
+      TxTooOld: {allowed_window_nanos: bigint};
+    }
+  | {BadFee: {expected_fee: Tokens}}
+  | {TxDuplicate: {duplicate_of: BlockIndex}}
+  | {TxCreatedInFuture: null}
+  | {InsufficientFunds: {balance: Tokens}};
+export interface TransferFee {
+  transfer_fee: Tokens;
+}
+export type TransferFeeArg = {};
+export type TransferResult = {Ok: BlockIndex} | {Err: TransferError};
+export interface _SERVICE {
+  account_balance: ActorMethod<[AccountBalanceArgs], Tokens>;
+  archives: ActorMethod<[], Archives>;
+  decimals: ActorMethod<[], {decimals: number}>;
+  name: ActorMethod<[], {name: string}>;
+  query_blocks: ActorMethod<[GetBlocksArgs], QueryBlocksResponse>;
+  symbol: ActorMethod<[], {symbol: string}>;
+  transfer: ActorMethod<[TransferArgs], TransferResult>;
+  transfer_fee: ActorMethod<[TransferFeeArg], TransferFee>;
+}

package/declarations/ledger/ledger.factory.did.js

@@ -0,0 +1,98 @@
+export const idlFactory = ({IDL}) => {
+  const AccountIdentifier = IDL.Vec(IDL.Nat8);
+  const AccountBalanceArgs = IDL.Record({account: AccountIdentifier});
+  const Tokens = IDL.Record({e8s: IDL.Nat64});
+  const Archive = IDL.Record({canister_id: IDL.Principal});
+  const Archives = IDL.Record({archives: IDL.Vec(Archive)});
+  const BlockIndex = IDL.Nat64;
+  const GetBlocksArgs = IDL.Record({
+    start: BlockIndex,
+    length: IDL.Nat64
+  });
+  const Memo = IDL.Nat64;
+  const Operation = IDL.Variant({
+    Burn: IDL.Record({from: AccountIdentifier, amount: Tokens}),
+    Mint: IDL.Record({to: AccountIdentifier, amount: Tokens}),
+    Transfer: IDL.Record({
+      to: AccountIdentifier,
+      fee: Tokens,
+      from: AccountIdentifier,
+      amount: Tokens
+    })
+  });
+  const TimeStamp = IDL.Record({timestamp_nanos: IDL.Nat64});
+  const Transaction = IDL.Record({
+    memo: Memo,
+    operation: IDL.Opt(Operation),
+    created_at_time: TimeStamp
+  });
+  const Block = IDL.Record({
+    transaction: Transaction,
+    timestamp: TimeStamp,
+    parent_hash: IDL.Opt(IDL.Vec(IDL.Nat8))
+  });
+  const BlockRange = IDL.Record({blocks: IDL.Vec(Block)});
+  const QueryArchiveError = IDL.Variant({
+    BadFirstBlockIndex: IDL.Record({
+      requested_index: BlockIndex,
+      first_valid_index: BlockIndex
+    }),
+    Other: IDL.Record({
+      error_message: IDL.Text,
+      error_code: IDL.Nat64
+    })
+  });
+  const QueryArchiveResult = IDL.Variant({
+    Ok: BlockRange,
+    Err: QueryArchiveError
+  });
+  const QueryArchiveFn = IDL.Func([GetBlocksArgs], [QueryArchiveResult], ['query']);
+  const QueryBlocksResponse = IDL.Record({
+    certificate: IDL.Opt(IDL.Vec(IDL.Nat8)),
+    blocks: IDL.Vec(Block),
+    chain_length: IDL.Nat64,
+    first_block_index: BlockIndex,
+    archived_blocks: IDL.Vec(
+      IDL.Record({
+        callback: QueryArchiveFn,
+        start: BlockIndex,
+        length: IDL.Nat64
+      })
+    )
+  });
+  const SubAccount = IDL.Vec(IDL.Nat8);
+  const TransferArgs = IDL.Record({
+    to: AccountIdentifier,
+    fee: Tokens,
+    memo: Memo,
+    from_subaccount: IDL.Opt(SubAccount),
+    created_at_time: IDL.Opt(TimeStamp),
+    amount: Tokens
+  });
+  const TransferError = IDL.Variant({
+    TxTooOld: IDL.Record({allowed_window_nanos: IDL.Nat64}),
+    BadFee: IDL.Record({expected_fee: Tokens}),
+    TxDuplicate: IDL.Record({duplicate_of: BlockIndex}),
+    TxCreatedInFuture: IDL.Null,
+    InsufficientFunds: IDL.Record({balance: Tokens})
+  });
+  const TransferResult = IDL.Variant({
+    Ok: BlockIndex,
+    Err: TransferError
+  });
+  const TransferFeeArg = IDL.Record({});
+  const TransferFee = IDL.Record({transfer_fee: Tokens});
+  return IDL.Service({
+    account_balance: IDL.Func([AccountBalanceArgs], [Tokens], ['query']),
+    archives: IDL.Func([], [Archives], ['query']),
+    decimals: IDL.Func([], [IDL.Record({decimals: IDL.Nat32})], ['query']),
+    name: IDL.Func([], [IDL.Record({name: IDL.Text})], ['query']),
+    query_blocks: IDL.Func([GetBlocksArgs], [QueryBlocksResponse], ['query']),
+    symbol: IDL.Func([], [IDL.Record({symbol: IDL.Text})], ['query']),
+    transfer: IDL.Func([TransferArgs], [TransferResult], []),
+    transfer_fee: IDL.Func([TransferFeeArg], [TransferFee], ['query'])
+  });
+};
+export const init = ({IDL}) => {
+  return [];
+};

package/declarations/mission_control/index.d.ts

@@ -0,0 +1,45 @@
+import type {ActorConfig, ActorSubclass, Agent, HttpAgentOptions} from '@dfinity/agent';
+import type {IDL} from '@dfinity/candid';
+import type {Principal} from '@dfinity/principal';
+
+import {_SERVICE} from './mission_control.did';
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const canisterId: string;
+
+export declare interface CreateActorOptions {
+  /**
+   * @see {@link Agent}
+   */
+  agent?: Agent;
+  /**
+   * @see {@link HttpAgentOptions}
+   */
+  agentOptions?: HttpAgentOptions;
+  /**
+   * @see {@link ActorConfig}
+   */
+  actorOptions?: ActorConfig;
+}
+
+/**
+ * Intializes an {@link ActorSubclass}, configured with the provided SERVICE interface of a canister.
+ * @constructs {@link ActorSubClass}
+ * @param {string | Principal} canisterId - ID of the canister the {@link Actor} will talk to
+ * @param {CreateActorOptions} options - see {@link CreateActorOptions}
+ * @param {CreateActorOptions["agent"]} options.agent - a pre-configured agent you'd like to use. Supercedes agentOptions
+ * @param {CreateActorOptions["agentOptions"]} options.agentOptions - options to set up a new agent
+ * @see {@link HttpAgentOptions}
+ * @param {CreateActorOptions["actorOptions"]} options.actorOptions - options for the Actor
+ * @see {@link ActorConfig}
+ */
+export declare const createActor: (
+  canisterId: string | Principal,
+  options?: CreateActorOptions
+) => ActorSubclass<_SERVICE>;
+
+/**
+ * Intialized Actor using default settings, ready to talk to a canister using its candid interface
+ * @constructs {@link ActorSubClass}
+ */
+export declare const mission_control: ActorSubclass<_SERVICE>;

package/declarations/mission_control/index.js

@@ -0,0 +1,32 @@
+import {Actor, HttpAgent} from '@dfinity/agent';
+
+// Imports and re-exports candid interface
+import {idlFactory} from './mission_control.did.js';
+export {idlFactory} from './mission_control.did.js';
+
+// CANISTER_ID is replaced by webpack based on node environment
+
+export const createActor = (canisterId, options = {}) => {
+  const agent = options.agent || new HttpAgent({...options.agentOptions});
+
+  if (options.agent && options.agentOptions) {
+    console.warn(
+      'Detected both agent and agentOptions passed to createActor. Ignoring agentOptions and proceeding with the provided agent.'
+    );
+  }
+
+  // Fetch root key for certificate validation during development
+  if (process.env.DFX_NETWORK !== 'ic') {
+    agent.fetchRootKey().catch((err) => {
+      console.warn('Unable to fetch root key. Check to ensure that your local replica is running');
+      console.error(err);
+    });
+  }
+
+  // Creates an actor with using the candid interface and the HttpAgent
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+    ...options.actorOptions
+  });
+};

package/declarations/mission_control/mission_control.did.d.ts

@@ -0,0 +1,41 @@
+import type {ActorMethod} from '@dfinity/agent';
+import type {Principal} from '@dfinity/principal';
+
+export interface Controller {
+  updated_at: bigint;
+  metadata: Array<[string, string]>;
+  created_at: bigint;
+  expires_at: [] | [bigint];
+}
+export interface Satellite {
+  updated_at: bigint;
+  metadata: Array<[string, string]>;
+  created_at: bigint;
+  satellite_id: Principal;
+}
+export interface SetController {
+  metadata: Array<[string, string]>;
+  expires_at: [] | [bigint];
+}
+export interface Tokens {
+  e8s: bigint;
+}
+export interface _SERVICE {
+  add_mission_control_controllers: ActorMethod<[Array<Principal>], undefined>;
+  add_satellites_controllers: ActorMethod<[Array<Principal>, Array<Principal>], undefined>;
+  create_satellite: ActorMethod<[string], Satellite>;
+  del_mission_control_controllers: ActorMethod<[Array<Principal>], undefined>;
+  del_satellites_controllers: ActorMethod<[Array<Principal>, Array<Principal>], undefined>;
+  get_user: ActorMethod<[], Principal>;
+  list_mission_control_controllers: ActorMethod<[], Array<[Principal, Controller]>>;
+  list_satellites: ActorMethod<[], Array<[Principal, Satellite]>>;
+  remove_mission_control_controllers: ActorMethod<[Array<Principal>], undefined>;
+  remove_satellites_controllers: ActorMethod<[Array<Principal>, Array<Principal>], undefined>;
+  set_mission_control_controllers: ActorMethod<[Array<Principal>, SetController], undefined>;
+  set_satellites_controllers: ActorMethod<
+    [Array<Principal>, Array<Principal>, SetController],
+    undefined
+  >;
+  top_up: ActorMethod<[Principal, Tokens], undefined>;
+  version: ActorMethod<[], string>;
+}

package/declarations/mission_control/mission_control.factory.did.js

@@ -0,0 +1,50 @@
+export const idlFactory = ({IDL}) => {
+  const Satellite = IDL.Record({
+    updated_at: IDL.Nat64,
+    metadata: IDL.Vec(IDL.Tuple(IDL.Text, IDL.Text)),
+    created_at: IDL.Nat64,
+    satellite_id: IDL.Principal
+  });
+  const Controller = IDL.Record({
+    updated_at: IDL.Nat64,
+    metadata: IDL.Vec(IDL.Tuple(IDL.Text, IDL.Text)),
+    created_at: IDL.Nat64,
+    expires_at: IDL.Opt(IDL.Nat64)
+  });
+  const SetController = IDL.Record({
+    metadata: IDL.Vec(IDL.Tuple(IDL.Text, IDL.Text)),
+    expires_at: IDL.Opt(IDL.Nat64)
+  });
+  const Tokens = IDL.Record({e8s: IDL.Nat64});
+  return IDL.Service({
+    add_mission_control_controllers: IDL.Func([IDL.Vec(IDL.Principal)], [], []),
+    add_satellites_controllers: IDL.Func([IDL.Vec(IDL.Principal), IDL.Vec(IDL.Principal)], [], []),
+    create_satellite: IDL.Func([IDL.Text], [Satellite], []),
+    del_mission_control_controllers: IDL.Func([IDL.Vec(IDL.Principal)], [], []),
+    del_satellites_controllers: IDL.Func([IDL.Vec(IDL.Principal), IDL.Vec(IDL.Principal)], [], []),
+    get_user: IDL.Func([], [IDL.Principal], ['query']),
+    list_mission_control_controllers: IDL.Func(
+      [],
+      [IDL.Vec(IDL.Tuple(IDL.Principal, Controller))],
+      ['query']
+    ),
+    list_satellites: IDL.Func([], [IDL.Vec(IDL.Tuple(IDL.Principal, Satellite))], ['query']),
+    remove_mission_control_controllers: IDL.Func([IDL.Vec(IDL.Principal)], [], []),
+    remove_satellites_controllers: IDL.Func(
+      [IDL.Vec(IDL.Principal), IDL.Vec(IDL.Principal)],
+      [],
+      []
+    ),
+    set_mission_control_controllers: IDL.Func([IDL.Vec(IDL.Principal), SetController], [], []),
+    set_satellites_controllers: IDL.Func(
+      [IDL.Vec(IDL.Principal), IDL.Vec(IDL.Principal), SetController],
+      [],
+      []
+    ),
+    top_up: IDL.Func([IDL.Principal, Tokens], [], []),
+    version: IDL.Func([], [IDL.Text], ['query'])
+  });
+};
+export const init = ({IDL}) => {
+  return [];
+};

package/declarations/satellite/index.d.ts

@@ -0,0 +1,45 @@
+import type {ActorConfig, ActorSubclass, Agent, HttpAgentOptions} from '@dfinity/agent';
+import type {IDL} from '@dfinity/candid';
+import type {Principal} from '@dfinity/principal';
+
+import {_SERVICE} from './satellite.did';
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const canisterId: string;
+
+export declare interface CreateActorOptions {
+  /**
+   * @see {@link Agent}
+   */
+  agent?: Agent;
+  /**
+   * @see {@link HttpAgentOptions}
+   */
+  agentOptions?: HttpAgentOptions;
+  /**
+   * @see {@link ActorConfig}
+   */
+  actorOptions?: ActorConfig;
+}
+
+/**
+ * Intializes an {@link ActorSubclass}, configured with the provided SERVICE interface of a canister.
+ * @constructs {@link ActorSubClass}
+ * @param {string | Principal} canisterId - ID of the canister the {@link Actor} will talk to
+ * @param {CreateActorOptions} options - see {@link CreateActorOptions}
+ * @param {CreateActorOptions["agent"]} options.agent - a pre-configured agent you'd like to use. Supercedes agentOptions
+ * @param {CreateActorOptions["agentOptions"]} options.agentOptions - options to set up a new agent
+ * @see {@link HttpAgentOptions}
+ * @param {CreateActorOptions["actorOptions"]} options.actorOptions - options for the Actor
+ * @see {@link ActorConfig}
+ */
+export declare const createActor: (
+  canisterId: string | Principal,
+  options?: CreateActorOptions
+) => ActorSubclass<_SERVICE>;
+
+/**
+ * Intialized Actor using default settings, ready to talk to a canister using its candid interface
+ * @constructs {@link ActorSubClass}
+ */
+export declare const satellite: ActorSubclass<_SERVICE>;