@cubist-labs/cubesigner-sdk 0.2.24 → 0.3.1

package/dist/esm/src/org.js

@@ -0,0 +1,91 @@
+import { CubeSignerClient } from "./client";
+import { SignerSessionManager } from ".";
+/**
+ * An organization.
+ *
+ * Extends {@link CubeSignerClient} and provides a few org-specific methods on top.
+ */
+export class Org extends CubeSignerClient {
+    /**
+     * @description The org id
+     * @example Org#c3b9379c-4e8c-4216-bd0a-65ace53cf98f
+     */
+    get id() {
+        return this.orgId;
+    }
+    /**
+     * Obtain information about the current organization.
+     *
+     * Same as {@link orgGet}.
+     */
+    get info() {
+        return this.orgGet.bind(this);
+    }
+    /** Human-readable name for the org */
+    async name() {
+        const org = await this.orgGet();
+        return org.name ?? undefined;
+    }
+    /** Get all keys in the org. */
+    get keys() {
+        return this.orgKeys.bind(this);
+    }
+    /**
+     * Set the human-readable name for the org.
+     * @param {string} name The new human-readable name for the org (must be alphanumeric).
+     * @example my_org_name
+     */
+    async setName(name) {
+        if (!/^[a-zA-Z0-9_]{3,30}$/.test(name)) {
+            throw new Error("Org name must be alphanumeric and between 3 and 30 characters");
+        }
+        await this.orgUpdate({ name });
+    }
+    /** Is the org enabled? */
+    async enabled() {
+        const org = await this.orgGet();
+        return org.enabled;
+    }
+    /** Enable the org. */
+    async enable() {
+        await this.orgUpdate({ enabled: true });
+    }
+    /** Disable the org. */
+    async disable() {
+        await this.orgUpdate({ enabled: false });
+    }
+    /** Get the policy for the org. */
+    async policy() {
+        const org = await this.orgGet();
+        return (org.policy ?? []);
+    }
+    /**
+     * Set the policy for the org.
+     * @param {OrgPolicy[]} policy The new policy for the org.
+     */
+    async setPolicy(policy) {
+        const p = policy;
+        await this.orgUpdate({ policy: p });
+    }
+    /**
+     * Retrieve the org associated with a session.
+     * @param {SessionStorage} storage The session
+     * @return {Org} An {@link Org} instance for the org associated with this session.
+     */
+    static async retrieveFromStorage(storage) {
+        const sessionMgr = await SignerSessionManager.loadFromStorage(storage);
+        return new Org(new CubeSignerClient(sessionMgr), sessionMgr.orgId);
+    }
+    /**
+     * Constructor.
+     * @param {CubeSignerClient | SignerSessionManager} csc The CubeSigner instance.
+     * @param {OrgInfo| string} data Either org id or name or {@link OrgInfo}.
+     */
+    constructor(csc, data) {
+        const mgr = csc instanceof CubeSignerClient ? csc.sessionMgr : csc;
+        // NOTE: data can be OrgInfo for backward compatibility reasons
+        const orgId = typeof data === "string" ? data : data?.org_id;
+        super(mgr, orgId);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org.js","sourceRoot":"","sources":["../../../src/org.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAW,oBAAoB,EAAwB,MAAM,GAAG,CAAC;AA4CxE;;;;GAIG;AACH,MAAM,OAAO,GAAI,SAAQ,gBAAgB;IACvC;;;OAGG;IACH,IAAI,EAAE;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED;;;;OAIG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED,sCAAsC;IACtC,KAAK,CAAC,IAAI;QACR,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QAChC,OAAO,GAAG,CAAC,IAAI,IAAI,SAAS,CAAC;IAC/B,CAAC;IAED,+BAA+B;IAC/B,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,OAAO,CAAC,IAAY;QACxB,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACvC,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;QACnF,CAAC;QACD,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;IACjC,CAAC;IAED,0BAA0B;IAC1B,KAAK,CAAC,OAAO;QACX,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QAChC,OAAO,GAAG,CAAC,OAAO,CAAC;IACrB,CAAC;IAED,sBAAsB;IACtB,KAAK,CAAC,MAAM;QACV,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED,uBAAuB;IACvB,KAAK,CAAC,OAAO;QACX,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;IAC3C,CAAC;IAED,kCAAkC;IAClC,KAAK,CAAC,MAAM;QACV,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QAChC,OAAO,CAAC,GAAG,CAAC,MAAM,IAAI,EAAE,CAA2B,CAAC;IACtD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,SAAS,CAAC,MAAmB;QACjC,MAAM,CAAC,GAAG,MAA4C,CAAC;QACvD,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;IACtC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,OAA6B;QAC5D,MAAM,UAAU,GAAG,MAAM,oBAAoB,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QACvE,OAAO,IAAI,GAAG,CAAC,IAAI,gBAAgB,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;IACrE,CAAC;IAED;;;;OAIG;IACH,YAAY,GAA4C,EAAE,IAAuB;QAC/E,MAAM,GAAG,GAAG,GAAG,YAAY,gBAAgB,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAE,GAA4B,CAAC;QAE7F,+DAA+D;QAC/D,MAAM,KAAK,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC;QAC7D,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACpB,CAAC;CACF","sourcesContent":["import { CubeSignerClient } from \"./client\";\nimport { OrgInfo, SignerSessionManager, SignerSessionStorage } from \".\";\n\n/** Organization id */\nexport type OrgId = string;\n\n/** Org-wide policy */\nexport type OrgPolicy =\n  | SourceIpAllowlistPolicy\n  | OidcAuthSourcesPolicy\n  | OriginAllowlistPolicy\n  | MaxDailyUnstakePolicy;\n\n/**\n * Provides an allowlist of OIDC Issuers and audiences that are allowed to authenticate into this org.\n * @example {\"OidcAuthSources\": { \"https://accounts.google.com\": [ \"1234.apps.googleusercontent.com\" ]}}\n */\nexport interface OidcAuthSourcesPolicy {\n  OidcAuthSources: Record<string, string[]>;\n}\n\n/**\n * Only allow requests from the specified origins.\n * @example {\"OriginAllowlist\": \"*\"}\n */\nexport interface OriginAllowlistPolicy {\n  OriginAllowlist: string[] | \"*\";\n}\n\n/**\n * Restrict signing to specific source IP addresses.\n * @example {\"SourceIpAllowlist\": [\"10.1.2.3/8\", \"169.254.17.1/16\"]}\n */\nexport interface SourceIpAllowlistPolicy {\n  SourceIpAllowlist: string[];\n}\n\n/**\n * Restrict the number of unstakes per day.\n * @example {\"MaxDailyUnstake\": 5 }\n */\nexport interface MaxDailyUnstakePolicy {\n  MaxDailyUnstake: number;\n}\n\n/**\n * An organization.\n *\n * Extends {@link CubeSignerClient} and provides a few org-specific methods on top.\n */\nexport class Org extends CubeSignerClient {\n  /**\n   * @description The org id\n   * @example Org#c3b9379c-4e8c-4216-bd0a-65ace53cf98f\n   */\n  get id(): OrgId {\n    return this.orgId;\n  }\n\n  /**\n   * Obtain information about the current organization.\n   *\n   * Same as {@link orgGet}.\n   */\n  get info() {\n    return this.orgGet.bind(this);\n  }\n\n  /** Human-readable name for the org */\n  async name(): Promise<string | undefined> {\n    const org = await this.orgGet();\n    return org.name ?? undefined;\n  }\n\n  /** Get all keys in the org. */\n  get keys() {\n    return this.orgKeys.bind(this);\n  }\n\n  /**\n   * Set the human-readable name for the org.\n   * @param {string} name The new human-readable name for the org (must be alphanumeric).\n   * @example my_org_name\n   */\n  async setName(name: string) {\n    if (!/^[a-zA-Z0-9_]{3,30}$/.test(name)) {\n      throw new Error(\"Org name must be alphanumeric and between 3 and 30 characters\");\n    }\n    await this.orgUpdate({ name });\n  }\n\n  /** Is the org enabled? */\n  async enabled(): Promise<boolean> {\n    const org = await this.orgGet();\n    return org.enabled;\n  }\n\n  /** Enable the org. */\n  async enable() {\n    await this.orgUpdate({ enabled: true });\n  }\n\n  /** Disable the org. */\n  async disable() {\n    await this.orgUpdate({ enabled: false });\n  }\n\n  /** Get the policy for the org. */\n  async policy(): Promise<OrgPolicy[]> {\n    const org = await this.orgGet();\n    return (org.policy ?? []) as unknown as OrgPolicy[];\n  }\n\n  /**\n   * Set the policy for the org.\n   * @param {OrgPolicy[]} policy The new policy for the org.\n   */\n  async setPolicy(policy: OrgPolicy[]) {\n    const p = policy as unknown as Record<string, never>[];\n    await this.orgUpdate({ policy: p });\n  }\n\n  /**\n   * Retrieve the org associated with a session.\n   * @param {SessionStorage} storage The session\n   * @return {Org} An {@link Org} instance for the org associated with this session.\n   */\n  static async retrieveFromStorage(storage: SignerSessionStorage): Promise<Org> {\n    const sessionMgr = await SignerSessionManager.loadFromStorage(storage);\n    return new Org(new CubeSignerClient(sessionMgr), sessionMgr.orgId);\n  }\n\n  /**\n   * Constructor.\n   * @param {CubeSignerClient | SignerSessionManager} csc The CubeSigner instance.\n   * @param {OrgInfo| string} data Either org id or name or {@link OrgInfo}.\n   */\n  constructor(csc: CubeSignerClient | SignerSessionManager, data?: OrgInfo | string) {\n    const mgr = csc instanceof CubeSignerClient ? csc.sessionMgr : (csc as SignerSessionManager);\n\n    // NOTE: data can be OrgInfo for backward compatibility reasons\n    const orgId = typeof data === \"string\" ? data : data?.org_id;\n    super(mgr, orgId);\n  }\n}\n"]}

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

