@lightsparkdev/grid 0.2.1

package/src/resources/receiver.ts

@@ -0,0 +1,139 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import * as ConfigAPI from './config';
+import * as QuotesAPI from './quotes';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+export class Receiver extends APIResource {
+  /**
+   * Lookup an external account by ID to determine supported currencies and exchange
+   * rates. This endpoint helps platforms determine what currencies they can send to
+   * a given external account, along with the current estimated exchange rates and
+   * minimum and maximum amounts that can be sent.
+   */
+  lookupExternalAccount(
+    accountID: string,
+    query: ReceiverLookupExternalAccountParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ReceiverLookupExternalAccountResponse> {
+    return this._client.get(path`/receiver/external-account/${accountID}`, { query, ...options });
+  }
+
+  /**
+   * Lookup a receiving UMA address to determine supported currencies and exchange
+   * rates. This endpoint helps platforms determine what currencies they can send to
+   * a given UMA address.
+   */
+  lookupUma(
+    receiverUmaAddress: string,
+    query: ReceiverLookupUmaParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<ReceiverLookupUmaResponse> {
+    return this._client.get(path`/receiver/uma/${receiverUmaAddress}`, { query, ...options });
+  }
+}
+
+export interface CounterpartyFieldDefinition {
+  /**
+   * Whether the field is mandatory
+   */
+  mandatory: boolean;
+
+  /**
+   * Name of a type of field containing info about a platform's customer or
+   * counterparty customer.
+   */
+  name: ConfigAPI.CustomerInfoFieldName;
+}
+
+export interface LookupResponse {
+  /**
+   * Unique identifier for the lookup. Needed in the subsequent create quote request.
+   */
+  lookupId: string;
+
+  /**
+   * List of currencies supported by the receiving account
+   */
+  supportedCurrencies: Array<LookupResponse.SupportedCurrency>;
+
+  /**
+   * Fields required by the receiving institution about the payer before payment can
+   * be completed
+   */
+  requiredPayerDataFields?: Array<CounterpartyFieldDefinition>;
+}
+
+export namespace LookupResponse {
+  export interface SupportedCurrency {
+    currency: QuotesAPI.Currency;
+
+    /**
+     * An estimated exchange rate from the sender's currency to this currency. This is
+     * not a locked rate and is subject to change when calling the quotes endpoint.
+     */
+    estimatedExchangeRate: number;
+
+    /**
+     * The maximum amount that can be received in this currency.
+     */
+    max: number;
+
+    /**
+     * The minimum amount that can be received in this currency.
+     */
+    min: number;
+  }
+}
+
+export interface ReceiverLookupExternalAccountResponse extends LookupResponse {
+  /**
+   * The external account ID that was looked up
+   */
+  accountId: string;
+}
+
+export interface ReceiverLookupUmaResponse extends LookupResponse {
+  /**
+   * The UMA address that was looked up
+   */
+  receiverUmaAddress: string;
+}
+
+export interface ReceiverLookupExternalAccountParams {
+  /**
+   * System ID of the sender (optional if senderUmaAddress is provided)
+   */
+  customerId?: string;
+
+  /**
+   * UMA address of the sender (optional if customerId is provided)
+   */
+  senderUmaAddress?: string;
+}
+
+export interface ReceiverLookupUmaParams {
+  /**
+   * System ID of the sender (optional if senderUmaAddress is provided)
+   */
+  customerId?: string;
+
+  /**
+   * UMA address of the sender (optional if customerId is provided)
+   */
+  senderUmaAddress?: string;
+}
+
+export declare namespace Receiver {
+  export {
+    type CounterpartyFieldDefinition as CounterpartyFieldDefinition,
+    type LookupResponse as LookupResponse,
+    type ReceiverLookupExternalAccountResponse as ReceiverLookupExternalAccountResponse,
+    type ReceiverLookupUmaResponse as ReceiverLookupUmaResponse,
+    type ReceiverLookupExternalAccountParams as ReceiverLookupExternalAccountParams,
+    type ReceiverLookupUmaParams as ReceiverLookupUmaParams,
+  };
+}

package/src/resources/sandbox/index.ts

@@ -0,0 +1,10 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  InternalAccounts,
+  type InternalAccount,
+  type InternalAccountFundParams,
+  type InternalAccountsDefaultPagination,
+} from './internal-accounts';
+export { Sandbox, type SandboxSendFundsResponse, type SandboxSendFundsParams } from './sandbox';
+export { Uma, type UmaReceivePaymentParams } from './uma';

package/src/resources/sandbox/internal-accounts.ts

@@ -0,0 +1,82 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as InvitationsAPI from '../invitations';
+import * as QuotesAPI from '../quotes';
+import { APIPromise } from '../../core/api-promise';
+import { DefaultPagination } from '../../core/pagination';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class InternalAccounts extends APIResource {
+  /**
+   * Simulate receiving funds into an internal account in the sandbox environment.
+   * This is useful for testing scenarios where you need to add funds to a customer's
+   * or platform's internal account without going through a real bank transfer or
+   * following payment instructions. This endpoint is only for the sandbox
+   * environment and will fail for production platforms/keys.
+   *
+   * @example
+   * ```ts
+   * const internalAccount =
+   *   await client.sandbox.internalAccounts.fund(
+   *     'InternalAccount:a12dcbd6-dced-4ec4-b756-3c3a9ea3d123',
+   *     { amount: 100000 },
+   *   );
+   * ```
+   */
+  fund(
+    accountID: string,
+    body: InternalAccountFundParams,
+    options?: RequestOptions,
+  ): APIPromise<InternalAccount> {
+    return this._client.post(path`/sandbox/internal-accounts/${accountID}/fund`, { body, ...options });
+  }
+}
+
+export type InternalAccountsDefaultPagination = DefaultPagination<InternalAccount>;
+
+export interface InternalAccount {
+  /**
+   * The ID of the internal account
+   */
+  id: string;
+
+  balance: InvitationsAPI.CurrencyAmount;
+
+  /**
+   * Timestamp when the internal account was created
+   */
+  createdAt: string;
+
+  /**
+   * Payment instructions for funding the account
+   */
+  fundingPaymentInstructions: Array<QuotesAPI.PaymentInstructions>;
+
+  /**
+   * Timestamp when the internal account was last updated
+   */
+  updatedAt: string;
+
+  /**
+   * The ID of the customer associated with the internal account. If this field is
+   * empty, the internal account belongs to the platform.
+   */
+  customerId?: string;
+}
+
+export interface InternalAccountFundParams {
+  /**
+   * Amount to add in the smallest unit of the account's currency (e.g., cents for
+   * USD/EUR, satoshis for BTC)
+   */
+  amount: number;
+}
+
+export declare namespace InternalAccounts {
+  export {
+    type InternalAccount as InternalAccount,
+    type InternalAccountFundParams as InternalAccountFundParams,
+  };
+}

package/src/resources/sandbox/sandbox.ts

@@ -0,0 +1,159 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as InvitationsAPI from '../invitations';
+import * as QuotesAPI from '../quotes';
+import * as TransactionsAPI from '../transactions';
+import * as TransferInAPI from '../transfer-in';
+import * as InternalAccountsAPI from './internal-accounts';
+import { InternalAccount, InternalAccountFundParams, InternalAccounts } from './internal-accounts';
+import * as UmaAPI from './uma';
+import { Uma, UmaReceivePaymentParams } from './uma';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+
+export class Sandbox extends APIResource {
+  uma: UmaAPI.Uma = new UmaAPI.Uma(this._client);
+  internalAccounts: InternalAccountsAPI.InternalAccounts = new InternalAccountsAPI.InternalAccounts(
+    this._client,
+  );
+
+  /**
+   * Simulate sending funds to the bank account as instructed in the quote. This
+   * endpoint is only for the sandbox environment and will fail for production
+   * platforms/keys.
+   *
+   * @example
+   * ```ts
+   * const response = await client.sandbox.sendFunds({
+   *   currencyCode: 'USD',
+   *   quoteId: 'Quote:019542f5-b3e7-1d02-0000-000000000006',
+   * });
+   * ```
+   */
+  sendFunds(body: SandboxSendFundsParams, options?: RequestOptions): APIPromise<SandboxSendFundsResponse> {
+    return this._client.post('/sandbox/send', { body, ...options });
+  }
+}
+
+export interface SandboxSendFundsResponse extends TransferInAPI.Transaction {
+  /**
+   * Payment instructions for executing the payment.
+   */
+  paymentInstructions: Array<QuotesAPI.PaymentInstructions>;
+
+  /**
+   * Amount sent in the sender's currency
+   */
+  sentAmount: InvitationsAPI.CurrencyAmount;
+
+  /**
+   * Source account details
+   */
+  source: TransactionsAPI.TransactionSourceOneOf;
+
+  /**
+   * Number of sending currency units per receiving currency unit.
+   */
+  exchangeRate?: number;
+
+  /**
+   * If the transaction failed, this field provides the reason for failure.
+   */
+  failureReason?:
+    | 'QUOTE_EXPIRED'
+    | 'QUOTE_EXECUTION_FAILED'
+    | 'LIGHTNING_PAYMENT_FAILED'
+    | 'FUNDING_AMOUNT_MISMATCH'
+    | 'COUNTERPARTY_POST_TX_FAILED'
+    | 'TIMEOUT';
+
+  /**
+   * The fees associated with the quote in the smallest unit of the sending currency
+   * (eg. cents).
+   */
+  fees?: number;
+
+  /**
+   * ID of the original transaction that this transaction is retrying, if applicable
+   */
+  originalTransactionId?: string;
+
+  /**
+   * The ID of the quote that was used to trigger this payment
+   */
+  quoteId?: string;
+
+  /**
+   * Details about the rate and fees for the transaction.
+   */
+  rateDetails?: QuotesAPI.OutgoingRateDetails;
+
+  /**
+   * Amount to be received by recipient in the recipient's currency
+   */
+  receivedAmount?: InvitationsAPI.CurrencyAmount;
+
+  /**
+   * The refund if transaction was refunded.
+   */
+  refund?: SandboxSendFundsResponse.Refund;
+}
+
+export namespace SandboxSendFundsResponse {
+  /**
+   * The refund if transaction was refunded.
+   */
+  export interface Refund {
+    /**
+     * When the refund was initiated
+     */
+    initiatedAt: string;
+
+    /**
+     * The unique reference code of the refund
+     */
+    reference: string;
+
+    /**
+     * When the refund was or will be settled
+     */
+    settledAt?: string;
+  }
+}
+
+export interface SandboxSendFundsParams {
+  /**
+   * Currency code for the funds to be sent
+   */
+  currencyCode: string;
+
+  /**
+   * The unique identifier of the quote
+   */
+  quoteId: string;
+
+  /**
+   * The amount to send in the smallest unit of the currency (eg. cents). If not
+   * provided, the amount will be derived from the quote.
+   */
+  currencyAmount?: number;
+}
+
+Sandbox.Uma = Uma;
+Sandbox.InternalAccounts = InternalAccounts;
+
+export declare namespace Sandbox {
+  export {
+    type SandboxSendFundsResponse as SandboxSendFundsResponse,
+    type SandboxSendFundsParams as SandboxSendFundsParams,
+  };
+
+  export { Uma as Uma, type UmaReceivePaymentParams as UmaReceivePaymentParams };
+
+  export {
+    InternalAccounts as InternalAccounts,
+    type InternalAccount as InternalAccount,
+    type InternalAccountFundParams as InternalAccountFundParams,
+  };
+}

package/src/resources/sandbox/uma.ts

@@ -0,0 +1,61 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as TransactionsAPI from '../transactions';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+
+export class Uma extends APIResource {
+  /**
+   * Simulate sending payment from an sandbox uma address to a platform customer to
+   * test payment receive. This endpoint is only for the sandbox environment and will
+   * fail for production platforms/keys.
+   *
+   * @example
+   * ```ts
+   * const incomingTransaction =
+   *   await client.sandbox.uma.receivePayment({
+   *     receivingCurrencyAmount: 1000,
+   *     receivingCurrencyCode: 'USD',
+   *     senderUmaAddress: '$success.usd@sandbox.grid.uma.money',
+   *   });
+   * ```
+   */
+  receivePayment(
+    body: UmaReceivePaymentParams,
+    options?: RequestOptions,
+  ): APIPromise<TransactionsAPI.IncomingTransaction> {
+    return this._client.post('/sandbox/uma/receive', { body, ...options });
+  }
+}
+
+export interface UmaReceivePaymentParams {
+  /**
+   * The amount to be received in the smallest unit of the currency (eg. cents)
+   */
+  receivingCurrencyAmount: number;
+
+  /**
+   * The currency code for the receiving amount
+   */
+  receivingCurrencyCode: string;
+
+  /**
+   * UMA address of the sender from the sandbox
+   */
+  senderUmaAddress: string;
+
+  /**
+   * System ID of the receiver (optional if receiverUmaAddress is provided)
+   */
+  customerId?: string;
+
+  /**
+   * UMA address of the receiver (optional if customerId is provided)
+   */
+  receiverUmaAddress?: string;
+}
+
+export declare namespace Uma {
+  export { type UmaReceivePaymentParams as UmaReceivePaymentParams };
+}

package/src/resources/sandbox.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './sandbox/index';

package/src/resources/tokens.ts

@@ -0,0 +1,176 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { DefaultPagination, type DefaultPaginationParams, PagePromise } from '../core/pagination';
+import { buildHeaders } from '../internal/headers';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+export class Tokens extends APIResource {
+  /**
+   * Create a new API token to access the Grid APIs.
+   *
+   * @example
+   * ```ts
+   * const apiToken = await client.tokens.create({
+   *   name: 'Sandbox read-only',
+   *   permissions: ['VIEW'],
+   * });
+   * ```
+   */
+  create(body: TokenCreateParams, options?: RequestOptions): APIPromise<APIToken> {
+    return this._client.post('/tokens', { body, ...options });
+  }
+
+  /**
+   * Retrieve an API token by their system-generated ID
+   *
+   * @example
+   * ```ts
+   * const apiToken = await client.tokens.retrieve('tokenId');
+   * ```
+   */
+  retrieve(tokenID: string, options?: RequestOptions): APIPromise<APIToken> {
+    return this._client.get(path`/tokens/${tokenID}`, options);
+  }
+
+  /**
+   * Retrieve a list of API tokens with optional filtering parameters. Returns all
+   * tokens that match the specified filters. If no filters are provided, returns all
+   * tokens (paginated).
+   *
+   * @example
+   * ```ts
+   * // Automatically fetches more pages as needed.
+   * for await (const apiToken of client.tokens.list()) {
+   *   // ...
+   * }
+   * ```
+   */
+  list(
+    query: TokenListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<APITokensDefaultPagination, APIToken> {
+    return this._client.getAPIList('/tokens', DefaultPagination<APIToken>, { query, ...options });
+  }
+
+  /**
+   * Delete an API token by their system-generated ID
+   *
+   * @example
+   * ```ts
+   * await client.tokens.delete('tokenId');
+   * ```
+   */
+  delete(tokenID: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/tokens/${tokenID}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+}
+
+export type APITokensDefaultPagination = DefaultPagination<APIToken>;
+
+export interface APIToken {
+  /**
+   * System-generated unique identifier
+   */
+  id: string;
+
+  /**
+   * An opaque identifier that should be used as a client_id (or username) in the
+   * HTTP Basic Authentication scheme when issuing http requests to Grid.
+   */
+  clientId: string;
+
+  /**
+   * Creation timestamp
+   */
+  createdAt: string;
+
+  /**
+   * Name of the token
+   */
+  name: string;
+
+  /**
+   * A list of permissions granted to the token
+   */
+  permissions: Array<Permission>;
+
+  /**
+   * Last update timestamp
+   */
+  updatedAt: string;
+
+  /**
+   * The secret that should be used to authenticate against Grid API. This secret is
+   * not stored and will never be available again after creation. Platform must keep
+   * this secret secure as it grants access to the account.
+   */
+  clientSecret?: string;
+}
+
+/**
+ * Permission of an API token that determines what actions the token can perform:
+ * VIEW: Can view all data, including platform config, customers and transactions
+ * TRANSACT: Can send payments MANAGE: Can manage platform config, api tokens and
+ * customers
+ */
+export type Permission = 'VIEW' | 'TRANSACT' | 'MANAGE';
+
+export interface TokenCreateParams {
+  /**
+   * Name of the token to help identify it
+   */
+  name: string;
+
+  /**
+   * A list of permissions to grant to the token
+   */
+  permissions: Array<Permission>;
+}
+
+export interface TokenListParams extends DefaultPaginationParams {
+  /**
+   * Filter customers created after this timestamp (inclusive)
+   */
+  createdAfter?: string;
+
+  /**
+   * Filter customers created before this timestamp (inclusive)
+   */
+  createdBefore?: string;
+
+  /**
+   * Maximum number of results to return (default 20, max 100)
+   */
+  limit?: number;
+
+  /**
+   * Filter by name of the token
+   */
+  name?: string;
+
+  /**
+   * Filter customers updated after this timestamp (inclusive)
+   */
+  updatedAfter?: string;
+
+  /**
+   * Filter customers updated before this timestamp (inclusive)
+   */
+  updatedBefore?: string;
+}
+
+export declare namespace Tokens {
+  export {
+    type APIToken as APIToken,
+    type Permission as Permission,
+    type APITokensDefaultPagination as APITokensDefaultPagination,
+    type TokenCreateParams as TokenCreateParams,
+    type TokenListParams as TokenListParams,
+  };
+}