@icp-sdk/vetkeys 0.5.0-beta.0

package/dist/lib/index.es.js

@@ -0,0 +1,20 @@
+import { a as s, D as r, E as t, I as i, z as y, A as c, M as K, B as d, P as l, T as u, V as b, C as I, G as o, H as P, J as n, K as p, L as M } from "./index-BUXhtQhx.mjs";
+export {
+  s as DerivedKeyMaterial,
+  r as DerivedPublicKey,
+  t as EncryptedVetKey,
+  i as IbeCiphertext,
+  y as IbeIdentity,
+  c as IbeSeed,
+  K as MasterPublicKey,
+  d as MasterPublicKeyId,
+  l as PocketIcMasterPublicKeyId,
+  u as TransportSecretKey,
+  b as VetKey,
+  I as VrfOutput,
+  o as augmentedHashToG1,
+  P as deriveSymmetricKey,
+  n as hashToScalar,
+  p as isValidTransportPublicKey,
+  M as verifyBlsSignature
+};

package/dist/lib/key_manager.es.js

@@ -0,0 +1,274 @@
+import { T as u, D as _, E as l } from "./index-BUXhtQhx.mjs";
+import { A as h } from "./actor-4fotMNaR.mjs";
+const g = ({ IDL: e }) => {
+  const r = e.Record({ inner: e.Vec(e.Nat8) }), t = e.Variant({ Ok: r, Err: e.Text }), s = e.Variant({
+    Read: e.Null,
+    ReadWrite: e.Null,
+    ReadWriteManage: e.Null
+  }), i = e.Variant({
+    Ok: e.Vec(e.Tuple(e.Principal, s)),
+    Err: e.Text
+  }), n = e.Variant({
+    Ok: e.Opt(s),
+    Err: e.Text
+  });
+  return e.Service({
+    get_accessible_shared_key_ids: e.Func(
+      [],
+      [e.Vec(e.Tuple(e.Principal, r))],
+      ["query"]
+    ),
+    get_encrypted_vetkey: e.Func(
+      [e.Principal, r, r],
+      [t],
+      []
+    ),
+    get_shared_user_access_for_key: e.Func(
+      [e.Principal, r],
+      [i],
+      ["query"]
+    ),
+    get_user_rights: e.Func(
+      [e.Principal, r, e.Principal],
+      [n],
+      ["query"]
+    ),
+    get_vetkey_verification_key: e.Func([], [r], []),
+    remove_user: e.Func(
+      [e.Principal, r, e.Principal],
+      [n],
+      []
+    ),
+    set_user_rights: e.Func(
+      [e.Principal, r, e.Principal, s],
+      [n],
+      []
+    )
+  });
+};
+class v {
+  canisterId;
+  actor;
+  verificationKey = void 0;
+  constructor(r, t) {
+    this.canisterId = t, this.actor = h.createActor(g, {
+      agent: r,
+      canisterId: t
+    });
+  }
+  get_accessible_shared_key_ids() {
+    return this.actor.get_accessible_shared_key_ids();
+  }
+  set_user_rights(r, t, s, i) {
+    return this.actor.set_user_rights(r, t, s, i);
+  }
+  get_user_rights(r, t, s) {
+    return this.actor.get_user_rights(r, t, s);
+  }
+  remove_user(r, t, s) {
+    return this.actor.remove_user(r, t, s);
+  }
+  async get_encrypted_vetkey(r, t, s) {
+    return await this.actor.get_encrypted_vetkey(
+      r,
+      t,
+      s
+    );
+  }
+  async get_vetkey_verification_key() {
+    return this.verificationKey ? this.verificationKey : (this.verificationKey = await this.actor.get_vetkey_verification_key(), this.verificationKey);
+  }
+}
+class E {
+  /**
+   * The client instance for interacting with the KeyManager canister.
+   */
+  canisterClient;
+  /**
+   * Creates a new instance of the KeyManager.
+   *
+   * @example
+   * ```ts
+   * import { KeyManager } from "@icp-sdk/vetkeys/key_manager";
+   *
+   * const keyManager = new KeyManager(keyManagerClientInstance);
+   * ```
+   */
+  constructor(r) {
+    this.canisterClient = r;
+  }
+  /**
+   * Retrieves a list of keys that were shared with the user and the user still has access to.
+   *
+   * @example
+   * ```ts
+   * const sharedKeys = await keyManager.getAccessibleSharedKeyIds();
+   * console.log("Shared Keys:", sharedKeys);
+   * ```
+   *
+   * @returns Promise resolving to an array of `[Principal, Uint8Array]` pairs representing accessible key identifiers.
+   */
+  async getAccessibleSharedKeyIds() {
+    return (await this.canisterClient.get_accessible_shared_key_ids()).map(
+      ([r, t]) => [r, Uint8Array.from(t.inner)]
+    );
+  }
+  /**
+   * Fetches and decrypts an encrypted VetKey.
+   *
+   * @example
+   * ```ts
+   * const keyOwner = Principal.fromText("aaaaa-aa");
+   * const vetkeyName = "my_secure_key";
+   *
+   * const vetkey = await keyManager.getVetkey(
+   *   keyOwner,
+   *   vetkeyName,
+   * );
+   * console.log("Decrypted VetKey:", vetkey);
+   * ```
+   *
+   * @param keyOwner - The principal of the key owner
+   * @param vetkeyName - The name/identifier of the VetKey
+   * @returns Promise resolving to the decrypted VetKey bytes
+   * @throws Error if the key retrieval or decryption fails
+   */
+  async getVetkey(r, t) {
+    const s = u.random(), i = await this.canisterClient.get_encrypted_vetkey(
+      r,
+      c(t),
+      c(s.publicKeyBytes())
+    );
+    if ("Err" in i)
+      throw Error(i.Err);
+    {
+      const n = Uint8Array.from(i.Ok.inner), a = await this.getVetkeyVerificationKey(), o = _.deserialize(
+        Uint8Array.from(a)
+      ), y = new Uint8Array([
+        r.toUint8Array().length,
+        ...r.toUint8Array(),
+        ...t
+      ]);
+      return l.deserialize(n).decryptAndVerify(
+        s,
+        o,
+        y
+      ).signatureBytes();
+    }
+  }
+  /**
+   * Retrieves the public verification key for validating encrypted VetKeys.
+   * The vetkeys obtained via `getVetkey` are verified using this key,
+   * and, therefore, this method is not needed for using `getVetkey`.
+   *
+   * @example
+   * ```ts
+   * const verificationKey = await keyManager.getVetkeyVerificationKey();
+   * console.log("Verification Key:", verificationKey);
+   * ```
+   *
+   * @returns Promise resolving to the verification key bytes
+   */
+  async getVetkeyVerificationKey() {
+    return Uint8Array.from(
+      (await this.canisterClient.get_vetkey_verification_key()).inner
+    );
+  }
+  /**
+   * Grants or modifies access rights for a user.
+   *
+   * @example
+   * ```ts
+   * const owner = Principal.fromText("aaaaa-aa");
+   * const keyName = "my_secure_key";
+   * const user = Principal.fromText("bbbbbb-bb");
+   * const accessRights = { ReadWrite: null };
+   *
+   * const result = await keyManager.setUserRights(
+   *   owner,
+   *   keyName,
+   *   user,
+   *   accessRights,
+   * );
+   * console.log("Replaced Access Rights:", result);
+   * ```
+   *
+   * @param owner - The principal of the key owner
+   * @param vetkeyName - The name/identifier of the VetKey
+   * @param user - The principal of the user to grant/modify rights for
+   * @param userRights - The access rights to grant
+   * @returns Promise resolving to the previous access rights if they existed
+   * @throws Error if the operation fails
+   */
+  async setUserRights(r, t, s, i) {
+    const n = await this.canisterClient.set_user_rights(
+      r,
+      c(t),
+      s,
+      i
+    );
+    if ("Err" in n) throw Error(n.Err);
+    if (n.Ok.length > 1)
+      throw Error("Unexpected result from set_user_rights");
+    return n.Ok.length === 0 ? void 0 : n.Ok[0];
+  }
+  /**
+   * Checks a user's access rights.
+   *
+   * @example
+   * ```ts
+   * const userRights = await keyManager.getUserRights(owner, keyName, user);
+   * console.log("User Access Rights:", userRights);
+   * ```
+   *
+   * @param owner - The principal of the key owner
+   * @param vetkeyName - The name/identifier of the VetKey
+   * @param user - The principal of the user to check rights for
+   * @returns Promise resolving to the user's access rights if they exist
+   * @throws Error if the operation fails
+   */
+  async getUserRights(r, t, s) {
+    const i = await this.canisterClient.get_user_rights(
+      r,
+      c(t),
+      s
+    );
+    if ("Err" in i) throw Error(i.Err);
+    if (i.Ok.length > 1)
+      throw Error("Unexpected result from set_user_rights");
+    return i.Ok.length === 0 ? void 0 : i.Ok[0];
+  }
+  /**
+   * Revokes a user's access.
+   *
+   * @example
+   * ```ts
+   * const removalResult = await keyManager.removeUser(owner, keyName, user);
+   * console.log("User Removed:", removalResult);
+   * ```
+   *
+   * @param owner - The principal of the key owner
+   * @param vetkeyName - The name/identifier of the VetKey
+   * @param user - The principal of the user to remove
+   * @returns Promise resolving to the previous access rights if they existed
+   * @throws Error if the operation fails
+   */
+  async removeUser(r, t, s) {
+    const i = await this.canisterClient.remove_user(
+      r,
+      c(t),
+      s
+    );
+    if ("Err" in i) throw Error(i.Err);
+    if (i.Ok.length > 1)
+      throw Error("Unexpected result from set_user_rights");
+    return i.Ok.length === 0 ? void 0 : i.Ok[0];
+  }
+}
+function c(e) {
+  return { inner: e };
+}
+export {
+  v as DefaultKeyManagerClient,
+  E as KeyManager
+};