@@ -0,0 +1,76 @@
+/** Pagination options. */
+export interface PageOpts {
+    /** Max number of items per page. */
+    size?: number;
+    /**
+     * Starting point (i.e., 'last_evaluated_key' from the previous page).
+     * Omit to start from the beginning.
+     */
+    start?: string;
+    /** Iterate until retrieving the entire result set. */
+    all: boolean;
+}
+/** Static constructors for `IPage` */
+export declare class Page {
+    /**
+     * The default is to fetch the entire result set
+     * (by repeatedly calling the remote endpoint until all pages are retrieved).
+     *
+     * @return {PageOpts} Pagination options.
+     */
+    static default(): PageOpts;
+}
+export interface PageQueryArgs {
+    /**
+     * Max number of items to return per page.
+     *
+     * The actual number of returned items may be less that this, even if there exist more
+     * data in the result set. To reliably determine if more data is left in the result set,
+     * inspect the [UnencryptedLastEvalKey] value in the response object.
+     */
+    "page.size"?: number;
+    /**
+     * The start of the page.
+     *
+     * Omit to start from the beginning; otherwise, only specify the exact
+     * value previously returned as 'last_evaluated_key' from the same endpoint.
+     */
+    "page.start"?: string | null;
+}
+export type ListFn<U> = (pageQueryArgs: PageQueryArgs) => Promise<U>;
+export type ItemsFn<U, T> = (resp: U) => T[];
+export type LastFn<U> = (resp: U) => string | null | undefined;
+/**
+ * Helper class for fetching paginated results.
+ */
+export declare class Paginator<U, T> {
+    #private;
+    /**
+     * @param {PageOpts} pageOpts Pagination options
+     * @param {ListFn<U>} listFn Calls a remote endpoint that returns a paginated response
+     * @param {ItemsFn<U, T>} itemsFn Extracts items from the paginated response
+     * @param {LastFn<U>} lastFn Extracts the last evaluated key from the paginated response
+     */
+    constructor(pageOpts: PageOpts, listFn: ListFn<U>, itemsFn: ItemsFn<U, T>, lastFn: LastFn<U>);
+    /**
+     * Fetches either a single page or the entire result set, depending on
+     * the `all` property of the pagination options.
+     *
+     * @return {Promise<T[]>} A single page or the entire result set.
+     */
+    fetch(): Promise<T[]>;
+    /**
+     * Fetches a single page of the result set from where it previously left off.
+     * Mutates self to remember where it left off.
+     *
+     * @return {Promise<T[]>} The next page of the result set.
+     */
+    fetchPage(): Promise<T[]>;
+    /**
+     * Fetches the entire result set starting from where it previously left off
+     * by iterating through the pages returned by the remote end.
+     *
+     * @return {Promise<T[]>} The entire result set.
+     */
+    fetchAll(): Promise<T[]>;
+}

