@ledewire/browser 0.9.0 → 0.10.0

package/README.md

@@ -158,6 +158,7 @@ await lw.auth.signup({ email, password, name, company_invitation_token: token })
 // Company admins: members, spend caps, Machine users, top-ups, reports
 const { data: members } = await lw.company.members.list()
 await lw.company.members.update(members[0].id, { daily_spend_limit_cents: 5000 })
+const { balance_cents, held_cents } = await lw.company.wallet.get() // the Company balance
 const { data: pending } = await lw.company.wallet.listPendingTopUps()
 ```
 

package/dist/index.d.ts

@@ -115,9 +115,16 @@ declare class BrowserAuthNamespace {
      * Tokens are stored automatically after successful signup.
      *
      * Pass `company_invitation_token` (from a Company invitation email) to sign
-     * up and join the Company in one step. If the token does not name a pending
-     * invitation addressed to this email, the account is still created, without
-     * a membership.
+     * up and join the Company in one step, or `invitation_token` (from a store
+     * invitation email) to join the store. If an invitation can't be accepted,
+     * nothing is created and the signup is refused; with both tokens it joins
+     * both or neither.
+     *
+     * @throws {LedewireError} With `statusCode === 422` and
+     *   `type === 'invitation_not_accepted'` when an invitation token can't be
+     *   accepted. `details.reason` says why (an `InvitationRefusalReason`) and
+     *   `details.invitation` says which (`'store'` or `'company'`). A `409` still
+     *   means only that the email is taken.
      *
      * @param body - Signup credentials and display name.
      * @returns The authentication token response.
@@ -135,6 +142,14 @@ declare class BrowserAuthNamespace {
      * Log in with a Google ID token obtained from the Google OAuth flow.
      * Tokens are stored automatically after successful login.
      *
+     * Pass `invitation_token` (store) or `company_invitation_token` (Company)
+     * from an invitation email to accept it as you sign in. When this call
+     * creates the account, an invitation that can't be accepted refuses the
+     * whole call with a `422` (`type === 'invitation_not_accepted'`, as for
+     * {@link signup}) and nothing is created. For an account that already
+     * exists, the sign-in succeeds either way and the response's `invitations`
+     * reports what happened to each token sent.
+     *
      * @param body - The Google ID token.
      * @returns The authentication token response.
      */
@@ -698,10 +713,12 @@ export declare type CompanyInvitationRequest = Omit<components['schemas']['Compa
  * Nobody joins until they accept, because joining moves their spending onto
  * the Company wallet. Every invitation emails a token that accepting requires,
  * even for a buyer already signed in as the invited address. An existing buyer
- * passes it to {@link accept}; a new address passes it to `auth.signup()` as
- * `company_invitation_token`, which signs up and joins in one step.
+ * passes it to {@link accept}; a new address passes it to `auth.signup()` or
+ * `auth.loginWithGoogle()` as `company_invitation_token`, which creates the
+ * account and joins in one step.
  *
- * `list()` and `create()` are Company-admin only; `accept()` is for the invitee.
+ * `list()`, `create()` and `revoke()` are Company-admin only; `accept()` is for
+ * the invitee.
  *
  * Obtain via `client.company.invitations` — do not construct directly.
  *
@@ -737,18 +754,35 @@ declare class CompanyInvitationsNamespace {
      *   already a member or already has a pending invitation.
      */
     create(body: CompanyInvitationRequest): Promise<CompanyInvitation>;
+    /**
+     * Revokes a pending invitation. Company admins only. The emailed token can no
+     * longer be accepted, and the address can be invited again at once rather
+     * than when this invitation would have expired.
+     *
+     * @param id - The invitation id (`CompanyInvitation.id`).
+     * @throws {ForbiddenError} When the caller is not a Company admin.
+     * @throws {NotFoundError} When the caller belongs to no Company, or the
+     *   invitation is not one of its own.
+     * @throws {LedewireError} With `statusCode === 409` when the invitation is no
+     *   longer pending (accepted, already revoked, or expired).
+     */
+    revoke(id: string): Promise<void>;
     /**
      * Accepts an invitation, opening a membership with the invited role. The
      * token must belong to an invitation addressed to one of the buyer's
      * addresses.
      *
+     * Every refusal carries `type === 'invitation_not_accepted'` and the reason
+     * as `details.reason` (an `InvitationRefusalReason`).
+     *
      * @param body - The token from the invitation email.
      * @returns The new membership.
      * @throws {NotFoundError} When no invitation with this token is addressed to
-     *   this buyer.
-     * @throws {LedewireError} With `statusCode === 409` when already accepted, or
-     *   when the buyer already belongs to a Company (leave it first); with
-     *   `statusCode === 410` when the invitation has expired or was withdrawn.
+     *   this buyer (`details.reason === 'not_found'`).
+     * @throws {LedewireError} With `statusCode === 409` when already accepted
+     *   (`'already_accepted'`), or when the buyer already belongs to a Company
+     *   (`'already_in_company'`; leave it first); with `statusCode === 410` when
+     *   the invitation has expired or was withdrawn (`'expired'`).
      */
     accept(body: CompanyInvitationAcceptRequest): Promise<CompanyMembership>;
 }
@@ -946,6 +980,22 @@ declare class CompanyMachineUsersNamespace {
      *   blank or too long.
      */
     create(body: CompanyMachineUserCreateRequest): Promise<CompanyMachineUser>;
+    /**
+     * Renames a Machine user or changes its description, under the same name
+     * rules as {@link create}. Its keys and sessions are untouched, so the agent
+     * keeps working without being re-issued anything. Company reports read the
+     * name live, so `company.members`, `company.purchases` and `company.spend`
+     * show the new name on earlier rows as well as later ones.
+     *
+     * @param id - The Machine user id (`CompanyMachineUser.id`).
+     * @param body - A new `name`, a new `description` (`null` clears it), or both.
+     * @returns The updated Machine user.
+     * @throws {NotFoundError} When the Machine user is not in the caller's Company.
+     * @throws {LedewireError} With `statusCode === 409` when another active
+     *   Machine user has this name, or this one is deactivated; with
+     *   `statusCode === 422` when the name is blank or too long.
+     */
+    update(id: string, body: CompanyMachineUserUpdateRequest): Promise<CompanyMachineUser>;
     /**
      * Deactivates a Machine user, **permanently**. In one step this closes its
      * membership, revokes every key it holds, and ends its sessions. It cannot be
@@ -959,6 +1009,22 @@ declare class CompanyMachineUsersNamespace {
     deactivate(id: string): Promise<CompanyMachineUser>;
 }
 
+/**
+ * Request body for renaming a Machine user or changing its description. Give
+ * at least one of the two. A `null` or blank `description` clears it; `name`
+ * cannot be `null`, and is at most 100 characters.
+ *
+ * Hand-written: the spec expresses "at least one" as an `anyOf`, which the
+ * generator widens to `unknown`.
+ */
+export declare type CompanyMachineUserUpdateRequest = {
+    name: string;
+    description?: string | null;
+} | {
+    name?: string;
+    description: string | null;
+};
+
 /**
  * An open Company membership as a Company admin sees it. `id` is the membership
  * id the `company.members` methods take — not the member's `user_id`.
@@ -1106,7 +1172,7 @@ declare class CompanyNamespace {
     readonly members: CompanyMembersNamespace;
     /** Machine users and their Buyer keys and MCP API keys (admin). */
     readonly machineUsers: CompanyMachineUsersNamespace;
-    /** Fund the Company wallet and list unsettled top-ups (admin). */
+    /** Read and fund the Company wallet, and list unsettled top-ups (admin). */
     readonly wallet: CompanyWalletNamespace;
     /** Everything the Company paid for, attributed to its members (admin). */
     readonly purchases: CompanyPurchasesNamespace;
@@ -1239,16 +1305,27 @@ declare class CompanySpendNamespace {
 export declare type CompanySpendParams = CompanyReportFilters;
 
 /**
- * Fund the Company wallet and track top-ups that have not settled. Company
- * admins only.
+ * The Company wallet as a Company admin sees it: the spendable balance, what
+ * in-flight Bulk acquisitions hold, and what top-ups are on their way. The only
+ * response that carries the Company balance.
+ */
+export declare type CompanyWallet = components['schemas']['CompanyWallet'];
+
+/**
+ * Read the Company wallet, fund it, and track top-ups that have not settled.
+ * Company admins only.
  *
  * Members never see the Company balance and cannot fund the Company wallet; a
- * member who runs short is refused at purchase and must ask an admin.
+ * member who runs short is refused at purchase and must ask an admin. Even for
+ * an admin, `wallet.balance()` reports no Company balance: {@link get} is the
+ * only place it appears.
  *
  * Obtain via `client.company.wallet` — do not construct directly.
  *
  * @example
  * ```ts