package/dist/types/declarations/ic_vetkeys_encrypted_maps_canister/ic_vetkeys_encrypted_maps_canister.d.ts

@@ -0,0 +1,109 @@
+import { HttpAgentOptions, ActorConfig, Agent, ActorSubclass } from '@icp-sdk/core/agent';
+import { Principal } from '@icp-sdk/core/principal';
+import { _SERVICE } from './ic_vetkeys_encrypted_maps_canister.did';
+export interface Some<T> {
+    __kind__: "Some";
+    value: T;
+}
+export interface None {
+    __kind__: "None";
+}
+export type Option<T> = Some<T> | None;
+export type Result_4 = {
+    __kind__: "Ok";
+    Ok: AccessRights | null;
+} | {
+    __kind__: "Err";
+    Err: string;
+};
+export type Result_2 = {
+    __kind__: "Ok";
+    Ok: ByteBuf;
+} | {
+    __kind__: "Err";
+    Err: string;
+};
+export type Result = {
+    __kind__: "Ok";
+    Ok: ByteBuf | null;
+} | {
+    __kind__: "Err";
+    Err: string;
+};
+export type Result_3 = {
+    __kind__: "Ok";
+    Ok: Array<[Principal, AccessRights]>;
+} | {
+    __kind__: "Err";
+    Err: string;
+};
+export interface EncryptedMapData {
+    access_control: Array<[Principal, AccessRights]>;
+    keyvals: Array<[ByteBuf, ByteBuf]>;
+    map_name: ByteBuf;
+    map_owner: Principal;
+}
+export type Result_5 = {
+    __kind__: "Ok";
+    Ok: Array<ByteBuf>;
+} | {
+    __kind__: "Err";
+    Err: string;
+};
+export interface ByteBuf {
+    inner: Uint8Array;
+}
+export type Result_1 = {
+    __kind__: "Ok";
+    Ok: Array<[ByteBuf, ByteBuf]>;
+} | {
+    __kind__: "Err";
+    Err: string;
+};
+export declare enum AccessRights {
+    Read = "Read",
+    ReadWrite = "ReadWrite",
+    ReadWriteManage = "ReadWriteManage"
+}
+export interface ic_vetkeys_encrypted_maps_canisterInterface {
+    get_accessible_shared_map_names(): Promise<Array<[Principal, ByteBuf]>>;
+    get_all_accessible_encrypted_maps(): Promise<Array<EncryptedMapData>>;
+    get_all_accessible_encrypted_values(): Promise<Array<[[Principal, ByteBuf], Array<[ByteBuf, ByteBuf]>]>>;
+    get_encrypted_value(arg0: Principal, arg1: ByteBuf, arg2: ByteBuf): Promise<Result>;
+    get_encrypted_values_for_map(arg0: Principal, arg1: ByteBuf): Promise<Result_1>;
+    get_encrypted_vetkey(arg0: Principal, arg1: ByteBuf, arg2: ByteBuf): Promise<Result_2>;
+    get_owned_non_empty_map_names(): Promise<Array<ByteBuf>>;
+    get_shared_user_access_for_map(arg0: Principal, arg1: ByteBuf): Promise<Result_3>;
+    get_user_rights(arg0: Principal, arg1: ByteBuf, arg2: Principal): Promise<Result_4>;
+    get_vetkey_verification_key(): Promise<ByteBuf>;
+    insert_encrypted_value(arg0: Principal, arg1: ByteBuf, arg2: ByteBuf, arg3: ByteBuf): Promise<Result>;
+    remove_encrypted_value(arg0: Principal, arg1: ByteBuf, arg2: ByteBuf): Promise<Result>;
+    remove_map_values(arg0: Principal, arg1: ByteBuf): Promise<Result_5>;
+    remove_user(arg0: Principal, arg1: ByteBuf, arg2: Principal): Promise<Result_4>;
+    set_user_rights(arg0: Principal, arg1: ByteBuf, arg2: Principal, arg3: AccessRights): Promise<Result_4>;
+}
+export declare class Ic_vetkeys_encrypted_maps_canister implements ic_vetkeys_encrypted_maps_canisterInterface {
+    private actor;
+    constructor(actor: ActorSubclass<_SERVICE>);
+    get_accessible_shared_map_names(): Promise<Array<[Principal, ByteBuf]>>;
+    get_all_accessible_encrypted_maps(): Promise<Array<EncryptedMapData>>;
+    get_all_accessible_encrypted_values(): Promise<Array<[[Principal, ByteBuf], Array<[ByteBuf, ByteBuf]>]>>;
+    get_encrypted_value(arg0: Principal, arg1: ByteBuf, arg2: ByteBuf): Promise<Result>;
+    get_encrypted_values_for_map(arg0: Principal, arg1: ByteBuf): Promise<Result_1>;
+    get_encrypted_vetkey(arg0: Principal, arg1: ByteBuf, arg2: ByteBuf): Promise<Result_2>;
+    get_owned_non_empty_map_names(): Promise<Array<ByteBuf>>;
+    get_shared_user_access_for_map(arg0: Principal, arg1: ByteBuf): Promise<Result_3>;
+    get_user_rights(arg0: Principal, arg1: ByteBuf, arg2: Principal): Promise<Result_4>;
+    get_vetkey_verification_key(): Promise<ByteBuf>;
+    insert_encrypted_value(arg0: Principal, arg1: ByteBuf, arg2: ByteBuf, arg3: ByteBuf): Promise<Result>;
+    remove_encrypted_value(arg0: Principal, arg1: ByteBuf, arg2: ByteBuf): Promise<Result>;
+    remove_map_values(arg0: Principal, arg1: ByteBuf): Promise<Result_5>;
+    remove_user(arg0: Principal, arg1: ByteBuf, arg2: Principal): Promise<Result_4>;
+    set_user_rights(arg0: Principal, arg1: ByteBuf, arg2: Principal, arg3: AccessRights): Promise<Result_4>;
+}
+export interface CreateActorOptions {
+    agent?: Agent;
+    agentOptions?: HttpAgentOptions;
+    actorOptions?: ActorConfig;
+}
+export declare function createActor(canisterId: string, options?: CreateActorOptions): Ic_vetkeys_encrypted_maps_canister;