package/dist/esm/src/paginator.js

@@ -0,0 +1,94 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Paginator_listFn, _Paginator_itemsFn, _Paginator_lastFn, _Paginator_opts, _Paginator_last, _Paginator_done;
+/** Static constructors for `IPage` */
+export class Page {
+    /**
+     * The default is to fetch the entire result set
+     * (by repeatedly calling the remote endpoint until all pages are retrieved).
+     *
+     * @return {PageOpts} Pagination options.
+     */
+    static default() {
+        return {
+            all: true,
+        };
+    }
+}
+/**
+ * Helper class for fetching paginated results.
+ */
+export class Paginator {
+    /**
+     * @param {PageOpts} pageOpts Pagination options
+     * @param {ListFn<U>} listFn Calls a remote endpoint that returns a paginated response
+     * @param {ItemsFn<U, T>} itemsFn Extracts items from the paginated response
+     * @param {LastFn<U>} lastFn Extracts the last evaluated key from the paginated response
+     */
+    constructor(pageOpts, listFn, itemsFn, lastFn) {
+        _Paginator_listFn.set(this, void 0);
+        _Paginator_itemsFn.set(this, void 0);
+        _Paginator_lastFn.set(this, void 0);
+        _Paginator_opts.set(this, void 0);
+        _Paginator_last.set(this, void 0);
+        _Paginator_done.set(this, void 0);
+        __classPrivateFieldSet(this, _Paginator_listFn, listFn, "f");
+        __classPrivateFieldSet(this, _Paginator_itemsFn, itemsFn, "f");
+        __classPrivateFieldSet(this, _Paginator_lastFn, lastFn, "f");
+        __classPrivateFieldSet(this, _Paginator_opts, pageOpts, "f");
+        __classPrivateFieldSet(this, _Paginator_last, pageOpts.start, "f");
+        __classPrivateFieldSet(this, _Paginator_done, false, "f");
+    }
+    /**
+     * Fetches either a single page or the entire result set, depending on
+     * the `all` property of the pagination options.
+     *
+     * @return {Promise<T[]>} A single page or the entire result set.
+     */
+    async fetch() {
+        return __classPrivateFieldGet(this, _Paginator_opts, "f").all ? await this.fetchAll() : await this.fetchPage();
+    }
+    /**
+     * Fetches a single page of the result set from where it previously left off.
+     * Mutates self to remember where it left off.
+     *
+     * @return {Promise<T[]>} The next page of the result set.
+     */
+    async fetchPage() {
+        if (__classPrivateFieldGet(this, _Paginator_done, "f")) {
+            return [];
+        }
+        const resp = await __classPrivateFieldGet(this, _Paginator_listFn, "f").call(this, {
+            "page.size": __classPrivateFieldGet(this, _Paginator_opts, "f").size,
+            "page.start": __classPrivateFieldGet(this, _Paginator_last, "f"),
+        });
+        __classPrivateFieldSet(this, _Paginator_last, __classPrivateFieldGet(this, _Paginator_lastFn, "f").call(this, resp), "f");
+        __classPrivateFieldSet(this, _Paginator_done, !__classPrivateFieldGet(this, _Paginator_last, "f"), "f");
+        return __classPrivateFieldGet(this, _Paginator_itemsFn, "f").call(this, resp);
+    }
+    /**
+     * Fetches the entire result set starting from where it previously left off
+     * by iterating through the pages returned by the remote end.
+     *
+     * @return {Promise<T[]>} The entire result set.
+     */
+    async fetchAll() {
+        const result = [];
+        while (!__classPrivateFieldGet(this, _Paginator_done, "f")) {
+            const items = await this.fetchPage();
+            result.push(...items);
+        }
+        return result;
+    }
+}
+_Paginator_listFn = new WeakMap(), _Paginator_itemsFn = new WeakMap(), _Paginator_lastFn = new WeakMap(), _Paginator_opts = new WeakMap(), _Paginator_last = new WeakMap(), _Paginator_done = new WeakMap();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,101 @@
+import { CubeSignerClient, SignerSession } from ".";
+import { MfaReceipt } from "./mfa";
+import { AcceptedResponse, NewSessionResponse } from "./schema_types";
+/**
+ * Response type, which can be either a value of type {@link U}
+ * or {@link AcceptedResponse} (status code 202) which requires MFA.
+ */
+export type Response<U> = U | AcceptedResponse;
+/**
+ * Request function which optionally takes additional headers
+ * (which, for example, can be used to attach an MFA receipt).
+ */
+export type RequestFn<U> = (headers?: HeadersInit) => Promise<Response<U>>;
+/**
+ * Map function occasionally used to map a response from the API into a higher-level type.
+ */
+export type MapFn<U, V> = (u: U) => V;
+/**
+ * Take a {@link Response<U>} and a {@link MapFn<U, V>} function and return
+ * a {@link Response<V>} that maps the value of the original response when its status code is 200.
+ *
+ * @param {Response<U>} resp Original response
+ * @param {Map<U, V>} mapFn Map to apply to the response value when its status code is 200.
+ * @return {Response<V>} Response whose value for status code 200 is mapped from U to V
+ */
+export declare function mapResponse<U, V>(resp: Response<U>, mapFn: MapFn<U, V>): Response<V>;
+export interface MfaRequired {
+    /** Org id */
+    org_id: string;
+    /** MFA request id */
+    id: string;
+    /** Optional MFA session */
+    session?: NewSessionResponse | null;
+}
+/**
+ * A response of a CubeSigner request.
+ */
+export declare class CubeSignerResponse<U> {
+    #private;
+    /** @return {string} The MFA id associated with this request (if any) */
+    mfaId(): string;
+    /** @return {boolean} True if this request requires an MFA approval */
+    requiresMfa(): boolean;
+    /**
+     * Return session information to use for any MFA approval requests (if any was included in the response).
+     * @return {ClientSessionInfo | undefined}
+     */
+    mfaSessionInfo(): NewSessionResponse | undefined;
+    /** @return {U} The response data, if no MFA is required */
+    data(): U;
+    /**
+     * Approve the MFA request using a given session and a TOTP code.
+     *
+     * @param {SignerSession} session Signer session to use
+     * @param {string} code 6-digit TOTP code
+     * @return {CubeSignerResponse<U>} The result of signing with the approval
+     */
+    approveTotp(session: SignerSession, code: string): Promise<CubeSignerResponse<U>>;
+    /**
+     * Approve the MFA request using a given `CubeSignerClient` instance (i.e., its session).
+     *
+     * @param {CubeSignerClient} cs CubeSigner whose session to use
+     * @return {CubeSignerResponse<U>} The result of signing with the approval
+     */
+    approve(cs: CubeSignerClient): Promise<CubeSignerResponse<U>>;
+    /**
+     * Resubmits the request with a given MFA receipt attached.
+     *
+     * @param {MfaReceipt} mfaReceipt The MFA receipt
+     * @return {Promise<CubeSignerResponse<U>>} The result of signing after MFA approval
+     */
+    signWithMfaApproval(mfaReceipt: MfaReceipt): Promise<CubeSignerResponse<U>>;
+    /**
+     * Constructor.
+     *
+     * @param {RequestFn} requestFn
+     *    The signing function that this response is from.
+     *    This argument is used to resend requests with different headers if needed.
+     * @param {U | AcceptedResponse} resp The response as returned by the OpenAPI client.
+     * @internal
+     */
+    constructor(requestFn: RequestFn<U>, resp: U | AcceptedResponse);
+    /**
+     * Static constructor.
+     * @param {RequestFn} requestFn
+     *    The request function that this response is from.
+     *    This argument is used to resend requests with different headers if needed.
+     * @param {MfaReceipt} mfaReceipt Optional MFA receipt
+     * @return {Promise<CubeSignerResponse<U>>} New instance of this class.
+     * @internal
+     */
+    static create<U>(requestFn: RequestFn<U>, mfaReceipt?: MfaReceipt): Promise<CubeSignerResponse<U>>;
+    /**
+     * Return HTTP headers containing a given MFA receipt.
+     *
+     * @param {MfaReceipt} mfaReceipt MFA receipt
+     * @return {HeadersInit} Headers including that receipt
+     * @internal
+     */
+    static getMfaHeaders(mfaReceipt?: MfaReceipt): HeadersInit | undefined;
+}

