@junobuild/admin 0.0.3 → 0.0.5

package/dist/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/dist/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/dist/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/dist/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/dist/declarations/mission_control/mission_control.did.d.ts

@@ -0,0 +1,24 @@
+import type {ActorMethod} from '@dfinity/agent';
+import type {Principal} from '@dfinity/principal';
+
+export interface Satellite {
+  updated_at: bigint;
+  metadata: Array<[string, string]>;
+  created_at: bigint;
+  satellite_id: Principal;
+}
+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>;
+  get_user: ActorMethod<[], Principal>;
+  list_mission_control_controllers: ActorMethod<[], Array<Principal>>;
+  list_satellites: ActorMethod<[], Array<[Principal, Satellite]>>;
+  remove_mission_control_controllers: ActorMethod<[Array<Principal>], undefined>;
+  remove_satellites_controllers: ActorMethod<[Array<Principal>, Array<Principal>], undefined>;
+  top_up: ActorMethod<[Principal, Tokens], undefined>;
+  version: ActorMethod<[], string>;
+}

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

@@ -0,0 +1,28 @@
+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 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], []),
+    get_user: IDL.Func([], [IDL.Principal], ['query']),
+    list_mission_control_controllers: IDL.Func([], [IDL.Vec(IDL.Principal)], ['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)],
+      [],
+      []
+    ),
+    top_up: IDL.Func([IDL.Principal, Tokens], [], []),
+    version: IDL.Func([], [IDL.Text], ['query'])
+  });
+};
+export const init = ({IDL}) => {
+  return [];
+};

package/dist/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>;

package/dist/declarations/satellite/index.js

@@ -0,0 +1,32 @@
+import {Actor, HttpAgent} from '@dfinity/agent';
+
+// Imports and re-exports candid interface
+import {idlFactory} from './satellite.did.js';
+export {idlFactory} from './satellite.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/dist/declarations/satellite/satellite.did.d.ts