package/dist/types/declarations/ic_vetkeys_encrypted_maps_canister/ic_vetkeys_encrypted_maps_canister.did.d.ts

@@ -0,0 +1,62 @@
+import { ActorMethod } from '@icp-sdk/core/agent';
+import { IDL } from '@icp-sdk/core/candid';
+import { Principal } from '@icp-sdk/core/principal';
+export type AccessRights = { 'Read' : null } |
+  { 'ReadWrite' : null } |
+  { 'ReadWriteManage' : null };
+export interface ByteBuf { 'inner' : Uint8Array }
+export interface EncryptedMapData {
+  'access_control' : Array<[Principal, AccessRights]>,
+  'keyvals' : Array<[ByteBuf, ByteBuf]>,
+  'map_name' : ByteBuf,
+  'map_owner' : Principal,
+}
+export type Result = { 'Ok' : [] | [ByteBuf] } |
+  { 'Err' : string };
+export type Result_1 = { 'Ok' : Array<[ByteBuf, ByteBuf]> } |
+  { 'Err' : string };
+export type Result_2 = { 'Ok' : ByteBuf } |
+  { 'Err' : string };
+export type Result_3 = { 'Ok' : Array<[Principal, AccessRights]> } |
+  { 'Err' : string };
+export type Result_4 = { 'Ok' : [] | [AccessRights] } |
+  { 'Err' : string };
+export type Result_5 = { 'Ok' : Array<ByteBuf> } |
+  { 'Err' : string };
+export interface _SERVICE {
+  'get_accessible_shared_map_names' : ActorMethod<
+    [],
+    Array<[Principal, ByteBuf]>
+  >,
+  'get_all_accessible_encrypted_maps' : ActorMethod<
+    [],
+    Array<EncryptedMapData>
+  >,
+  'get_all_accessible_encrypted_values' : ActorMethod<
+    [],
+    Array<[[Principal, ByteBuf], Array<[ByteBuf, ByteBuf]>]>
+  >,
+  'get_encrypted_value' : ActorMethod<[Principal, ByteBuf, ByteBuf], Result>,
+  'get_encrypted_values_for_map' : ActorMethod<[Principal, ByteBuf], Result_1>,
+  'get_encrypted_vetkey' : ActorMethod<[Principal, ByteBuf, ByteBuf], Result_2>,
+  'get_owned_non_empty_map_names' : ActorMethod<[], Array<ByteBuf>>,
+  'get_shared_user_access_for_map' : ActorMethod<
+    [Principal, ByteBuf],
+    Result_3
+  >,
+  'get_user_rights' : ActorMethod<[Principal, ByteBuf, Principal], Result_4>,
+  'get_vetkey_verification_key' : ActorMethod<[], ByteBuf>,
+  'insert_encrypted_value' : ActorMethod<
+    [Principal, ByteBuf, ByteBuf, ByteBuf],
+    Result
+  >,
+  'remove_encrypted_value' : ActorMethod<[Principal, ByteBuf, ByteBuf], Result>,
+  'remove_map_values' : ActorMethod<[Principal, ByteBuf], Result_5>,
+  'remove_user' : ActorMethod<[Principal, ByteBuf, Principal], Result_4>,
+  'set_user_rights' : ActorMethod<
+    [Principal, ByteBuf, Principal, AccessRights],
+    Result_4
+  >,
+}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];

