@cubist-labs/cubesigner-sdk 0.2.28 → 0.3.8

package/dist/esm/src/client.js

@@ -0,0 +1,451 @@
+import { SignerSessionManager } from "./session/signer_session_manager";
+import { CubeSignerApi, OidcClient } from "./api";
+import { Key } from "./key";
+import { Role } from "./role";
+import { MemorySessionStorage } from "./session/session_storage";
+/**
+ * Client to use to send requests to CubeSigner services
+ * when authenticating using a CubeSigner session token.
+ */
+export class CubeSignerClient extends 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 Storage from which to load the session
+     * @return {Promise<CubeSignerClient>} New CubeSigner instance
+     */
+    static async loadManagementSession(storage) {
+        // 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 storage 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 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(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(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 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 SignerSessionManager.loadFromStorage(new 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(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(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(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(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(this, r));
+    }
+    /**
+     * List all users in the org.
+     *
+     * Same as {@link orgUsersList}
+     */
+    get listUsers() {
+        return this.orgUsersList.bind(this);
+    }
+    /**
+     * Approve a pending MFA request using the current session.
+     *
+     * @param {string} mfaId The id of the MFA request
+     * @return {Promise<MfaRequestInfo>} The result of the MFA request
+     */
+    async mfaApprove(mfaId) {
+        return await this.mfaVoteCs(mfaId, "approve");
+    }
+    /**
+     * Reject a pending MFA request using the current session.
+     *
+     * @param {string} mfaId The id of the MFA request
+     * @return {Promise<MfaRequestInfo>} The result of the MFA request
+     */
+    async mfaReject(mfaId) {
+        return await this.mfaVoteCs(mfaId, "reject");
+    }
+    /**
+     * Approve a pending MFA request.
+     *
+     * Same as {@link mfaApprove}
+     */
+    get approveMfaRequest() {
+        return this.mfaApprove.bind(this);
+    }
+    /**
+     * Approve a pending MFA request using TOTP.
+     *
+     * @param {string} mfaId The MFA request to approve
+     * @param {string} code The TOTP code
+     * @return {Promise<MfaRequestInfo>} The current status of the MFA request
+     */
+    async mfaApproveTotp(mfaId, code) {
+        return await this.mfaVoteTotp(mfaId, code, "approve");
+    }
+    /**
+     * Reject a pending MFA request using TOTP.
+     *
+     * @param {string} mfaId The MFA request to reject
+     * @param {string} code The TOTP code
+     * @return {Promise<MfaRequestInfo>} The current status of the MFA request
+     */
+    async mfaRejectTotp(mfaId, code) {
+        return await this.mfaVoteTotp(mfaId, code, "reject");
+    }
+    /**
+     * 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 fidoApproveFidoInit() {
+        return this.mfaFidoInit.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.mfaFidoInit.bind(this);
+    }
+    /**
+     * Approve a previously initiated (via {@link mfaApproveFidoInit}) MFA request using FIDO.
+     *
+     * Instead of calling this method directly, prefer {@link MfaFidoChallenge.answer} or
+     * {@link MfaFidoChallenge.createCredentialAndAnswer}.
+     *
+     * @param {string} mfaId The MFA request ID
+     * @param {string} challengeId The ID of the challenge issued by {@link mfaApproveFidoInit}
+     * @param {PublicKeyCredential} credential The answer to the challenge
+     * @return {Promise<MfaRequestInfo>} The current status of the MFA request.
+     */
+    async mfaApproveFidoComplete(mfaId, challengeId, credential) {
+        return await this.mfaVoteFidoComplete(mfaId, "approve", challengeId, credential);
+    }
+    /**
+     * Reject a previously initiated (via {@link mfaApproveFidoInit}) MFA request using FIDO.
+     *
+     * Instead of calling this method directly, prefer {@link MfaFidoChallenge.answer} or
+     * {@link MfaFidoChallenge.createCredentialAndAnswer}.
+     *
+     * @param {string} mfaId The MFA request ID
+     * @param {string} challengeId The ID of the challenge issued by {@link mfaApproveFidoInit}
+     * @param {PublicKeyCredential} credential The answer to the challenge
+     * @return {Promise<MfaRequestInfo>} The current status of the MFA request.
+     */
+    async mfaRejectFidoComplete(mfaId, challengeId, credential) {
+        return await this.mfaVoteFidoComplete(mfaId, "reject", challengeId, credential);
+    }
+    /**
+     * 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);
+    }
+}
+//# 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 { MfaRequestInfo, OrgInfo, PublicKeyCredential, 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 { MemorySessionStorage } from \"./session/session_storage\";\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 Storage from which to load the session\n   * @return {Promise<CubeSignerClient>} New CubeSigner instance\n   */\n  static async loadManagementSession(storage: SignerSessionStorage): Promise<CubeSignerClient> {\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 storage 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 using the current session.\n   *\n   * @param {string} mfaId The id of the MFA request\n   * @return {Promise<MfaRequestInfo>} The result of the MFA request\n   */\n  async mfaApprove(mfaId: string): Promise<MfaRequestInfo> {\n    return await this.mfaVoteCs(mfaId, \"approve\");\n  }\n\n  /**\n   * Reject a pending MFA request using the current session.\n   *\n   * @param {string} mfaId The id of the MFA request\n   * @return {Promise<MfaRequestInfo>} The result of the MFA request\n   */\n  async mfaReject(mfaId: string): Promise<MfaRequestInfo> {\n    return await this.mfaVoteCs(mfaId, \"reject\");\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   * @param {string} mfaId The MFA request to approve\n   * @param {string} code The TOTP code\n   * @return {Promise<MfaRequestInfo>} The current status of the MFA request\n   */\n  async mfaApproveTotp(mfaId: string, code: string): Promise<MfaRequestInfo> {\n    return await this.mfaVoteTotp(mfaId, code, \"approve\");\n  }\n\n  /**\n   * Reject a pending MFA request using TOTP.\n   *\n   * @param {string} mfaId The MFA request to reject\n   * @param {string} code The TOTP code\n   * @return {Promise<MfaRequestInfo>} The current status of the MFA request\n   */\n  async mfaRejectTotp(mfaId: string, code: string): Promise<MfaRequestInfo> {\n    return await this.mfaVoteTotp(mfaId, code, \"reject\");\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 fidoApproveFidoInit() {\n    return this.mfaFidoInit.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.mfaFidoInit.bind(this);\n  }\n\n  /**\n   * Approve a previously initiated (via {@link mfaApproveFidoInit}) MFA request using FIDO.\n   *\n   * Instead of calling this method directly, prefer {@link MfaFidoChallenge.answer} or\n   * {@link MfaFidoChallenge.createCredentialAndAnswer}.\n   *\n   * @param {string} mfaId The MFA request ID\n   * @param {string} challengeId The ID of the challenge issued by {@link mfaApproveFidoInit}\n   * @param {PublicKeyCredential} credential The answer to the challenge\n   * @return {Promise<MfaRequestInfo>} The current status of the MFA request.\n   */\n  async mfaApproveFidoComplete(\n    mfaId: string,\n    challengeId: string,\n    credential: PublicKeyCredential,\n  ): Promise<MfaRequestInfo> {\n    return await this.mfaVoteFidoComplete(mfaId, \"approve\", challengeId, credential);\n  }\n\n  /**\n   * Reject a previously initiated (via {@link mfaApproveFidoInit}) MFA request using FIDO.\n   *\n   * Instead of calling this method directly, prefer {@link MfaFidoChallenge.answer} or\n   * {@link MfaFidoChallenge.createCredentialAndAnswer}.\n   *\n   * @param {string} mfaId The MFA request ID\n   * @param {string} challengeId The ID of the challenge issued by {@link mfaApproveFidoInit}\n   * @param {PublicKeyCredential} credential The answer to the challenge\n   * @return {Promise<MfaRequestInfo>} The current status of the MFA request.\n   */\n  async mfaRejectFidoComplete(\n    mfaId: string,\n    challengeId: string,\n    credential: PublicKeyCredential,\n  ): Promise<MfaRequestInfo> {\n    return await this.mfaVoteFidoComplete(mfaId, \"reject\", challengeId, credential);\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/esm/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/esm/src/env.js

@@ -0,0 +1,9 @@
+import * as prodSpec from "../spec/env/prod.json";
+import * as gammaSpec from "../spec/env/gamma.json";
+import * as betaSpec from "../spec/env/beta.json";
+export const envs = {
+    prod: prodSpec["Dev-CubeSignerStack"],
+    gamma: gammaSpec["Dev-CubeSignerStack"],
+    beta: betaSpec["Dev-CubeSignerStack"],
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2Vudi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssUUFBUSxNQUFNLHVCQUF1QixDQUFDO0FBQ2xELE9BQU8sS0FBSyxTQUFTLE1BQU0sd0JBQXdCLENBQUM7QUFDcEQsT0FBTyxLQUFLLFFBQVEsTUFBTSx1QkFBdUIsQ0FBQztBQWtCbEQsTUFBTSxDQUFDLE1BQU0sSUFBSSxHQUFzQztJQUNyRCxJQUFJLEVBQUUsUUFBUSxDQUFDLHFCQUFxQixDQUFDO0lBQ3JDLEtBQUssRUFBRSxTQUFTLENBQUMscUJBQXFCLENBQUM7SUFDdkMsSUFBSSxFQUFFLFFBQVEsQ0FBQyxxQkFBcUIsQ0FBQztDQUN0QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgcHJvZFNwZWMgZnJvbSBcIi4uL3NwZWMvZW52L3Byb2QuanNvblwiO1xuaW1wb3J0ICogYXMgZ2FtbWFTcGVjIGZyb20gXCIuLi9zcGVjL2Vudi9nYW1tYS5qc29uXCI7XG5pbXBvcnQgKiBhcyBiZXRhU3BlYyBmcm9tIFwiLi4vc3BlYy9lbnYvYmV0YS5qc29uXCI7XG5cbmV4cG9ydCB0eXBlIEVudmlyb25tZW50ID1cbiAgLyoqIFByb2R1Y3Rpb24gZW52aXJvbm1lbnQgKi9cbiAgfCBcInByb2RcIlxuICAvKiogR2FtbWEsIHN0YWdpbmcgZW52aXJvbm1lbnQgKi9cbiAgfCBcImdhbW1hXCJcbiAgLyoqIEJldGEsIGRldmVsb3BtZW50IGVudmlyb25tZW50ICovXG4gIHwgXCJiZXRhXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgRW52SW50ZXJmYWNlIHtcbiAgQ2xpZW50SWQ6IHN0cmluZztcbiAgTG9uZ0xpdmVkQ2xpZW50SWQ6IHN0cmluZztcbiAgUmVnaW9uOiBzdHJpbmc7XG4gIFVzZXJQb29sSWQ6IHN0cmluZztcbiAgU2lnbmVyQXBpUm9vdDogc3RyaW5nO1xufVxuXG5leHBvcnQgY29uc3QgZW52czogUmVjb3JkPEVudmlyb25tZW50LCBFbnZJbnRlcmZhY2U+ID0ge1xuICBwcm9kOiBwcm9kU3BlY1tcIkRldi1DdWJlU2lnbmVyU3RhY2tcIl0sXG4gIGdhbW1hOiBnYW1tYVNwZWNbXCJEZXYtQ3ViZVNpZ25lclN0YWNrXCJdLFxuICBiZXRhOiBiZXRhU3BlY1tcIkRldi1DdWJlU2lnbmVyU3RhY2tcIl0sXG59O1xuIl19

package/dist/esm/src/error.d.ts

@@ -0,0 +1,32 @@
+import { CsErrCode } from "./schema_types";
+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;
+    /** CubeSigner error code */
+    readonly errorCode?: CsErrCode;
+    /**
+     * @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/esm/src/error.js

@@ -0,0 +1,32 @@
+/**
+ * Error response type, thrown on non-successful responses.
+ */
+export class ErrResponse extends Error {
+    /**
+     * @param {Partial<ErrResponse>} init Initializer
+     */
+    constructor(init) {
+        super(init.message);
+        Object.assign(this, init);
+    }
+}
+/**
+ * An error that is thrown when a session has expired
+ */
+export 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,
+            errorCode: "SessionExpired",
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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