@cubist-labs/cubesigner-sdk 0.3.26 → 0.3.28

package/dist/src/client.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CubeSignerClient = void 0;
+const signer_session_manager_1 = require("./session/signer_session_manager");
+const api_1 = require("./api");
+const key_1 = require("./key");
+const role_1 = require("./role");
+const session_storage_1 = require("./session/session_storage");
+const util_1 = require("./util");
+/**
+ * Client to use to send requests to CubeSigner services
+ * when authenticating using a CubeSigner session token.
+ */
+class CubeSignerClient extends api_1.CubeSignerApi {
+    /**
+     * Constructor.
+     * @param {SignerSessionManager} sessionMgr The session manager to use
+     * @param {string?} orgId Optional organization ID; if omitted, uses the org ID from the session manager.
+     */
+    constructor(sessionMgr, orgId) {
+        super(sessionMgr, orgId);
+    }
+    /**
+     * Returns a new instance of this class using the same session manager but targeting a different organization.
+     *
+     * @param {string} orgId The organization ID.
+     * @return {CubeSignerClient} A new instance of this class using the same session manager but targeting different organization.
+     */
+    withOrg(orgId) {
+        return orgId ? new CubeSignerClient(this.sessionMgr, orgId) : this;
+    }
+    /**
+     * Loads an existing management session and creates a {@link CubeSignerClient} instance.
+     *
+     * @param {SignerSessionStorage} storage Optional storage from which to load the session (defaults to the default management session json file location)
+     * @return {Promise<CubeSignerClient>} New CubeSigner instance
+     */
+    static async loadManagementSession(storage) {
+        const filePath = (0, util_1.pathJoin)((0, util_1.configDir)(), "management-session.json");
+        storage ??= new session_storage_1.JsonFileSessionStorage(filePath);
+        // Throw and actionable error if the management session file contains a Cognito session
+        const session = await storage.retrieve();
+        if (session.id_token) {
+            throw new Error(`It appears that the '${filePath}' file contains the old (Cognito) session; please update your session by updating your 'cs' to version 'v0.37.0' or later and then running 'cs login'`);
+        }
+        const mgr = await signer_session_manager_1.SignerSessionManager.loadFromStorage(storage);
+        return new CubeSignerClient(mgr);
+    }
+    /**
+     * Create a new signing key.
+     * @param {KeyType} type The type of key to create.
+     * @param {string?} ownerId The owner of the key. Defaults to the session's user.
+     * @return {Key[]} The new keys.
+     */
+    async createKey(type, ownerId) {
+        return (await this.createKeys(type, 1, ownerId))[0];
+    }
+    /**
+     * Create new signing keys.
+     * @param {KeyType} type The type of key to create.
+     * @param {number} count The number of keys to create.
+     * @param {string?} ownerId The owner of the keys. Defaults to the session's user.
+     * @return {Key[]} The new keys.
+     */
+    async createKeys(type, count, ownerId) {
+        const keys = await this.keysCreate(type, count, ownerId);
+        return keys.map((k) => new key_1.Key(this, k));
+    }
+    /**
+     * Derive a key of the given type using the given derivation path and mnemonic.
+     * The owner of the derived key will be the owner of the mnemonic.
+     *
+     * @param {KeyType} type Type of key to derive from the mnemonic.
+     * @param {string} derivationPath Mnemonic derivation path used to generate new key.
+     * @param {string} mnemonicId materialId of mnemonic key used to derive the new key.
+     *
+     * @return {Key} newly derived key or undefined if it already exists.
+     */
+    async deriveKey(type, derivationPath, mnemonicId) {
+        return (await this.deriveKeys(type, [derivationPath], mnemonicId))[0];
+    }
+    /**
+     * Derive a set of keys of the given type using the given derivation paths and mnemonic.
+     *
+     * The owner of the derived keys will be the owner of the mnemonic.
+     *
+     * @param {KeyType} type Type of key to derive from the mnemonic.
+     * @param {string[]} derivationPaths Mnemonic derivation paths used to generate new key.
+     * @param {string} mnemonicId materialId of mnemonic key used to derive the new key.
+     *
+     * @return {Key[]} newly derived keys.
+     */
+    async deriveKeys(type, derivationPaths, mnemonicId) {
+        const keys = await this.keysDerive(type, derivationPaths, mnemonicId);
+        return keys.map((k) => new key_1.Key(this, k));
+    }
+    /**
+     * Create a new {@link OidcClient} that will use a given OIDC token for auth.
+     * @param {string} oidcToken The authentication token to use
+     * @return {OidcClient} New OIDC client.
+     */
+    newOidcClient(oidcToken) {
+        return new api_1.OidcClient(this.sessionMgr.env, this.orgId, oidcToken);
+    }
+    /**
+     * Authenticate an OIDC user and create a new session manager for them.
+     *
+     * @param {string} oidcToken The OIDC token
+     * @param {List<string>} scopes The scopes of the resulting session
+     * @param {OidcAuthOptions} options Options.
+     * @return {Promise<SignerSessionManager>} The signer session manager
+     */
+    async oidcAuth(oidcToken, scopes, options) {
+        const oidcClient = this.newOidcClient(oidcToken);
+        const resp = await oidcClient.sessionCreate(scopes, options?.lifetimes, options?.mfaReceipt);
+        return await signer_session_manager_1.SignerSessionManager.loadFromStorage(new session_storage_1.MemorySessionStorage(resp.data()));
+    }
+    /**
+     * Create a new user in the organization and sends an invitation to that user.
+     *
+     * Same as {@link orgUserInvite}.
+     */
+    get createUser() {
+        return this.orgUserInvite.bind(this);
+    }
+    /**
+     * Create a new OIDC user.
+     *
+     * Same as {@link orgUserCreateOidc}.
+     */
+    get createOidcUser() {
+        return this.orgUserCreateOidc.bind(this);
+    }
+    /**
+     * Delete an existing OIDC user.
+     *
+     * Same as {@link orgUserDeleteOidc}.
+     */
+    get deleteOidcUser() {
+        return this.orgUserDeleteOidc.bind(this);
+    }
+    /**
+     * List users in the organization.
+     *
+     * Same as {@link orgUsersList}
+     */
+    get users() {
+        return this.orgUsersList.bind(this);
+    }
+    /**
+     * Obtain information about the current user.
+     *
+     * Same as {@link userGet}
+     */
+    get user() {
+        return this.userGet.bind(this);
+    }
+    /**
+     * Get information about a specific org.
+     *
+     * @param {string?} orgId The ID or name of the org
+     * @return {Promise<OrgInfo>} CubeSigner client for the requested org.
+     */
+    async org(orgId) {
+        return await this.withOrg(orgId).orgGet();
+    }
+    /**
+     * Obtain information about the current user.
+     *
+     * Same as {@link userGet}
+     */
+    get aboutMe() {
+        return this.userGet.bind(this);
+    }
+    /**
+     * Get a key by id.
+     *
+     * @param {string} keyId The id of the key to get.
+     * @return {Key} The key.
+     */
+    async getKey(keyId) {
+        const keyInfo = await this.keyGet(keyId);
+        return new key_1.Key(this, keyInfo);
+    }
+    /**
+     * Get all keys in the org.
+     *
+     * @param {KeyType?} type Optional key type to filter list for.
+     * @param {PageOpts} page Pagination options. Defaults to fetching the entire result set.
+     * @return {Promise<Key[]>} The keys.
+     */
+    async orgKeys(type, page) {
+        const paginator = this.keysList(type, page);
+        const keys = await paginator.fetch();
+        return keys.map((k) => new key_1.Key(this, k));
+    }
+    /**
+     * Create a new role.
+     *
+     * @param {string?} name The name of the role.
+     * @return {Role} The new role.
+     */
+    async createRole(name) {
+        const roleId = await this.roleCreate(name);
+        const roleInfo = await this.roleGet(roleId);
+        return new role_1.Role(this, roleInfo);
+    }
+    /**
+     * Get a role by id or name.
+     *
+     * @param {string} roleId The id or name of the role to get.
+     * @return {Role} The role.
+     */
+    async getRole(roleId) {
+        const roleInfo = await this.roleGet(roleId);
+        return new role_1.Role(this, roleInfo);
+    }
+    /**
+     * List all roles in the org.
+     *
+     * @param {PageOpts} page Pagination options. Defaults to fetching the entire result set.
+     * @return {Role[]} The roles.
+     */
+    async listRoles(page) {
+        const roles = await this.rolesList(page).fetch();
+        return roles.map((r) => new role_1.Role(this, r));
+    }
+    /**
+     * List all users in the org.
+     *
+     * Same as {@link orgUsersList}
+     */
+    get listUsers() {
+        return this.orgUsersList.bind(this);
+    }
+    /**
+     * Approve a pending MFA request.
+     *
+     * Same as {@link mfaApprove}
+     */
+    get approveMfaRequest() {
+        return this.mfaApprove.bind(this);
+    }
+    /**
+     * Approve a pending MFA request using TOTP.
+     *
+     * Same as {@link mfaApproveTotp}
+     */
+    get totpApprove() {
+        return this.mfaApproveTotp.bind(this);
+    }
+    /**
+     * Initiate approval of an existing MFA request using FIDO.
+     *
+     * Returns a {@link MfaFidoChallenge} that must be answered by calling
+     * {@link MfaFidoChallenge.answer} or {@link fidoApproveComplete}.
+     *
+     * Same as {@link mfaApproveFidoInit}
+     */
+    get fidoApproveStart() {
+        return this.mfaApproveFidoInit.bind(this);
+    }
+    /**
+     * Answer the MFA approval with FIDO challenge issued by {@link fidoApproveStart}.
+     *
+     * Same as {@link mfaApproveFidoComplete}
+     */
+    get fidoApproveComplete() {
+        return this.mfaApproveFidoComplete.bind(this);
+    }
+    /**
+     * Get a pending MFA request by its id.
+     *
+     * Same as {@link mfaGet}
+     */
+    get getMfaInfo() {
+        return this.mfaGet.bind(this);
+    }
+    /**
+     * List pending MFA requests accessible to the current user.
+     *
+     * Same as {@link mfaList}
+     */
+    get listMfaInfos() {
+        return this.mfaList.bind(this);
+    }
+    /**
+     * Obtain a proof of authentication.
+     *
+     * Same as {@link identityProve}
+     */
+    get proveIdentity() {
+        return this.identityProve.bind(this);
+    }
+    /**
+     * Check if a given proof of OIDC authentication is valid.
+     *
+     * Same as {@link identityVerify}
+     */
+    get verifyIdentity() {
+        return this.identityVerify.bind(this);
+    }
+    /**
+     * Creates a request to add a new FIDO device.
+     *
+     * Returns a {@link AddFidoChallenge} that must be answered by calling {@link AddFidoChallenge.answer}.
+     *
+     * MFA may be required.
+     *
+     * Same as {@link userFidoRegisterInit}
+     */
+    get addFidoStart() {
+        return this.userFidoRegisterInit.bind(this);
+    }
+    /**
+     * Delete a FIDO key from the user's account.
+     * Allowed only if TOTP is also defined.
+     * MFA via TOTP is always required.
+     *
+     * Same as {@link userFidoDelete}
+     */
+    get deleteFido() {
+        return this.userFidoDelete.bind(this);
+    }
+    /**
+     * Creates a request to change user's TOTP. Returns a {@link TotpChallenge}
+     * that must be answered by calling {@link TotpChallenge.answer} or
+     * {@link resetTotpComplete}.
+     *
+     * Same as {@link userTotpResetInit}
+     */
+    get resetTotpStart() {
+        return this.userTotpResetInit.bind(this);
+    }
+    /**
+     * Answer the TOTP challenge issued by {@link resetTotpStart}. If successful,
+     * user's TOTP configuration will be updated to that of the TOTP challenge.
+     *
+     * Same as {@link userTotpResetComplete}
+     */
+    get resetTotpComplete() {
+        return this.userTotpResetComplete.bind(this);
+    }
+    /**
+     * Verifies a given TOTP code against the current user's TOTP configuration.
+     * Throws an error if the verification fails.
+     *
+     * Same as {@link userTotpVerify}
+     */
+    get verifyTotp() {
+        return this.userTotpVerify.bind(this);
+    }
+    /**
+     * Delete TOTP from the user's account.
+     * Allowed only if at least one FIDO key is registered with the user's account.
+     * MFA via FIDO is always required.
+     *
+     * Same as {@link userTotpDelete}.
+     */
+    get deleteTotp() {
+        return this.userTotpDelete.bind(this);
+    }
+    /**
+     * Sign a stake request.
+     *
+     * Same as {@link signStake}
+     */
+    get stake() {
+        return this.signStake.bind(this);
+    }
+    /**
+     * Sign an unstake request.
+     *
+     * Same as {@link signUnstake}
+     */
+    get unstake() {
+        return this.signUnstake.bind(this);
+    }
+}
+exports.CubeSignerClient = CubeSignerClient;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"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","sourcesContent":["import { SignerSessionManager, SignerSessionStorage } from \"./session/signer_session_manager\";\nimport { CubeSignerApi, OidcClient } from \"./api\";\nimport { KeyType, Key } from \"./key\";\nimport { OrgInfo, RatchetConfig } from \"./schema_types\";\nimport { MfaReceipt } from \"./mfa\";\nimport { PageOpts } from \"./paginator\";\nimport { Role } from \"./role\";\n\n// used in doc comments\n// eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars\nimport { AddFidoChallenge, MfaFidoChallenge, TotpChallenge } from \"./mfa\";\nimport { JsonFileSessionStorage, MemorySessionStorage } from \"./session/session_storage\";\nimport { configDir, pathJoin } from \"./util\";\n\n/** Options for logging in with OIDC token */\nexport interface OidcAuthOptions {\n  /** Optional token lifetimes */\n  lifetimes?: RatchetConfig;\n  /** Optional MFA receipt */\n  mfaReceipt?: MfaReceipt;\n  /** Optional storage to use for the returned session (defaults to {@link MemorySessionStorage}) */\n  storage?: SignerSessionStorage;\n}\n\n/**\n * Client to use to send requests to CubeSigner services\n * when authenticating using a CubeSigner session token.\n */\nexport class CubeSignerClient extends CubeSignerApi {\n  /**\n   * Constructor.\n   * @param {SignerSessionManager} sessionMgr The session manager to use\n   * @param {string?} orgId Optional organization ID; if omitted, uses the org ID from the session manager.\n   */\n  constructor(sessionMgr: SignerSessionManager, orgId?: string) {\n    super(sessionMgr, orgId);\n  }\n\n  /**\n   * Returns a new instance of this class using the same session manager but targeting a different organization.\n   *\n   * @param {string} orgId The organization ID.\n   * @return {CubeSignerClient} A new instance of this class using the same session manager but targeting different organization.\n   */\n  withOrg(orgId?: string): CubeSignerClient {\n    return orgId ? new CubeSignerClient(this.sessionMgr, orgId) : this;\n  }\n\n  /**\n   * Loads an existing management session and creates a {@link CubeSignerClient} instance.\n   *\n   * @param {SignerSessionStorage} storage Optional storage from which to load the session (defaults to the default management session json file location)\n   * @return {Promise<CubeSignerClient>} New CubeSigner instance\n   */\n  static async loadManagementSession(storage?: SignerSessionStorage): Promise<CubeSignerClient> {\n    const filePath = pathJoin(configDir(), \"management-session.json\");\n    storage ??= new JsonFileSessionStorage(filePath);\n\n    // Throw and actionable error if the management session file contains a Cognito session\n    const session = await storage.retrieve();\n    if ((session as unknown as { id_token: string }).id_token) {\n      throw new Error(\n        `It appears that the '${filePath}' file contains the old (Cognito) session; please update your session by updating your 'cs' to version 'v0.37.0' or later and then running 'cs login'`,\n      );\n    }\n\n    const mgr = await SignerSessionManager.loadFromStorage(storage);\n    return new CubeSignerClient(mgr);\n  }\n\n  /**\n   * Create a new signing key.\n   * @param {KeyType} type The type of key to create.\n   * @param {string?} ownerId The owner of the key. Defaults to the session's user.\n   * @return {Key[]} The new keys.\n   */\n  async createKey(type: KeyType, ownerId?: string): Promise<Key> {\n    return (await this.createKeys(type, 1, ownerId))[0];\n  }\n\n  /**\n   * Create new signing keys.\n   * @param {KeyType} type The type of key to create.\n   * @param {number} count The number of keys to create.\n   * @param {string?} ownerId The owner of the keys. Defaults to the session's user.\n   * @return {Key[]} The new keys.\n   */\n  async createKeys(type: KeyType, count: number, ownerId?: string): Promise<Key[]> {\n    const keys = await this.keysCreate(type, count, ownerId);\n    return keys.map((k) => new Key(this, k));\n  }\n\n  /**\n   * Derive a key of the given type using the given derivation path and mnemonic.\n   * The owner of the derived key will be the owner of the mnemonic.\n   *\n   * @param {KeyType} type Type of key to derive from the mnemonic.\n   * @param {string} derivationPath Mnemonic derivation path used to generate new key.\n   * @param {string} mnemonicId materialId of mnemonic key used to derive the new key.\n   *\n   * @return {Key} newly derived key or undefined if it already exists.\n   */\n  async deriveKey(\n    type: KeyType,\n    derivationPath: string,\n    mnemonicId: string,\n  ): Promise<Key | undefined> {\n    return (await this.deriveKeys(type, [derivationPath], mnemonicId))[0];\n  }\n\n  /**\n   * Derive a set of keys of the given type using the given derivation paths and mnemonic.\n   *\n   * The owner of the derived keys will be the owner of the mnemonic.\n   *\n   * @param {KeyType} type Type of key to derive from the mnemonic.\n   * @param {string[]} derivationPaths Mnemonic derivation paths used to generate new key.\n   * @param {string} mnemonicId materialId of mnemonic key used to derive the new key.\n   *\n   * @return {Key[]} newly derived keys.\n   */\n  async deriveKeys(type: KeyType, derivationPaths: string[], mnemonicId: string): Promise<Key[]> {\n    const keys = await this.keysDerive(type, derivationPaths, mnemonicId);\n    return keys.map((k) => new Key(this, k));\n  }\n\n  /**\n   * Create a new {@link OidcClient} that will use a given OIDC token for auth.\n   * @param {string} oidcToken The authentication token to use\n   * @return {OidcClient} New OIDC client.\n   */\n  newOidcClient(oidcToken: string): OidcClient {\n    return new OidcClient(this.sessionMgr.env, this.orgId, oidcToken);\n  }\n\n  /**\n   * Authenticate an OIDC user and create a new session manager for them.\n   *\n   * @param {string} oidcToken The OIDC token\n   * @param {List<string>} scopes The scopes of the resulting session\n   * @param {OidcAuthOptions} options Options.\n   * @return {Promise<SignerSessionManager>} The signer session manager\n   */\n  async oidcAuth(\n    oidcToken: string,\n    scopes: Array<string>,\n    options?: OidcAuthOptions,\n  ): Promise<SignerSessionManager> {\n    const oidcClient = this.newOidcClient(oidcToken);\n    const resp = await oidcClient.sessionCreate(scopes, options?.lifetimes, options?.mfaReceipt);\n    return await SignerSessionManager.loadFromStorage(new MemorySessionStorage(resp.data()));\n  }\n\n  /**\n   * Create a new user in the organization and sends an invitation to that user.\n   *\n   * Same as {@link orgUserInvite}.\n   */\n  get createUser() {\n    return this.orgUserInvite.bind(this);\n  }\n\n  /**\n   * Create a new OIDC user.\n   *\n   * Same as {@link orgUserCreateOidc}.\n   */\n  get createOidcUser() {\n    return this.orgUserCreateOidc.bind(this);\n  }\n\n  /**\n   * Delete an existing OIDC user.\n   *\n   * Same as {@link orgUserDeleteOidc}.\n   */\n  get deleteOidcUser() {\n    return this.orgUserDeleteOidc.bind(this);\n  }\n\n  /**\n   * List users in the organization.\n   *\n   * Same as {@link orgUsersList}\n   */\n  get users() {\n    return this.orgUsersList.bind(this);\n  }\n\n  /**\n   * Obtain information about the current user.\n   *\n   * Same as {@link userGet}\n   */\n  get user() {\n    return this.userGet.bind(this);\n  }\n\n  /**\n   * Get information about a specific org.\n   *\n   * @param {string?} orgId The ID or name of the org\n   * @return {Promise<OrgInfo>} CubeSigner client for the requested org.\n   */\n  async org(orgId?: string): Promise<OrgInfo> {\n    return await this.withOrg(orgId).orgGet();\n  }\n\n  /**\n   * Obtain information about the current user.\n   *\n   * Same as {@link userGet}\n   */\n  get aboutMe() {\n    return this.userGet.bind(this);\n  }\n\n  /**\n   * Get a key by id.\n   *\n   * @param {string} keyId The id of the key to get.\n   * @return {Key} The key.\n   */\n  async getKey(keyId: string): Promise<Key> {\n    const keyInfo = await this.keyGet(keyId);\n    return new Key(this, keyInfo);\n  }\n\n  /**\n   * Get all keys in the org.\n   *\n   * @param {KeyType?} type Optional key type to filter list for.\n   * @param {PageOpts} page Pagination options. Defaults to fetching the entire result set.\n   * @return {Promise<Key[]>} The keys.\n   */\n  async orgKeys(type?: KeyType, page?: PageOpts): Promise<Key[]> {\n    const paginator = this.keysList(type, page);\n    const keys = await paginator.fetch();\n    return keys.map((k) => new Key(this, k));\n  }\n\n  /**\n   * Create a new role.\n   *\n   * @param {string?} name The name of the role.\n   * @return {Role} The new role.\n   */\n  async createRole(name?: string): Promise<Role> {\n    const roleId = await this.roleCreate(name);\n    const roleInfo = await this.roleGet(roleId);\n    return new Role(this, roleInfo);\n  }\n\n  /**\n   * Get a role by id or name.\n   *\n   * @param {string} roleId The id or name of the role to get.\n   * @return {Role} The role.\n   */\n  async getRole(roleId: string): Promise<Role> {\n    const roleInfo = await this.roleGet(roleId);\n    return new Role(this, roleInfo);\n  }\n\n  /**\n   * List all roles in the org.\n   *\n   * @param {PageOpts} page Pagination options. Defaults to fetching the entire result set.\n   * @return {Role[]} The roles.\n   */\n  async listRoles(page?: PageOpts): Promise<Role[]> {\n    const roles = await this.rolesList(page).fetch();\n    return roles.map((r) => new Role(this, r));\n  }\n\n  /**\n   * List all users in the org.\n   *\n   * Same as {@link orgUsersList}\n   */\n  get listUsers() {\n    return this.orgUsersList.bind(this);\n  }\n\n  /**\n   * Approve a pending MFA request.\n   *\n   * Same as {@link mfaApprove}\n   */\n  get approveMfaRequest() {\n    return this.mfaApprove.bind(this);\n  }\n\n  /**\n   * Approve a pending MFA request using TOTP.\n   *\n   * Same as {@link mfaApproveTotp}\n   */\n  get totpApprove() {\n    return this.mfaApproveTotp.bind(this);\n  }\n\n  /**\n   * Initiate approval of an existing MFA request using FIDO.\n   *\n   * Returns a {@link MfaFidoChallenge} that must be answered by calling\n   * {@link MfaFidoChallenge.answer} or {@link fidoApproveComplete}.\n   *\n   * Same as {@link mfaApproveFidoInit}\n   */\n  get fidoApproveStart() {\n    return this.mfaApproveFidoInit.bind(this);\n  }\n\n  /**\n   * Answer the MFA approval with FIDO challenge issued by {@link fidoApproveStart}.\n   *\n   * Same as {@link mfaApproveFidoComplete}\n   */\n  get fidoApproveComplete() {\n    return this.mfaApproveFidoComplete.bind(this);\n  }\n\n  /**\n   * Get a pending MFA request by its id.\n   *\n   * Same as {@link mfaGet}\n   */\n  get getMfaInfo() {\n    return this.mfaGet.bind(this);\n  }\n\n  /**\n   * List pending MFA requests accessible to the current user.\n   *\n   * Same as {@link mfaList}\n   */\n  get listMfaInfos() {\n    return this.mfaList.bind(this);\n  }\n\n  /**\n   * Obtain a proof of authentication.\n   *\n   * Same as {@link identityProve}\n   */\n  get proveIdentity() {\n    return this.identityProve.bind(this);\n  }\n\n  /**\n   * Check if a given proof of OIDC authentication is valid.\n   *\n   * Same as {@link identityVerify}\n   */\n  get verifyIdentity() {\n    return this.identityVerify.bind(this);\n  }\n\n  /**\n   * Creates a request to add a new FIDO device.\n   *\n   * Returns a {@link AddFidoChallenge} that must be answered by calling {@link AddFidoChallenge.answer}.\n   *\n   * MFA may be required.\n   *\n   * Same as {@link userFidoRegisterInit}\n   */\n  get addFidoStart() {\n    return this.userFidoRegisterInit.bind(this);\n  }\n\n  /**\n   * Delete a FIDO key from the user's account.\n   * Allowed only if TOTP is also defined.\n   * MFA via TOTP is always required.\n   *\n   * Same as {@link userFidoDelete}\n   */\n  get deleteFido() {\n    return this.userFidoDelete.bind(this);\n  }\n\n  /**\n   * Creates a request to change user's TOTP. Returns a {@link TotpChallenge}\n   * that must be answered by calling {@link TotpChallenge.answer} or\n   * {@link resetTotpComplete}.\n   *\n   * Same as {@link userTotpResetInit}\n   */\n  get resetTotpStart() {\n    return this.userTotpResetInit.bind(this);\n  }\n\n  /**\n   * Answer the TOTP challenge issued by {@link resetTotpStart}. If successful,\n   * user's TOTP configuration will be updated to that of the TOTP challenge.\n   *\n   * Same as {@link userTotpResetComplete}\n   */\n  get resetTotpComplete() {\n    return this.userTotpResetComplete.bind(this);\n  }\n\n  /**\n   * Verifies a given TOTP code against the current user's TOTP configuration.\n   * Throws an error if the verification fails.\n   *\n   * Same as {@link userTotpVerify}\n   */\n  get verifyTotp() {\n    return this.userTotpVerify.bind(this);\n  }\n\n  /**\n   * Delete TOTP from the user's account.\n   * Allowed only if at least one FIDO key is registered with the user's account.\n   * MFA via FIDO is always required.\n   *\n   * Same as {@link userTotpDelete}.\n   */\n  get deleteTotp() {\n    return this.userTotpDelete.bind(this);\n  }\n\n  /**\n   * Sign a stake request.\n   *\n   * Same as {@link signStake}\n   */\n  get stake() {\n    return this.signStake.bind(this);\n  }\n\n  /**\n   * Sign an unstake request.\n   *\n   * Same as {@link signUnstake}\n   */\n  get unstake() {\n    return this.signUnstake.bind(this);\n  }\n}\n"]}