package/dist/types/declarations/ic_vetkeys_manager_canister/ic_vetkeys_manager_canister.d.ts

@@ -0,0 +1,66 @@
+import { HttpAgentOptions, ActorConfig, Agent, ActorSubclass } from '@icp-sdk/core/agent';
+import { Principal } from '@icp-sdk/core/principal';
+import { _SERVICE } from './ic_vetkeys_manager_canister.did';
+export interface Some<T> {
+    __kind__: "Some";
+    value: T;
+}
+export interface None {
+    __kind__: "None";
+}
+export type Option<T> = Some<T> | None;
+export type Result_2 = {
+    __kind__: "Ok";
+    Ok: AccessRights | null;
+} | {
+    __kind__: "Err";
+    Err: string;
+};
+export type Result = {
+    __kind__: "Ok";
+    Ok: ByteBuf;
+} | {
+    __kind__: "Err";
+    Err: string;
+};
+export interface ByteBuf {
+    inner: Uint8Array;
+}
+export type Result_1 = {
+    __kind__: "Ok";
+    Ok: Array<[Principal, AccessRights]>;
+} | {
+    __kind__: "Err";
+    Err: string;
+};
+export declare enum AccessRights {
+    Read = "Read",
+    ReadWrite = "ReadWrite",
+    ReadWriteManage = "ReadWriteManage"
+}
+export interface ic_vetkeys_manager_canisterInterface {
+    get_accessible_shared_key_ids(): Promise<Array<[Principal, ByteBuf]>>;
+    get_encrypted_vetkey(arg0: Principal, arg1: ByteBuf, arg2: ByteBuf): Promise<Result>;
+    get_shared_user_access_for_key(arg0: Principal, arg1: ByteBuf): Promise<Result_1>;
+    get_user_rights(arg0: Principal, arg1: ByteBuf, arg2: Principal): Promise<Result_2>;
+    get_vetkey_verification_key(): Promise<ByteBuf>;
+    remove_user(arg0: Principal, arg1: ByteBuf, arg2: Principal): Promise<Result_2>;
+    set_user_rights(arg0: Principal, arg1: ByteBuf, arg2: Principal, arg3: AccessRights): Promise<Result_2>;
+}
+export declare class Ic_vetkeys_manager_canister implements ic_vetkeys_manager_canisterInterface {
+    private actor;
+    constructor(actor: ActorSubclass<_SERVICE>);
+    get_accessible_shared_key_ids(): Promise<Array<[Principal, ByteBuf]>>;
+    get_encrypted_vetkey(arg0: Principal, arg1: ByteBuf, arg2: ByteBuf): Promise<Result>;
+    get_shared_user_access_for_key(arg0: Principal, arg1: ByteBuf): Promise<Result_1>;
+    get_user_rights(arg0: Principal, arg1: ByteBuf, arg2: Principal): Promise<Result_2>;
+    get_vetkey_verification_key(): Promise<ByteBuf>;
+    remove_user(arg0: Principal, arg1: ByteBuf, arg2: Principal): Promise<Result_2>;
+    set_user_rights(arg0: Principal, arg1: ByteBuf, arg2: Principal, arg3: AccessRights): Promise<Result_2>;
+}
+export interface CreateActorOptions {
+    agent?: Agent;
+    agentOptions?: HttpAgentOptions;
+    actorOptions?: ActorConfig;
+}
+export declare function createActor(canisterId: string, options?: CreateActorOptions): Ic_vetkeys_manager_canister;