+ * const { balance_cents, held_cents, pending_top_up_cents } = await client.company.wallet.get()
+ *
  * const session = await client.company.wallet.createPaymentSession({ amount_cents: 50000 })
  * // Confirm with session.client_secret in the payment widget, as for a personal top-up.
  *
@@ -1258,6 +1335,18 @@ export declare type CompanySpendParams = CompanyReportFilters;
 declare class CompanyWalletNamespace {
     private readonly http;
     /* Excluded from this release type: __constructor */
+    /**
+     * Reads the Company wallet: the spendable `balance_cents` (money held by
+     * in-flight Bulk acquisitions is already out of it, and it goes negative when
+     * a reversed top-up takes the wallet below zero), `held_cents` committed to
+     * Company-paid Bulk acquisitions still in progress, and
+     * `pending_top_up_cents`, the total of {@link listPendingTopUps}.
+     *
+     * @returns The Company wallet.
+     * @throws {ForbiddenError} When the caller is not a Company admin.
+     * @throws {NotFoundError} When the caller belongs to no Company.
+     */
+    get(): Promise<CompanyWallet>;
     /**
      * Starts a Company wallet top-up, by card or ACH (`us_bank_account`). Confirm
      * it client-side with the returned `client_secret`, as for a personal top-up.
@@ -1323,6 +1412,34 @@ declare interface components {
              * @description When the access token expires, about 30 minutes after it was issued. Equal to the token's `exp` claim. Refresh before then.
              */
             expires_at: string;
+            /** @description Present only on `POST /v1/auth/login/google` for an account that already existed, when the call carried `invitation_token` or `company_invitation_token`. One entry per token sent. A refused invitation does not refuse the sign-in; it is reported here instead. */
+            invitations?: {
+                store?: components['schemas']['InvitationOutcome'];
+                company?: components['schemas']['InvitationOutcome'];
+            };
+        };
+        InvitationOutcome: {
+            accepted: boolean;
+            reason?: components['schemas']['InvitationRefusalReason'];
+            /** @description The refusal in words, for display. Present when `accepted` is false. */
+            message?: string;
+        };
+        /**
+         * @description Why an invitation was not accepted. `not_found` also covers a Company invitation addressed to another email, deliberately indistinguishable; `expired` covers a withdrawn one; `wrong_email` is a store invitation sent to another address; `already_in_company` means the account belongs to another Company and must leave it first; `already_member` means it already belongs to the store; `invalid` is an invitation that could not be saved.
+         * @enum {string}
+         */
+        InvitationRefusalReason: 'not_found' | 'already_accepted' | 'expired' | 'wrong_email' | 'already_in_company' | 'already_member' | 'invalid';
+        /** @description An invitation refused. Signup and Google sign-in return it with HTTP 422 and name the `invitation`; `POST /v1/company/invitations/accept` returns it with its own status (404, 409 or 410) and no `invitation`. */
+        InvitationNotAcceptedError: {
+            error: {
+                code: number;
+                message: string;
+                /** @enum {string} */
+                type: 'invitation_not_accepted';
+            };
+            reason: components['schemas']['InvitationRefusalReason'];
+            /** @enum {string} */
+            invitation?: 'store' | 'company';
         };
         /** @description Token response for merchant authentication. Includes stores the user has access to so the client can prompt for store selection. */
         MerchantAuthenticationResponse: {
@@ -1390,16 +1507,20 @@ declare interface components {
                  * @description Machine-readable reason, present on refusals that carry one. Branch on this rather than on `message`, which is prose and may be reworded. `retrieval_failed` is transient and worth retrying; `not_licensable` means report it undelivered; `price_drifted` means re-quote; `client_error` is ours to fix and must never be retried unchanged; `insufficient_funds` is cleared by funding the wallet and `daily_spend_cap_reached` deliberately is not.
                  *
                  *     On the Bulk acquisition steps: `exclusions_unacknowledged` means post the acknowledgement first; `quote_not_ready` means keep polling a `pending` quote or re-quote a `failed` one (`quote_state` says which); `quote_expired` and `quote_in_progress` mean re-quote, and wait for the re-quote already running; `invalid_acquisition_state` means re-read the acquisition (`status` and `expected_status` are alongside); `nothing_to_hold` means every work was excluded and a different selection is needed; `run_not_started` means the run could not be queued, so nothing was held and the same authorization is safe to retry.
+                 *
+                 *     `invitation_not_accepted` means a store or Company invitation was refused; `reason` alongside says why (see `InvitationNotAcceptedError`).
                  * @enum {string}
                  */
-                type?: 'retrieval_failed' | 'not_licensable' | 'price_drifted' | 'client_error' | 'insufficient_funds' | 'daily_spend_cap_reached' | 'exclusions_unacknowledged' | 'invalid_acquisition_state' | 'quote_not_ready' | 'nothing_to_hold' | 'quote_expired' | 'quote_in_progress' | 'run_not_started';
+                type?: 'retrieval_failed' | 'not_licensable' | 'price_drifted' | 'client_error' | 'insufficient_funds' | 'daily_spend_cap_reached' | 'exclusions_unacknowledged' | 'invalid_acquisition_state' | 'quote_not_ready' | 'nothing_to_hold' | 'quote_expired' | 'quote_in_progress' | 'run_not_started' | 'invitation_not_accepted';
             };
         };
         AuthSignupRequest: {
             email: string;
             password: string;
             name: string;
-            /** @description The token from a Company invitation email. When it names a pending invitation addressed to this email, signup also accepts it and the new buyer joins the Company. Otherwise the account is created without a membership. */
+            /** @description The token from a store invitation email. Signup also accepts it and the new account joins the store. If the invitation can't be accepted, nothing is created and the signup is refused with a 422 (`InvitationNotAcceptedError`). */
+            invitation_token?: string;
+            /** @description The token from a Company invitation email. Signup also accepts it and the new buyer joins the Company. If the invitation can't be accepted (unknown, addressed to another email, expired, withdrawn or already accepted), nothing is created and the signup is refused with a 422. A signup carrying both tokens joins both or neither. */
             company_invitation_token?: string;
         };
         AuthLoginEmailRequest: {
@@ -1408,6 +1529,10 @@ declare interface components {
         };
         AuthLoginOAuthRequest: {
             id_token?: string;
+            /** @description The token from a store invitation email. The account joins the store. When this call creates the account and the invitation can't be accepted, nothing is created and the call is refused with a 422. See `company_invitation_token` for an existing account. */
+            invitation_token?: string;
+            /** @description The token from a Company invitation email. When this call creates the account, it also accepts the invitation and the new buyer joins the Company. If the invitation can't be accepted (unknown, addressed to another email, expired, withdrawn or already accepted), nothing is created and the call is refused with a 422. A call creating an account with both tokens joins both or neither. For an account that already exists, each token is accepted if it can be, the sign-in succeeds either way, and the response's `invitations` says what happened to each. */
+            company_invitation_token?: string;
         };
         MerchantEmailLoginRequest: {
             email: string;
@@ -1557,6 +1682,7 @@ declare interface components {
             id: string;
             /** Format: uuid */
             user_id: string;
+            /** @description The member's current name, read when the response is built. Renaming a Machine user (PATCH /v1/company/machine-users/{id}) relabels its earlier rows too; the audit trail keeps the old name. */
             name: string;
             /** @enum {string} */
             kind: 'human' | 'machine';
@@ -1607,6 +1733,11 @@ declare interface components {
             name: string;
             description?: string | null;
         };
+        /** @description At least one of `name` and `description`. A null or blank `description` clears it; `name` cannot be null. */
+        CompanyMachineUserUpdateRequest: {
+            name?: string;
+            description?: string | null;
+        } | unknown | unknown;
         /** @description A Machine user's Buyer key as a Company admin sees it. It logs in through POST /v1/auth/login/buyer-api-key. Its limit is the Machine user's membership Spend cap. */
         CompanyMachineUserBuyerKey: {
             /** Format: uuid */
@@ -1675,6 +1806,18 @@ declare interface components {
         CompanyMemberList: {
             data: components['schemas']['CompanyMember'][];
         };
+        /** @description The Company wallet, as a Company admin sees it. No member-facing response carries these figures; only this one does. */
+        CompanyWallet: {
+            /** @description Spendable now. Money held by in-flight Bulk acquisitions is already out of it. Negative when a reversed top-up has taken the wallet below zero; a purchase is refused whenever the balance does not cover its price. */
+            balance_cents: number;
+            /** @description Committed to Company-paid Bulk acquisitions still in progress, including those started by members who have since left the Company. When an acquisition settles or is cancelled, what it captured is charged and the rest is released back to the balance. */
+            held_cents: number;
+            /** @description The sum of top-ups not yet spendable: the same top-ups GET /v1/company/wallet/pending-top-ups lists. Not part of the balance until each settles. */
+            pending_top_up_cents: number;
+            /** @example usd */
+            currency: string;
+            company_name: string;
+        };
         /** @description A Company wallet top-up that has not yet settled, as a Company admin sees it. */
         CompanyPendingTopUp: {
             /** Format: uuid */
@@ -3585,6 +3728,20 @@ declare interface HttpClientConfig {
  */
 export declare function init(config: BrowserClientConfig): BrowserClient;
 
+/**
+ * What happened to one invitation token sent with `auth.loginWithGoogle()` for
+ * an account that already existed. A refused invitation does not refuse the
+ * sign-in; `accepted` is `false` and `reason` says why.
+ */
+export declare type InvitationOutcome = components['schemas']['InvitationOutcome'];
+
+/**
+ * Why a store or Company invitation was not accepted. Carried by an
+ * {@link InvitationOutcome}, and by a refused signup or Google sign-in as
+ * `LedewireError.details.reason` (with `type === 'invitation_not_accepted'`).
+ */
+export declare type InvitationRefusalReason = components['schemas']['InvitationRefusalReason'];
+
 /**
  * Base error class for all LedeWire SDK errors.
  * All errors thrown by the SDK are instances of this class,

package/dist/index.js

@@ -394,6 +394,9 @@ var S = class {
 	async create(e) {
 		return this.http.post("/v1/company/invitations", e);
 	}
+	async revoke(e) {
+		return this.http.delete(`/v1/company/invitations/${encodeURIComponent(e)}`);
+	}
 	async accept(e) {
 		return this.http.post("/v1/company/invitations/accept", e);
 	}
@@ -439,6 +442,9 @@ var M = class {
 	async create(e) {
 		return this.http.post("/v1/company/machine-users", e);
 	}
+	async update(e, t) {
+		return this.http.patch(j(e), t);
+	}
 	async deactivate(e) {
 		return this.http.delete(j(e));
 	}
@@ -483,6 +489,9 @@ var M = class {
 	constructor(e) {
 		a(this, "http", void 0), this.http = e;
 	}
+	async get() {
+		return this.http.get("/v1/company/wallet");
+	}
 	async createPaymentSession(e) {
 		return this.http.post("/v1/company/wallet/payment-session", e);
 	}