package/dist/src/env.d.ts

@@ -0,0 +1,15 @@
+export type Environment = 
+/** Production environment */
+"prod"
+/** Gamma, staging environment */
+ | "gamma"
+/** Beta, development environment */
+ | "beta";
+export interface EnvInterface {
+    ClientId: string;
+    LongLivedClientId: string;
+    Region: string;
+    UserPoolId: string;
+    SignerApiRoot: string;
+}
+export declare const envs: Record<Environment, EnvInterface>;

package/dist/src/env.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envs = void 0;
+const prodSpec = __importStar(require("../spec/env/prod.json"));
+const gammaSpec = __importStar(require("../spec/env/gamma.json"));
+const betaSpec = __importStar(require("../spec/env/beta.json"));
+exports.envs = {
+    prod: prodSpec["Dev-CubeSignerStack"],
+    gamma: gammaSpec["Dev-CubeSignerStack"],
+    beta: betaSpec["Dev-CubeSignerStack"],
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Vudi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGdFQUFrRDtBQUNsRCxrRUFBb0Q7QUFDcEQsZ0VBQWtEO0FBa0JyQyxRQUFBLElBQUksR0FBc0M7SUFDckQsSUFBSSxFQUFFLFFBQVEsQ0FBQyxxQkFBcUIsQ0FBQztJQUNyQyxLQUFLLEVBQUUsU0FBUyxDQUFDLHFCQUFxQixDQUFDO0lBQ3ZDLElBQUksRUFBRSxRQUFRLENBQUMscUJBQXFCLENBQUM7Q0FDdEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIHByb2RTcGVjIGZyb20gXCIuLi9zcGVjL2Vudi9wcm9kLmpzb25cIjtcbmltcG9ydCAqIGFzIGdhbW1hU3BlYyBmcm9tIFwiLi4vc3BlYy9lbnYvZ2FtbWEuanNvblwiO1xuaW1wb3J0ICogYXMgYmV0YVNwZWMgZnJvbSBcIi4uL3NwZWMvZW52L2JldGEuanNvblwiO1xuXG5leHBvcnQgdHlwZSBFbnZpcm9ubWVudCA9XG4gIC8qKiBQcm9kdWN0aW9uIGVudmlyb25tZW50ICovXG4gIHwgXCJwcm9kXCJcbiAgLyoqIEdhbW1hLCBzdGFnaW5nIGVudmlyb25tZW50ICovXG4gIHwgXCJnYW1tYVwiXG4gIC8qKiBCZXRhLCBkZXZlbG9wbWVudCBlbnZpcm9ubWVudCAqL1xuICB8IFwiYmV0YVwiO1xuXG5leHBvcnQgaW50ZXJmYWNlIEVudkludGVyZmFjZSB7XG4gIENsaWVudElkOiBzdHJpbmc7XG4gIExvbmdMaXZlZENsaWVudElkOiBzdHJpbmc7XG4gIFJlZ2lvbjogc3RyaW5nO1xuICBVc2VyUG9vbElkOiBzdHJpbmc7XG4gIFNpZ25lckFwaVJvb3Q6IHN0cmluZztcbn1cblxuZXhwb3J0IGNvbnN0IGVudnM6IFJlY29yZDxFbnZpcm9ubWVudCwgRW52SW50ZXJmYWNlPiA9IHtcbiAgcHJvZDogcHJvZFNwZWNbXCJEZXYtQ3ViZVNpZ25lclN0YWNrXCJdLFxuICBnYW1tYTogZ2FtbWFTcGVjW1wiRGV2LUN1YmVTaWduZXJTdGFja1wiXSxcbiAgYmV0YTogYmV0YVNwZWNbXCJEZXYtQ3ViZVNpZ25lclN0YWNrXCJdLFxufTtcbiJdfQ==

package/dist/src/error.d.ts

@@ -0,0 +1,29 @@
+import { operations } from "./schema";
+/**
+ * Error response type, thrown on non-successful responses.
+ */
+export declare class ErrResponse extends Error {
+    /** Operation that produced this error */
+    readonly operation?: keyof operations;
+    /** HTTP status code text (derived from `this.status`) */
+    readonly statusText?: string;
+    /** HTTP status code */
+    readonly status?: number;
+    /** HTTP response url */
+    readonly url?: string;
+    /**
+     * @param {Partial<ErrResponse>} init Initializer
+     */
+    constructor(init: Partial<ErrResponse>);
+}
+/**
+ * An error that is thrown when a session has expired
+ */
+export declare class SessionExpiredError extends ErrResponse {
+    /**
+     * Constructor.
+     *
+     * @param {operations} operation The operation that was attempted
+     */
+    constructor(operation?: keyof operations);
+}

package/dist/src/error.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionExpiredError = exports.ErrResponse = void 0;
+/**
+ * Error response type, thrown on non-successful responses.
+ */
+class ErrResponse extends Error {
+    /**
+     * @param {Partial<ErrResponse>} init Initializer
+     */
+    constructor(init) {
+        super(init.message);
+        Object.assign(this, init);
+    }
+}
+exports.ErrResponse = ErrResponse;
+/**
+ * An error that is thrown when a session has expired
+ */
+class SessionExpiredError extends ErrResponse {
+    /**
+     * Constructor.
+     *
+     * @param {operations} operation The operation that was attempted
+     */
+    constructor(operation) {
+        super({
+            message: "Session has expired",
+            status: 403,
+            statusText: "Forbidden",
+            operation,
+        });
+    }
+}
+exports.SessionExpiredError = SessionExpiredError;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/events.d.ts

@@ -0,0 +1,84 @@
+import { ErrResponse } from "./error";
+export type EventHandler<T> = (event: T) => Promise<void>;
+export type ErrorEvent = ErrResponse;
+export interface SessionExpiredEvent {
+}
+/**
+ * Whether an error message matches one of several different "session expired" responses.
+ *
+ * @param {string} msg The string to test.
+ * @return {boolean} Whether the string matches.
+ * @internal Exported only so that it can be called from a unit test
+ */
+export declare function messageMatchesSessionExpired(msg: string): boolean;
+/**
+ * Class for registering and unregistering event handlers.
+ */
+export declare class Events {
+    #private;
+    /**
+     * Register a handler for {@link ErrorEvent}: triggered every time a request to
+     * a CubeSigner API endpoint returns a non-success response.
+     *
+     * @param {EventHandler<ErrorEvent>} handler The handler to register.
+     */
+    onError(handler: EventHandler<ErrorEvent>): void;
+    /**
+     * Register a handler for {@link SessionExpiredEvent}: triggered every time a
+     * request to a CubeSigner API endpoint fails because of an expired session.
+     *
+     * @param {EventHandler<SessionExpiredEvent>} handler The handler to register.
+     */
+    onSessionExpired(handler: EventHandler<SessionExpiredEvent>): void;
+    /**
+     * Unregister a handler for {@link ErrorEvent}.
+     *
+     * @param {EventHandler<ErrorEvent>} handler The handler to unregister.
+     * @return {boolean} Whether the handler was found (and unregistered).
+     */
+    unregisterOnError(handler: EventHandler<ErrorEvent>): boolean;
+    /**
+     * Unregister a handler for {@link SessionExpiredEvent}.
+     *
+     * @param {EventHandler<SessionExpiredEvent>} handler The handler to unregister.
+     * @return {boolean} Whether the handler was found (and unregistered).
+     */
+    unregisterOnSessionExpired(handler: EventHandler<SessionExpiredEvent>): boolean;
+    /** @internal */
+    triggerSessionExpired(): Promise<void>;
+    /**
+     * @param {ErrorEvent} event Event to trigger
+     * @internal
+     */
+    triggerErrorEvent(event: ErrorEvent): Promise<void>;
+}
+/**
+ * Used to classify and emit events to one or more {@link Events} instances.
+ */
+export declare class EventEmitter {
+    #private;
+    /**
+     *
+     * @param {Events[]} events Instances to which to emit events
+     * @param {boolean} skipGlobal Whether to include the global events instance {@link GlobalEvents}
+     */
+    constructor(events: Events[], skipGlobal?: boolean);
+    /**
+     * Called by {@link CubeSignerApi} when an API response indicates an error.
+     *
+     * @param {ErrorEvent} err The error to dispatch.
+     * @internal
+     */
+    classifyAndEmitError(err: ErrorEvent): Promise<void>;
+    /**
+     * Called by {@link SignerSessionManager} to notify that the session is expired
+     * beyond the possibility of refreshing, meaning that full re-login is required.
+     *
+     * @internal
+     */
+    emitSessionExpired(): Promise<void>;
+}
+/**
+ * Global events.
+ */
+export declare const GlobalEvents: Events;