package/dist/types/declarations/ic_vetkeys_manager_canister/ic_vetkeys_manager_canister.did.d.ts

@@ -0,0 +1,33 @@
+import { ActorMethod } from '@icp-sdk/core/agent';
+import { IDL } from '@icp-sdk/core/candid';
+import { Principal } from '@icp-sdk/core/principal';
+export type AccessRights = { 'Read' : null } |
+  { 'ReadWrite' : null } |
+  { 'ReadWriteManage' : null };
+export interface ByteBuf { 'inner' : Uint8Array }
+export type Result = { 'Ok' : ByteBuf } |
+  { 'Err' : string };
+export type Result_1 = { 'Ok' : Array<[Principal, AccessRights]> } |
+  { 'Err' : string };
+export type Result_2 = { 'Ok' : [] | [AccessRights] } |
+  { 'Err' : string };
+export interface _SERVICE {
+  'get_accessible_shared_key_ids' : ActorMethod<
+    [],
+    Array<[Principal, ByteBuf]>
+  >,
+  'get_encrypted_vetkey' : ActorMethod<[Principal, ByteBuf, ByteBuf], Result>,
+  'get_shared_user_access_for_key' : ActorMethod<
+    [Principal, ByteBuf],
+    Result_1
+  >,
+  'get_user_rights' : ActorMethod<[Principal, ByteBuf, Principal], Result_2>,
+  'get_vetkey_verification_key' : ActorMethod<[], ByteBuf>,
+  'remove_user' : ActorMethod<[Principal, ByteBuf, Principal], Result_2>,
+  'set_user_rights' : ActorMethod<
+    [Principal, ByteBuf, Principal, AccessRights],
+    Result_2
+  >,
+}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];

