@shardflux/sdk 0.7.0 → 0.9.0

package/dist/account.d.ts

@@ -0,0 +1,469 @@
+/**
+ * The account plane with a user session (0.9.0; contracts §30): what a person does in the web app, from code.
+ *
+ *   // Before a session exists (no token needed)
+ *   await ShardfluxAccount.register({ email, password, displayName });
+ *   await ShardfluxAccount.verifyEmail(linkFromTheEmail);
+ *   const { account, result } = await ShardfluxAccount.login({ email, password, onSessionToken: (s) => save(s.token) });
+ *   if (result.status === 'mfa_required') await account.auth.completeMfa({ code });
+ *
+ *   // Later, with the saved token
+ *   const account = new ShardfluxAccount({ sessionToken: 'sfu_...', onSessionToken: (s) => save(s.token) });
+ *   const org = await account.organizations.create({ name: 'Acme' });
+ *
+ * A CLI session token (`sfu_<43 base64url chars>`) is sent as `Authorization: Bearer` on /v1. The API rotates it on
+ * login completion, step-up, password change and TOTP confirm/disable (the previous token is revoked):
+ * `account.sessionToken` always holds the current one, and `onSessionToken` is called with each new token. Methods
+ * that need a recent password check answer 403 `step_up_required` (call `auth.stepUp()` and retry); a session still
+ * waiting for its second factor gets 403 `mfa_required`, an unverified email 403 `email_unverified`.
+ */
+import type { operations } from './generated/app-api.js';
+import { BillingApi, WorkspacesApi } from './client.js';
+import type { ClientContext, Me, WorkspaceView } from './client.js';
+import type { RequestOptions } from './http.js';
+import { AuditApi } from './audit.js';
+import type { AuditFilters } from './audit.js';
+import { EgressPolicyApi } from './egress.js';
+import type { AccountFeedbackParams, FeedbackReceipt } from './feedback.js';
+import { SecretsApi } from './secrets.js';
+import { TemplatesApi } from './templates.js';
+import type { TemplateDetail } from './templates.js';
+import { UsageApi } from './usage.js';
+import type { SpendPolicy } from './usage.js';
+import { VolumesApi } from './volumes.js';
+import type { VersionCheckOption } from './version-check.js';
+import type { ProgressListener } from './progress.js';
+type JsonOf<R> = R extends {
+    content: {
+        'application/json': infer T;
+    };
+} ? T : never;
+type Ok<Op> = Op extends {
+    responses: infer R;
+} ? {
+    [K in keyof R]: K extends 200 | 201 | 202 ? JsonOf<R[K]> : never;
+}[keyof R] : never;
+export type RegisterResult = Ok<operations['postV1AuthRegister']>;
+export type VerifyEmailResult = Ok<operations['postV1AuthVerifyEmail']>;
+export type PasswordResetRequestResult = Ok<operations['postV1AuthPasswordResetRequest']>;
+export type PasswordResetConfirmResult = Ok<operations['postV1AuthPasswordResetConfirm']>;
+export type EmailChangeResult = Ok<operations['postV1AuthEmailChange']>;
+export type EmailChangeConfirmResult = Ok<operations['postV1AuthEmailChangeConfirm']>;
+export type ResendVerificationResult = Ok<operations['postV1AuthVerifyEmailResend']>;
+/** Login (and MFA challenge) answer: `status` `authenticated` or `mfa_required`, with the new `session_token`. */
+export type LoginResult = Ok<operations['postV1AuthLogin']>;
+export type MfaChallengeResult = Ok<operations['postV1AuthMfaChallenge']>;
+export type AuthUser = NonNullable<LoginResult['user']>;
+/** GET /v1/auth/session: `state` anonymous | mfa_required | authenticated, the user and the session. */
+export type AuthSessionState = Ok<operations['getV1AuthSession']>;
+export type AuthSessionPage = Ok<operations['getV1AuthSessions']>;
+/** One of the user's sessions (`client`: browser or cli; `current`: the one making the request). */
+export type AuthSessionInfo = AuthSessionPage['data'][number];
+export type StepUpResult = Ok<operations['postV1AuthStepUp']>;
+export type PasswordChangeResult = Ok<operations['postV1AuthPasswordChange']>;
+export type TotpEnrollment = Ok<operations['postV1AuthMfaTotpEnroll']>;
+export type TotpConfirmResult = Ok<operations['postV1AuthMfaTotpConfirm']>;
+export type TotpDisableResult = Ok<operations['postV1AuthMfaTotpDisable']>;
+export type RecoveryCodes = Ok<operations['postV1AuthMfaRecoveryCodes']>;
+export type Organization = Ok<operations['getV1OrganizationsOrganizationId']>;
+export type OrganizationPage = Ok<operations['getV1Organizations']>;
+export type OrganizationRole = Organization['role'];
+export type OrganizationDeletion = Ok<operations['getV1OrganizationsOrganizationIdDeletion']>;
+export type OrganizationDeletionResult = Ok<operations['postV1OrganizationsOrganizationIdDeletion']>;
+/** An account or organization data export (JSON; `state` ready | expired). */
+export type DataExport = Ok<operations['getV1AccountExportsExportId']>;
+export type OrganizationWorkspacePage = Ok<operations['getV1OrganizationsOrganizationIdWorkspaces']>;
+export type Project = Ok<operations['getV1ProjectsProjectId']>;
+export type ProjectPage = Ok<operations['getV1OrganizationsOrganizationIdProjects']>;
+export type ApiKeyPage = Ok<operations['getV1ProjectsProjectIdApiKeys']>;
+export type ApiKey = ApiKeyPage['data'][number];
+/** The created key (`api_key`) and its `secret` (the `sfk_...` key, shown once). */
+export type CreatedApiKey = Ok<operations['postV1ProjectsProjectIdApiKeys']>;
+export type ApiKeyToolPermission = ApiKey['tool_permissions'][number];
+export type MemberPage = Ok<operations['getV1OrganizationsOrganizationIdMembers']>;
+export type Member = MemberPage['data'][number];
+export type MemberRole = Member['role'];
+export type InvitationPage = Ok<operations['getV1OrganizationsOrganizationIdInvitations']>;
+export type Invitation = InvitationPage['data'][number];
+/** A Checkout intent: `url` is where a person pays; `subscription_active` turns true once the webhook activated it. */
+export type CheckoutStatus = Ok<operations['getV1OrganizationsOrganizationIdBillingCheckoutSessionsCheckoutId']>;
+export type BillingPortalSession = Ok<operations['postV1OrganizationsOrganizationIdBillingPortalSessions']>;
+export type BillingInvoicePage = Ok<operations['getV1OrganizationsOrganizationIdBillingInvoices']>;
+export type AccountDeletion = Ok<operations['getV1AccountDeletion']>;
+export type AccountDeletionScheduled = Ok<operations['postV1AccountDeletion']>;
+export type AccountDeletionCanceled = Ok<operations['deleteV1AccountDeletion']>;
+/** A new session token and when it expires (idle expiry, sliding). */
+export interface SessionTokenUpdate {
+    token: string;
+    expiresAt: string;
+}
+export interface ShardfluxAccountOptions {
+    /** A CLI session token, `sfu_<token>`. Omitted: only the pre-session calls work until `login` gives one. */
+    sessionToken?: string;
+    /** Default https://api.shardflux.dev. */
+    baseUrl?: string;
+    /** Default: the runtime's fetch, with `Connection: close` on Node 26 (see defaultFetch in http.ts). */
+    fetch?: typeof fetch;
+    userAgent?: string;
+    /** Per-request timeout (ms), default 30 s. */
+    timeoutMs?: number;
+    /** Retries of safe/idempotent requests on transient failures, default 2. */
+    maxRetries?: number;
+    /** Injected for tests; defaults to setTimeout. */
+    sleep?: (ms: number) => Promise<void>;
+    /**
+     * Called with every new token (login, completeMfa, stepUp, changePassword, totp.confirm, totp.disable), after
+     * `sessionToken` changed; the previous token no longer works. A returned promise is awaited, and an error from the
+     * callback rejects the call that rotated the token (the rotation itself already happened).
+     */
+    onSessionToken?: (session: SessionTokenUpdate) => void | Promise<void>;
+    /** The automatic version check (see ShardfluxOptions.versionCheck). */
+    versionCheck?: VersionCheckOption;
+    /** Progress of traced calls (volume and workspace operation waits). */
+    onProgress?: ProgressListener;
+}
+/** Client options of the static pre-session calls. */
+export type AccountClientOptions = Omit<ShardfluxAccountOptions, 'sessionToken'>;
+export interface PageParams {
+    limit?: number;
+    cursor?: string;
+}
+/** The shape of a CLI session token. */
+export declare const SESSION_TOKEN_PATTERN: RegExp;
+/** True when `value` has the shape of a CLI session token (`sfu_` + 43 base64url characters). */
+export declare function isSessionToken(value: unknown): value is string;
+/**
+ * The token of an emailed link (`<app>/auth/verify-email#token=...`, `/auth/reset-password#token=...`,
+ * `/auth/confirm-email-change#token=...`, `/invitations/accept#token=...`): the `token` of its `#` fragment, else of
+ * its `?` query, percent-decoded. Input that is not a link is the token itself (trimmed). Throws for an empty input
+ * and for a link without a token.
+ */
+export declare function parseEmailToken(input: string): string;
+/** Internal wiring shared with the namespaces of one ShardfluxAccount. */
+export interface AccountCore {
+    ctx: () => ClientContext;
+    /** Adopts the `session_token` of a response (rotation), then calls onSessionToken. */
+    adopt<T>(body: T): Promise<T>;
+}
+export declare class AccountTotpApi {
+    #private;
+    constructor(core: AccountCore);
+    /** Starts TOTP enrollment: the `secret` and `otpauth_uri` for an authenticator app (confirm with a code). */
+    enroll(): Promise<TotpEnrollment>;
+    /** Confirms enrollment with a current code: returns the recovery codes (shown once). Rotates the session token. */
+    confirm(code: string): Promise<TotpConfirmResult>;
+    /** Turns TOTP off (needs a recent step-up). Rotates the session token. */
+    disable(): Promise<TotpDisableResult>;
+    /** New recovery codes (the old ones stop working; needs a recent step-up). */
+    regenerateRecoveryCodes(): Promise<RecoveryCodes>;
+}
+export declare class AccountAuthApi {
+    #private;
+    /** Authenticator-app second factor. */
+    readonly totp: AccountTotpApi;
+    constructor(core: AccountCore);
+    /** The session's state (`anonymous`, `mfa_required`, `authenticated`), its user and expiry. */
+    session(): Promise<AuthSessionState>;
+    /** Completes a login that answered `mfa_required`, with a TOTP code or a recovery code. Rotates the session token. */
+    completeMfa(params: {
+        code: string;
+    } | {
+        recoveryCode: string;
+    }): Promise<MfaChallengeResult>;
+    /** Ends this session (the token stops working; `sessionToken` keeps the revoked value). */
+    logout(): Promise<void>;
+    /** Ends every session of the user, this one included. */
+    logoutAll(): Promise<void>;
+    /** The user's sessions (browser and CLI; `current` marks this one). */
+    sessions(): Promise<AuthSessionPage>;
+    revokeSession(sessionId: string): Promise<void>;
+    /**
+     * Confirms the password (and a code when MFA is on) for the calls that need a recent check (403
+     * `step_up_required`). Rotates the session token.
+     */
+    stepUp(params: {
+        password: string;
+        code?: string;
+        recoveryCode?: string;
+    }): Promise<StepUpResult>;
+    /** Changes the password; every other session is revoked. Rotates the session token. */
+    changePassword(params: {
+        currentPassword: string;
+        newPassword: string;
+    }): Promise<PasswordChangeResult>;
+    /** Sends a confirmation link to the new address (confirm with ShardfluxAccount.confirmEmailChange). */
+    changeEmail(newEmail: string): Promise<EmailChangeResult>;
+    /** Sends the verification email again. */
+    resendVerification(): Promise<ResendVerificationResult>;
+}
+export declare class OrganizationExportsApi {
+    #private;
+    constructor(core: AccountCore);
+    /** Builds a JSON export of the organization (owners/admins; needs a recent step-up). */
+    create(organizationId: string): Promise<DataExport>;
+    get(organizationId: string, exportId: string): Promise<DataExport>;
+    /** The export document (JSON text). */
+    download(organizationId: string, exportId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
+}
+export interface OrganizationWorkspacesParams extends PageParams {
+    projectId?: string;
+    state?: WorkspaceView['observed_state'];
+    desiredState?: WorkspaceView['desired_state'];
+    keyPrefix?: string;
+    includeDeleted?: boolean;
+    lifetime?: 'persistent' | 'session' | 'any';
+    purpose?: 'standard' | 'template_draft' | 'template_test' | 'any';
+}
+export declare class AccountOrganizationsApi {
+    #private;
+    /** Data exports of an organization. */
+    readonly exports: OrganizationExportsApi;
+    constructor(core: AccountCore);
+    /** One page of the user's organizations (with the user's `role`). */
+    list(params?: PageParams): Promise<OrganizationPage>;
+    /** Every organization of the user, following next_cursor. */
+    listAll(params?: {
+        limit?: number;
+    }): AsyncGenerator<Organization>;
+    /** Creates an organization; the user becomes its owner. */
+    create(params: {
+        name: string;
+        slug?: string;
+    }): Promise<Organization>;
+    get(organizationId: string): Promise<Organization>;
+    /** The organization's plan, allowances and limits. */
+    entitlements(organizationId: string): Promise<Ok<operations['getV1OrganizationsOrganizationIdEntitlements']>>;
+    /** The deletion state: a scheduled request, what blocks it (an active subscription) and what would be removed. */
+    deletion(organizationId: string): Promise<OrganizationDeletion>;
+    /** Deletes the organization (owners; needs a recent step-up). `confirmation` is the organization's slug. */
+    delete(organizationId: string, params: {
+        confirmation: string;
+    }): Promise<OrganizationDeletionResult>;
+    /** One page of the organization's workspaces (views, across its projects unless `projectId`). */
+    workspaces(organizationId: string, params?: OrganizationWorkspacesParams): Promise<OrganizationWorkspacePage>;
+}
+export declare class AccountProjectsApi {
+    #private;
+    constructor(core: AccountCore);
+    list(organizationId: string, params?: PageParams): Promise<ProjectPage>;
+    /** Every project of the organization, following next_cursor. */
+    listAll(organizationId: string, params?: {
+        limit?: number;
+    }): AsyncGenerator<Project>;
+    create(organizationId: string, params: {
+        name: string;
+        slug?: string;
+    }): Promise<Project>;
+    get(projectId: string): Promise<Project>;
+}
+/** Every tool permission an API key can carry (pass it as `toolPermissions` for a key with every tool). */
+export declare const API_KEY_TOOL_PERMISSIONS: readonly ApiKeyToolPermission[];
+export interface CreateApiKeyParams {
+    name: string;
+    /**
+     * The workspace tools the key may use (a subset of API_KEY_TOOL_PERMISSIONS). Default [] (no tools: read-only API
+     * use). Billing members may only create keys without tools.
+     */
+    toolPermissions?: readonly ApiKeyToolPermission[];
+    /** Between 1 minute and 366 days from now; omitted: the key does not expire. */
+    expiresAt?: string | Date;
+    /** Default: a fresh key per call, so a transport retry replays the creation (and returns the same secret) instead of creating a second key. */
+    idempotencyKey?: string;
+}
+export declare class AccountApiKeysApi {
+    #private;
+    constructor(core: AccountCore);
+    list(projectId: string, params?: PageParams): Promise<ApiKeyPage>;
+    /** Creates a project API key: `secret` is the `sfk_...` key, shown once (an Idempotency-Key replay within 24 h returns it again). */
+    create(projectId: string, params: CreateApiKeyParams): Promise<CreatedApiKey>;
+    revoke(projectId: string, apiKeyId: string): Promise<void>;
+}
+export declare class AccountMembersApi {
+    #private;
+    constructor(core: AccountCore);
+    list(organizationId: string, params?: PageParams): Promise<MemberPage>;
+    update(organizationId: string, userId: string, params: {
+        role: MemberRole;
+    }): Promise<Member>;
+    remove(organizationId: string, userId: string): Promise<void>;
+}
+export declare class AccountInvitationsApi {
+    #private;
+    constructor(core: AccountCore);
+    list(organizationId: string, params?: PageParams): Promise<InvitationPage>;
+    /** Invites an email address (the invitee gets a link; accept with invitations.accept). */
+    create(organizationId: string, params: {
+        email: string;
+        role: MemberRole;
+    }): Promise<Invitation>;
+    revoke(organizationId: string, invitationId: string): Promise<void>;
+    /** Accepts an invitation with the emailed link (or its token): returns the organization joined. */
+    accept(linkOrToken: string): Promise<Organization>;
+}
+export interface WaitForCheckoutOptions {
+    /** Give up after this long (default 900 000 ms = 15 min): CheckoutTimeoutError. The checkout stays open. */
+    timeoutMs?: number;
+    /** Delay between polls (default 2000 ms). */
+    intervalMs?: number;
+    signal?: AbortSignal;
+}
+/**
+ * waitForCheckout gave up (0.9.0): nobody paid within `timeoutMs`, or the payment's webhook has not activated the
+ * subscription yet. The checkout stays usable; `checkout` is its last status.
+ */
+export declare class CheckoutTimeoutError extends Error {
+    readonly checkout: CheckoutStatus;
+    readonly waitedMs: number;
+    constructor(checkout: CheckoutStatus, waitedMs: number);
+}
+/**
+ * Billing with a user session: the catalog and subscription (as for API keys) plus Checkout, the Stripe portal,
+ * invoices and usage alert thresholds (owner/billing members).
+ */
+export declare class AccountBillingApi extends BillingApi {
+    #private;
+    constructor(core: AccountCore);
+    /**
+     * Starts (or reuses) a Stripe Checkout for `planKey`: a person pays at `url`. 409 `subscription_exists` when the
+     * organization already has a subscription (change plans in the portal).
+     */
+    checkout(organizationId: string, params: {
+        planKey: string;
+    }): Promise<CheckoutStatus>;
+    checkoutStatus(organizationId: string, checkoutId: string): Promise<CheckoutStatus>;
+    /**
+     * Polls the checkout until the subscription is active (`subscription_active`) or the checkout ended without one
+     * (`expired`, `canceled`, `failed`) and returns that final status. Throws CheckoutTimeoutError after `timeoutMs`,
+     * and the signal's reason when aborted.
+     */
+    waitForCheckout(organizationId: string, checkoutId: string, opts?: WaitForCheckoutOptions): Promise<CheckoutStatus>;
+    /** A Stripe customer portal link (plan changes, payment methods, cancellation). */
+    portal(organizationId: string): Promise<BillingPortalSession>;
+    invoices(organizationId: string, params?: PageParams): Promise<BillingInvoicePage>;
+    /** Usage alert thresholds. */
+    spendPolicy(organizationId: string): Promise<SpendPolicy>;
+    /** Sets the usage alert thresholds (percent of the allowance, 1..100, at most 5; [] turns alerts off). */
+    setSpendPolicy(organizationId: string, params: {
+        alertThresholdsPercent: number[];
+    }): Promise<SpendPolicy>;
+}
+export declare class AccountExportsApi {
+    #private;
+    constructor(core: AccountCore);
+    /** Builds a JSON export of the user's own data (needs a recent step-up). */
+    create(): Promise<DataExport>;
+    get(exportId: string): Promise<DataExport>;
+    /** The export document (JSON text; needs a recent step-up). */
+    download(exportId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<string>;
+}
+/** The signed-in person: account deletion and data export. */
+export declare class AccountUserApi {
+    #private;
+    readonly exports: AccountExportsApi;
+    constructor(core: AccountCore);
+    /** The deletion state: a scheduled request, the organizations that block it, the API keys that survive it. */
+    deletion(): Promise<AccountDeletion>;
+    /** Schedules deletion of the account after the grace period (needs a recent step-up). `confirmation` is the user's email. */
+    scheduleDeletion(params: {
+        confirmation: string;
+    }): Promise<AccountDeletionScheduled>;
+    cancelDeletion(): Promise<AccountDeletionCanceled>;
+}
+/** Organization templates with a user session: everything of TemplatesApi (pass `organizationId`) plus publish/archive. */
+export declare class AccountTemplatesApi extends TemplatesApi {
+    #private;
+    constructor(core: AccountCore);
+    /** Publishes a registered version (owners/admins): `open` may use it. */
+    publishVersion(organizationId: string, slug: string, version: number): Promise<TemplateDetail>;
+    /** Archives a version (owners/admins): new opens stop using it; existing workspaces keep it. */
+    archiveVersion(organizationId: string, slug: string, version: number): Promise<TemplateDetail>;
+}
+export interface AuditExportParams extends AuditFilters {
+    /** Default `ndjson` (parse with parseAuditNdjson). */
+    format?: 'csv' | 'ndjson';
+    signal?: AbortSignal;
+    /** Request timeout (ms), default 120 s (an export is at most 50 000 rows over at most 90 days). */
+    timeoutMs?: number;
+}
+/** The organization audit log (owners/admins) plus its CSV/NDJSON export. */
+export declare class AccountAuditApi extends AuditApi {
+    #private;
+    constructor(core: AccountCore);
+    /** The export as text: NDJSON (one AuditEvent per line) or CSV with a header row. */
+    export(organizationId: string, params?: AuditExportParams): Promise<string>;
+}
+type PreSession<P> = P & AccountClientOptions;
+/**
+ * A user (CLI) session on the Shardflux API: accounts, organizations, projects, API keys, members, invitations,
+ * billing, audit, data export and deletion, plus the project namespaces (usage, secrets, egress, volumes) with explicit
+ * organization/project ids. See the module comment for the token lifecycle.
+ */
+export declare class ShardfluxAccount {
+    #private;
+    readonly auth: AccountAuthApi;
+    readonly organizations: AccountOrganizationsApi;
+    readonly projects: AccountProjectsApi;
+    readonly apiKeys: AccountApiKeysApi;
+    readonly members: AccountMembersApi;
+    readonly invitations: AccountInvitationsApi;
+    readonly billing: AccountBillingApi;
+    /** The signed-in person (account deletion, data export). */
+    readonly user: AccountUserApi;
+    readonly templates: AccountTemplatesApi;
+    readonly audit: AccountAuditApi;
+    readonly usage: UsageApi;
+    readonly secrets: SecretsApi;
+    readonly egress: EgressPolicyApi;
+    readonly volumes: VolumesApi;
+    /** Workspace routes with the session (pass `projectId` where a route needs a project, e.g. open). */
+    readonly workspaces: WorkspacesApi;
+    constructor(opts?: ShardfluxAccountOptions);
+    /** The current session token (rotations replace it), or null before login. */
+    get sessionToken(): string | null;
+    /** The signed-in user and their memberships. */
+    me(): Promise<Me>;
+    /**
+     * Send feedback straight to the Shardflux founder as the signed-in user (0.9.0+; POST /v1/feedback), optionally about
+     * one of your organizations (`organizationId`). Otherwise the same as `Shardflux.sendFeedback`: use it while you work,
+     * returns `{ id, receivedAt, duplicate }`, never retried, 429 `rate_limited` per user.
+     */
+    sendFeedback(params: AccountFeedbackParams): Promise<FeedbackReceipt>;
+    /** Raw access to any /v1 endpoint with the session's authentication and the SDK's error handling. */
+    request<T>(method: string, path: string, init?: RequestOptions): Promise<T>;
+    /** Creates an account; a verification link is emailed (`{ status: 'accepted' }` also when the email is taken). */
+    static register(params: PreSession<{
+        email: string;
+        password: string;
+        displayName?: string;
+    }>): Promise<RegisterResult>;
+    /**
+     * Verifies the email with the emailed link (or its token). `password_reset_required` (with `reset_token`): the
+     * account must set a password first (confirmPasswordReset with that token).
+     */
+    static verifyEmail(linkOrToken: string, opts?: AccountClientOptions): Promise<VerifyEmailResult>;
+    /** Emails a password reset link (`{ status: 'accepted' }` whether or not the account exists). */
+    static requestPasswordReset(email: string, opts?: AccountClientOptions): Promise<PasswordResetRequestResult>;
+    /** Sets a new password with the emailed reset link (or its token); every session is revoked. */
+    static confirmPasswordReset(params: {
+        token: string;
+        newPassword: string;
+    }, opts?: AccountClientOptions): Promise<PasswordResetConfirmResult>;
+    /** Confirms an email change with the link sent to the new address (or its token). */
+    static confirmEmailChange(linkOrToken: string, opts?: AccountClientOptions): Promise<EmailChangeConfirmResult>;
+    /**
+     * Signs in: `account` holds the new session (onSessionToken is called with it). `result.status` `mfa_required`: the
+     * session is pending until `account.auth.completeMfa({ code })` (which rotates the token).
+     */
+    static login(params: PreSession<{
+        email: string;
+        password: string;
+    }>): Promise<{
+        account: ShardfluxAccount;
+        result: LoginResult;
+    }>;
+}
+export {};