@@ -0,0 +1,168 @@
+import type {ActorMethod} from '@dfinity/agent';
+import type {Principal} from '@dfinity/principal';
+
+export interface AssetEncodingNoContent {
+  modified: bigint;
+  sha256: Uint8Array | number[];
+  total_length: bigint;
+}
+export interface AssetKey {
+  token: [] | [string];
+  collection: string;
+  owner: Principal;
+  name: string;
+  full_path: string;
+}
+export interface AssetNoContent {
+  key: AssetKey;
+  updated_at: bigint;
+  encodings: Array<[string, AssetEncodingNoContent]>;
+  headers: Array<[string, string]>;
+  created_at: bigint;
+}
+export interface Chunk {
+  content: Uint8Array | number[];
+  batch_id: bigint;
+}
+export interface CommitBatch {
+  batch_id: bigint;
+  headers: Array<[string, string]>;
+  chunk_ids: Array<bigint>;
+}
+export interface Config {
+  storage: StorageConfig;
+}
+export interface ControllersArgs {
+  controllers: Array<Principal>;
+}
+export interface CustomDomain {
+  updated_at: bigint;
+  created_at: bigint;
+  bn_id: [] | [string];
+}
+export interface DelDoc {
+  updated_at: [] | [bigint];
+}
+export interface Doc {
+  updated_at: bigint;
+  owner: Principal;
+  data: Uint8Array | number[];
+  created_at: bigint;
+}
+export interface HttpRequest {
+  url: string;
+  method: string;
+  body: Uint8Array | number[];
+  headers: Array<[string, string]>;
+}
+export interface HttpResponse {
+  body: Uint8Array | number[];
+  headers: Array<[string, string]>;
+  streaming_strategy: [] | [StreamingStrategy];
+  status_code: number;
+}
+export interface InitAssetKey {
+  token: [] | [string];
+  collection: string;
+  name: string;
+  encoding_type: [] | [string];
+  full_path: string;
+}
+export interface InitUploadResult {
+  batch_id: bigint;
+}
+export interface ListOrder {
+  field: ListOrderField;
+  desc: boolean;
+}
+export type ListOrderField = {UpdatedAt: null} | {Keys: null} | {CreatedAt: null};
+export interface ListPaginate {
+  start_after: [] | [string];
+  limit: [] | [bigint];
+}
+export interface ListParams {
+  order: [] | [ListOrder];
+  matcher: [] | [string];
+  paginate: [] | [ListPaginate];
+}
+export interface ListResults {
+  matches_length: bigint;
+  length: bigint;
+  items: Array<[string, AssetNoContent]>;
+}
+export interface ListResults_1 {
+  matches_length: bigint;
+  length: bigint;
+  items: Array<[string, Doc]>;
+}
+export type Permission = {Controllers: null} | {Private: null} | {Public: null} | {Managed: null};
+export interface Rule {
+  updated_at: bigint;
+  max_size: [] | [bigint];
+  read: Permission;
+  created_at: bigint;
+  write: Permission;
+}
+export type RulesType = {Db: null} | {Storage: null};
+export interface SetDoc {
+  updated_at: [] | [bigint];
+  data: Uint8Array | number[];
+}
+export interface SetRule {
+  updated_at: [] | [bigint];
+  max_size: [] | [bigint];
+  read: Permission;
+  write: Permission;
+}
+export interface StorageConfig {
+  headers: Array<[string, Array<[string, string]>]>;
+}
+export interface StreamingCallbackHttpResponse {
+  token: [] | [StreamingCallbackToken];
+  body: Uint8Array | number[];
+}
+export interface StreamingCallbackToken {
+  token: [] | [string];
+  sha256: [] | [Uint8Array | number[]];
+  headers: Array<[string, string]>;
+  index: bigint;
+  encoding_type: string;
+  full_path: string;
+}
+export type StreamingStrategy = {
+  Callback: {
+    token: StreamingCallbackToken;
+    callback: [Principal, string];
+  };
+};
+export interface UploadChunk {
+  chunk_id: bigint;
+}
+export interface _SERVICE {
+  add_controllers: ActorMethod<[ControllersArgs], Array<Principal>>;
+  commit_asset_upload: ActorMethod<[CommitBatch], undefined>;
+  del_asset: ActorMethod<[string, string], undefined>;
+  del_assets: ActorMethod<[[] | [string]], undefined>;
+  del_custom_domain: ActorMethod<[string], undefined>;
+  del_doc: ActorMethod<[string, string, DelDoc], undefined>;
+  get_config: ActorMethod<[], Config>;
+  get_doc: ActorMethod<[string, string], [] | [Doc]>;
+  http_request: ActorMethod<[HttpRequest], HttpResponse>;
+  http_request_streaming_callback: ActorMethod<
+    [StreamingCallbackToken],
+    StreamingCallbackHttpResponse
+  >;
+  init_asset_upload: ActorMethod<[InitAssetKey], InitUploadResult>;
+  list_assets: ActorMethod<[[] | [string], ListParams], ListResults>;
+  list_controllers: ActorMethod<[], Array<Principal>>;
+  list_custom_domains: ActorMethod<[], Array<[string, CustomDomain]>>;
+  list_docs: ActorMethod<[string, ListParams], ListResults_1>;
+  list_rules: ActorMethod<[RulesType], Array<[string, Rule]>>;
+  remove_controllers: ActorMethod<[ControllersArgs], Array<Principal>>;
+  set_config: ActorMethod<[Config], undefined>;
+  set_custom_domain: ActorMethod<[string, [] | [string]], undefined>;
+  set_doc: ActorMethod<[string, string, SetDoc], Doc>;
+  set_rule: ActorMethod<[RulesType, string, SetRule], undefined>;
+  upload_asset_chunk: ActorMethod<[Chunk], UploadChunk>;
+  version: ActorMethod<[], string>;
+}