package/dist/types/encrypted_maps/encrypted_maps_canister.d.ts

@@ -0,0 +1,66 @@
+import { Principal } from '@icp-sdk/core/principal';
+import { ActorSubclass, HttpAgent } from '@icp-sdk/core/agent';
+import { _SERVICE as _DEFAULT_ENCRYPTED_MAPS_SERVICE, AccessRights, ByteBuf, EncryptedMapData } from '../declarations/ic_vetkeys_encrypted_maps_canister/ic_vetkeys_encrypted_maps_canister.did.js';
+import { EncryptedMapsClient } from './index';
+export declare class DefaultEncryptedMapsClient implements EncryptedMapsClient {
+    actor: ActorSubclass<_DEFAULT_ENCRYPTED_MAPS_SERVICE>;
+    constructor(agent: HttpAgent, canisterId: string);
+    get_accessible_shared_map_names(): Promise<[Principal, ByteBuf][]>;
+    get_shared_user_access_for_map(owner: Principal, mapName: ByteBuf): Promise<{
+        Ok: Array<[Principal, AccessRights]>;
+    } | {
+        Err: string;
+    }>;
+    get_owned_non_empty_map_names(): Promise<Array<ByteBuf>>;
+    get_all_accessible_encrypted_values(): Promise<[
+        [Principal, ByteBuf],
+        [ByteBuf, ByteBuf][]
+    ][]>;
+    get_all_accessible_encrypted_maps(): Promise<Array<EncryptedMapData>>;
+    get_encrypted_value(mapOwner: Principal, mapName: ByteBuf, mapKey: ByteBuf): Promise<{
+        Ok: [] | [ByteBuf];
+    } | {
+        Err: string;
+    }>;
+    get_encrypted_values_for_map(mapOwner: Principal, mapName: ByteBuf): Promise<{
+        Ok: Array<[ByteBuf, ByteBuf]>;
+    } | {
+        Err: string;
+    }>;
+    get_encrypted_vetkey(mapOwner: Principal, mapName: ByteBuf, transportKey: ByteBuf): Promise<{
+        Ok: ByteBuf;
+    } | {
+        Err: string;
+    }>;
+    insert_encrypted_value(mapOwner: Principal, mapName: ByteBuf, mapKey: ByteBuf, data: ByteBuf): Promise<{
+        Ok: [] | [ByteBuf];
+    } | {
+        Err: string;
+    }>;
+    remove_encrypted_value(mapOwner: Principal, mapName: ByteBuf, mapKey: ByteBuf): Promise<{
+        Ok: [] | [ByteBuf];
+    } | {
+        Err: string;
+    }>;
+    remove_map_values(mapOwner: Principal, mapName: ByteBuf): Promise<{
+        Ok: Array<ByteBuf>;
+    } | {
+        Err: string;
+    }>;
+    get_vetkey_verification_key(): Promise<ByteBuf>;
+    set_user_rights(owner: Principal, mapName: ByteBuf, user: Principal, userRights: AccessRights): Promise<{
+        Ok: [] | [AccessRights];
+    } | {
+        Err: string;
+    }>;
+    get_user_rights(owner: Principal, mapName: ByteBuf, user: Principal): Promise<{
+        Ok: [] | [AccessRights];
+    } | {
+        Err: string;
+    }>;
+    remove_user(owner: Principal, mapName: ByteBuf, user: Principal): Promise<{
+        Ok: [] | [AccessRights];
+    } | {
+        Err: string;
+    }>;
+}

package/dist/types/encrypted_maps/encrypted_maps_canister.test.d.ts

@@ -0,0 +1 @@
+export {};