package/dist/esm/src/response.js

@@ -0,0 +1,159 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _CubeSignerResponse_requestFn, _CubeSignerResponse_resp, _CubeSignerResponse_mfaRequired;
+/**
+ * Take a {@link Response<U>} and a {@link MapFn<U, V>} function and return
+ * a {@link Response<V>} that maps the value of the original response when its status code is 200.
+ *
+ * @param {Response<U>} resp Original response
+ * @param {Map<U, V>} mapFn Map to apply to the response value when its status code is 200.
+ * @return {Response<V>} Response whose value for status code 200 is mapped from U to V
+ */
+export function mapResponse(resp, mapFn) {
+    if (resp.accepted?.MfaRequired) {
+        return resp;
+    }
+    else {
+        return mapFn(resp);
+    }
+}
+/**
+ * A response of a CubeSigner request.
+ */
+export class CubeSignerResponse {
+    /** @return {string} The MFA id associated with this request (if any) */
+    mfaId() {
+        return __classPrivateFieldGet(this, _CubeSignerResponse_mfaRequired, "f").id;
+    }
+    /** @return {boolean} True if this request requires an MFA approval */
+    requiresMfa() {
+        return __classPrivateFieldGet(this, _CubeSignerResponse_mfaRequired, "f") !== undefined;
+    }
+    /**
+     * Return session information to use for any MFA approval requests (if any was included in the response).
+     * @return {ClientSessionInfo | undefined}
+     */
+    mfaSessionInfo() {
+        return __classPrivateFieldGet(this, _CubeSignerResponse_resp, "f").accepted?.MfaRequired?.session ?? undefined;
+    }
+    /** @return {U} The response data, if no MFA is required */
+    data() {
+        if (this.requiresMfa()) {
+            throw new Error("Cannot call `data()` while MFA is required");
+        }
+        return __classPrivateFieldGet(this, _CubeSignerResponse_resp, "f");
+    }
+    /**
+     * Approve the MFA request using a given session and a TOTP code.
+     *
+     * @param {SignerSession} session Signer session to use
+     * @param {string} code 6-digit TOTP code
+     * @return {CubeSignerResponse<U>} The result of signing with the approval
+     */
+    async approveTotp(session, code) {
+        if (!this.requiresMfa()) {
+            return this;
+        }
+        const mfaId = this.mfaId();
+        const mfaOrgId = __classPrivateFieldGet(this, _CubeSignerResponse_mfaRequired, "f").org_id;
+        const mfaApproval = await session.mfaApproveTotp(mfaId, code);
+        const mfaConf = mfaApproval.receipt?.confirmation;
+        if (!mfaConf) {
+            return this;
+        }
+        return await this.signWithMfaApproval({ mfaId, mfaOrgId, mfaConf });
+    }
+    /**
+     * Approve the MFA request using a given `CubeSignerClient` instance (i.e., its session).
+     *
+     * @param {CubeSignerClient} cs CubeSigner whose session to use
+     * @return {CubeSignerResponse<U>} The result of signing with the approval
+     */
+    async approve(cs) {
+        if (!this.requiresMfa()) {
+            return this;
+        }
+        const mfaId = __classPrivateFieldGet(this, _CubeSignerResponse_mfaRequired, "f").id;
+        const mfaOrgId = __classPrivateFieldGet(this, _CubeSignerResponse_mfaRequired, "f").org_id;
+        const mfaApproval = await cs.mfaApprove(mfaId);
+        const mfaConf = mfaApproval.receipt?.confirmation;
+        if (!mfaConf) {
+            return this;
+        }
+        return await this.signWithMfaApproval({ mfaId, mfaOrgId, mfaConf });
+    }
+    /**
+     * Resubmits the request with a given MFA receipt attached.
+     *
+     * @param {MfaReceipt} mfaReceipt The MFA receipt
+     * @return {Promise<CubeSignerResponse<U>>} The result of signing after MFA approval
+     */
+    async signWithMfaApproval(mfaReceipt) {
+        const headers = CubeSignerResponse.getMfaHeaders(mfaReceipt);
+        return new CubeSignerResponse(__classPrivateFieldGet(this, _CubeSignerResponse_requestFn, "f"), await __classPrivateFieldGet(this, _CubeSignerResponse_requestFn, "f").call(this, headers));
+    }
+    // --------------------------------------------------------------------------
+    // -- INTERNAL --------------------------------------------------------------
+    // --------------------------------------------------------------------------
+    /**
+     * Constructor.
+     *
+     * @param {RequestFn} requestFn
+     *    The signing function that this response is from.
+     *    This argument is used to resend requests with different headers if needed.
+     * @param {U | AcceptedResponse} resp The response as returned by the OpenAPI client.
+     * @internal
+     */
+    constructor(requestFn, resp) {
+        _CubeSignerResponse_requestFn.set(this, void 0);
+        _CubeSignerResponse_resp.set(this, void 0);
+        /**
+         * Optional MFA id. Only set if there is an MFA request associated with the
+         * signing request
+         */
+        _CubeSignerResponse_mfaRequired.set(this, void 0);
+        __classPrivateFieldSet(this, _CubeSignerResponse_requestFn, requestFn, "f");
+        __classPrivateFieldSet(this, _CubeSignerResponse_resp, resp, "f");
+        __classPrivateFieldSet(this, _CubeSignerResponse_mfaRequired, __classPrivateFieldGet(this, _CubeSignerResponse_resp, "f").accepted?.MfaRequired, "f");
+    }
+    /**
+     * Static constructor.
+     * @param {RequestFn} requestFn
+     *    The request function that this response is from.
+     *    This argument is used to resend requests with different headers if needed.
+     * @param {MfaReceipt} mfaReceipt Optional MFA receipt
+     * @return {Promise<CubeSignerResponse<U>>} New instance of this class.
+     * @internal
+     */
+    static async create(requestFn, mfaReceipt) {
+        const seed = await requestFn(this.getMfaHeaders(mfaReceipt));
+        return new CubeSignerResponse(requestFn, seed);
+    }
+    /**
+     * Return HTTP headers containing a given MFA receipt.
+     *
+     * @param {MfaReceipt} mfaReceipt MFA receipt
+     * @return {HeadersInit} Headers including that receipt
+     * @internal
+     */
+    static getMfaHeaders(mfaReceipt) {
+        return mfaReceipt
+            ? {
+                "x-cubist-mfa-id": mfaReceipt.mfaId,
+                "x-cubist-mfa-org-id": mfaReceipt.mfaOrgId,
+                "x-cubist-mfa-confirmation": mfaReceipt.mfaConf,
+            }
+            : undefined;
+    }
+}
+_CubeSignerResponse_requestFn = new WeakMap(), _CubeSignerResponse_resp = new WeakMap(), _CubeSignerResponse_mfaRequired = new WeakMap();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"response.js","sourceRoot":"","sources":["../../../src/response.ts"],"names":[],"mappings":"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","sourcesContent":["import { CubeSignerClient, SignerSession } from \".\";\nimport { MfaReceipt } from \"./mfa\";\nimport { AcceptedResponse, NewSessionResponse } from \"./schema_types\";\n\n/**\n * Response type, which can be either a value of type {@link U}\n * or {@link AcceptedResponse} (status code 202) which requires MFA.\n */\nexport type Response<U> = U | AcceptedResponse;\n\n/**\n * Request function which optionally takes additional headers\n * (which, for example, can be used to attach an MFA receipt).\n */\nexport type RequestFn<U> = (headers?: HeadersInit) => Promise<Response<U>>;\n\n/**\n * Map function occasionally used to map a response from the API into a higher-level type.\n */\nexport type MapFn<U, V> = (u: U) => V;\n\n/**\n * Take a {@link Response<U>} and a {@link MapFn<U, V>} function and return\n * a {@link Response<V>} that maps the value of the original response when its status code is 200.\n *\n * @param {Response<U>} resp Original response\n * @param {Map<U, V>} mapFn Map to apply to the response value when its status code is 200.\n * @return {Response<V>} Response whose value for status code 200 is mapped from U to V\n */\nexport function mapResponse<U, V>(resp: Response<U>, mapFn: MapFn<U, V>): Response<V> {\n  if ((resp as AcceptedResponse).accepted?.MfaRequired) {\n    return resp as AcceptedResponse;\n  } else {\n    return mapFn(resp as U);\n  }\n}\n\nexport interface MfaRequired {\n  /** Org id */\n  org_id: string;\n  /** MFA request id */\n  id: string;\n  /** Optional MFA session */\n  session?: NewSessionResponse | null;\n}\n\n/**\n * A response of a CubeSigner request.\n */\nexport class CubeSignerResponse<U> {\n  readonly #requestFn: RequestFn<U>;\n  readonly #resp: U | AcceptedResponse;\n  /**\n   * Optional MFA id. Only set if there is an MFA request associated with the\n   * signing request\n   */\n  readonly #mfaRequired?: MfaRequired;\n\n  /** @return {string} The MFA id associated with this request (if any) */\n  mfaId(): string {\n    return this.#mfaRequired!.id;\n  }\n\n  /** @return {boolean} True if this request requires an MFA approval */\n  requiresMfa(): boolean {\n    return this.#mfaRequired !== undefined;\n  }\n\n  /**\n   * Return session information to use for any MFA approval requests (if any was included in the response).\n   * @return {ClientSessionInfo | undefined}\n   */\n  mfaSessionInfo(): NewSessionResponse | undefined {\n    return (this.#resp as AcceptedResponse).accepted?.MfaRequired?.session ?? undefined;\n  }\n\n  /** @return {U} The response data, if no MFA is required */\n  data(): U {\n    if (this.requiresMfa()) {\n      throw new Error(\"Cannot call `data()` while MFA is required\");\n    }\n    return this.#resp as U;\n  }\n\n  /**\n   * Approve the MFA request using a given session and a TOTP code.\n   *\n   * @param {SignerSession} session Signer session to use\n   * @param {string} code 6-digit TOTP code\n   * @return {CubeSignerResponse<U>} The result of signing with the approval\n   */\n  async approveTotp(session: SignerSession, code: string): Promise<CubeSignerResponse<U>> {\n    if (!this.requiresMfa()) {\n      return this;\n    }\n\n    const mfaId = this.mfaId();\n    const mfaOrgId = this.#mfaRequired!.org_id;\n    const mfaApproval = await session.mfaApproveTotp(mfaId, code);\n    const mfaConf = mfaApproval.receipt?.confirmation;\n\n    if (!mfaConf) {\n      return this;\n    }\n\n    return await this.signWithMfaApproval({ mfaId, mfaOrgId, mfaConf });\n  }\n\n  /**\n   * Approve the MFA request using a given `CubeSignerClient` instance (i.e., its session).\n   *\n   * @param {CubeSignerClient} cs CubeSigner whose session to use\n   * @return {CubeSignerResponse<U>} The result of signing with the approval\n   */\n  async approve(cs: CubeSignerClient): Promise<CubeSignerResponse<U>> {\n    if (!this.requiresMfa()) {\n      return this;\n    }\n\n    const mfaId = this.#mfaRequired!.id;\n    const mfaOrgId = this.#mfaRequired!.org_id;\n\n    const mfaApproval = await cs.mfaApprove(mfaId);\n    const mfaConf = mfaApproval.receipt?.confirmation;\n\n    if (!mfaConf) {\n      return this;\n    }\n\n    return await this.signWithMfaApproval({ mfaId, mfaOrgId, mfaConf });\n  }\n\n  /**\n   * Resubmits the request with a given MFA receipt attached.\n   *\n   * @param {MfaReceipt} mfaReceipt The MFA receipt\n   * @return {Promise<CubeSignerResponse<U>>} The result of signing after MFA approval\n   */\n  async signWithMfaApproval(mfaReceipt: MfaReceipt): Promise<CubeSignerResponse<U>> {\n    const headers = CubeSignerResponse.getMfaHeaders(mfaReceipt);\n    return new CubeSignerResponse(this.#requestFn, await this.#requestFn(headers));\n  }\n\n  // --------------------------------------------------------------------------\n  // -- INTERNAL --------------------------------------------------------------\n  // --------------------------------------------------------------------------\n\n  /**\n   * Constructor.\n   *\n   * @param {RequestFn} requestFn\n   *    The signing function that this response is from.\n   *    This argument is used to resend requests with different headers if needed.\n   * @param {U | AcceptedResponse} resp The response as returned by the OpenAPI client.\n   * @internal\n   */\n  constructor(requestFn: RequestFn<U>, resp: U | AcceptedResponse) {\n    this.#requestFn = requestFn;\n    this.#resp = resp;\n    this.#mfaRequired = (this.#resp as AcceptedResponse).accepted?.MfaRequired;\n  }\n\n  /**\n   * Static constructor.\n   * @param {RequestFn} requestFn\n   *    The request function that this response is from.\n   *    This argument is used to resend requests with different headers if needed.\n   * @param {MfaReceipt} mfaReceipt Optional MFA receipt\n   * @return {Promise<CubeSignerResponse<U>>} New instance of this class.\n   * @internal\n   */\n  static async create<U>(\n    requestFn: RequestFn<U>,\n    mfaReceipt?: MfaReceipt,\n  ): Promise<CubeSignerResponse<U>> {\n    const seed = await requestFn(this.getMfaHeaders(mfaReceipt));\n    return new CubeSignerResponse(requestFn, seed);\n  }\n\n  /**\n   * Return HTTP headers containing a given MFA receipt.\n   *\n   * @param {MfaReceipt} mfaReceipt MFA receipt\n   * @return {HeadersInit} Headers including that receipt\n   * @internal\n   */\n  static getMfaHeaders(mfaReceipt?: MfaReceipt): HeadersInit | undefined {\n    return mfaReceipt\n      ? {\n          \"x-cubist-mfa-id\": mfaReceipt.mfaId,\n          \"x-cubist-mfa-org-id\": mfaReceipt.mfaOrgId,\n          \"x-cubist-mfa-confirmation\": mfaReceipt.mfaConf,\n        }\n      : undefined;\n  }\n}\n"]}