schema.graphql

"""Exposes a URL that specifies the behavior of this scalar."""
directive @specifiedBy(
  """The URL that specifies the behavior of this scalar."""
  url: String!
) on SCALAR

directive @defer(label: String, if: Boolean! = true) on FRAGMENT_SPREAD | INLINE_FRAGMENT

interface Account {
  callbackEndpoints: [CallbackEndpoint!]!
  csvTransactions(walletIds: [WalletId!]!): String!
  defaultWalletId: WalletId!
  displayCurrency: DisplayCurrency!
  id: ID!
  level: AccountLevel!
  limits: AccountLimits!
  notificationSettings: NotificationSettings!
  realtimePrice: RealtimePrice!
  transactions(
    """Returns the items in the list that come after the specified cursor."""
    after: String

    """Returns the items in the list that come before the specified cursor."""
    before: String

    """Returns the first n items from the list."""
    first: Int

    """Returns the last n items from the list."""
    last: Int
    walletIds: [WalletId]
  ): TransactionConnection
  wallets: [Wallet!]!
}

type AccountCapabilities {
  """An approved bank account is on file for payouts."""
  bankPayout: Boolean!

  """Business profile (name and address) on file."""
  business: Boolean!

  """
  USD account and routing number available (Bridge KYC approved). Orthogonal to the other capabilities.
  """
  usdAccount: Boolean!

  """Phone and identity verified."""
  verified: Boolean!
}

enum AccountCapability {
  BANK_PAYOUT
  BUSINESS
}

input AccountCapabilityUpgradeRequestInput {
  address: AddressInput!
  bankAccount: BankAccountInput
  capability: AccountCapability!
  fullName: String!
  idDocument: String
  terminalsRequested: Int = 0
}

type AccountCapabilityUpgradeRequestPayload {
  errors: [Error]
  id: String
  status: String
}

type AccountDeletePayload {
  errors: [Error!]!
  success: Boolean!
}

input AccountDisableNotificationCategoryInput {
  category: NotificationCategory!
  channel: NotificationChannel
}

input AccountDisableNotificationChannelInput {
  channel: NotificationChannel!
}

input AccountEnableNotificationCategoryInput {
  category: NotificationCategory!
  channel: NotificationChannel
}

input AccountEnableNotificationChannelInput {
  channel: NotificationChannel!
}

enum AccountLevel {
  ONE
  THREE
  TWO
  ZERO
}

interface AccountLimit {
  """The rolling time interval in seconds that the limits would apply for."""
  interval: Seconds

  """
  The amount of cents remaining below the limit for the current 24 hour period.
  """
  remainingLimit: CentAmount

  """The current maximum limit for a given 24 hour period."""
  totalLimit: CentAmount!
}

type AccountLimits {
  """
  Limits for converting between currencies among a account's own wallets.
  """
  convert: [AccountLimit!]!

  """Limits for sending to other internal accounts."""
  internalSend: [AccountLimit!]!

  """Limits for withdrawing to external onchain or lightning destinations."""
  withdrawal: [AccountLimit!]!
}

"""Bank account number. Accepts String or Int and coerces to String."""
scalar AccountNumber

enum AccountStatusHeadline {
  BUSINESS
  TRIAL
  VERIFIED
}

input AccountUpdateDefaultWalletIdInput {
  walletId: WalletId!
}

type AccountUpdateDefaultWalletIdPayload {
  account: ConsumerAccount
  errors: [Error!]!
}

input AccountUpdateDisplayCurrencyInput {
  currency: DisplayCurrency!
}

type AccountUpdateDisplayCurrencyPayload {
  account: ConsumerAccount
  errors: [Error!]!
}

type AccountUpdateNotificationSettingsPayload {
  account: ConsumerAccount
  errors: [Error!]!
}

type AccountUpgradePayload {
  errors: [Error]
  id: String
  status: String
}

type AccountUpgradeRequest {
  address: Address!
  bankAccount: BankAccount
  currentLevel: AccountLevel!
  email: String
  fullName: String!
  idDocument: Boolean!

  """ERPNext document name"""
  name: String!
  phoneNumber: String!
  requestedLevel: AccountLevel!

  """Status of the upgrade request"""
  status: String!
  terminalsRequested: Int!
  username: String!
}

type AccountUpgradeRequestPayload {
  errors: [Error]
  upgradeRequest: AccountUpgradeRequest
}

type Address {
  city: String!
  country: String!
  line1: String!
  line2: String
  postalCode: String
  state: String!
  title: String!
}

input AddressInput {
  city: String!
  country: String!
  line1: String!
  line2: String
  postalCode: String
  state: String!
  title: String!
}

type ApiKey {
  createdAt: Timestamp!
  expiresAt: Timestamp
  id: ID!

  """Public key identifier (the keyId in fk_<keyId>_<secret>)"""
  keyId: String!
  lastUsedAt: Timestamp
  name: String!

  """
  Per-key request rate limit (requests per minute). Null means the platform default applies.
  """
  rateLimitPerMinute: Int
  scopes: [ApiKeyScope!]!

  """
  Effective status: keys past their expiry report EXPIRED even before the stored status catches up
  """
  status: ApiKeyStatus!
}

type ApiKeyCreated {
  """The raw API key. Store it securely — it won't be shown again."""
  apiKey: String!
  expiresAt: Timestamp
  id: ID!

  """Public key identifier (the keyId in fk_<keyId>_<secret>)"""
  keyId: String!
  name: String!

  """
  Per-key request rate limit (requests per minute). Null means the platform default applies.
  """
  rateLimitPerMinute: Int
  scopes: [ApiKeyScope!]!
  warning: String!
}

input ApiKeyCreateInput {
  """
  Optional expiration time in seconds. If not set, the key doesn't expire.
  """
  expiresIn: Int

  """A descriptive name for the API key (e.g., 'BTCPayServer Integration')"""
  name: String!

  """
  Optional per-key request rate limit (requests per minute, 1-10000). If not set, the platform default applies.
  """
  rateLimitPerMinute: Int

  """Permission scopes for the key. Defaults to read-only user access."""
  scopes: [ApiKeyScope!] = [read_user]
}

type ApiKeyCreatePayload {
  apiKey: ApiKeyCreated
  errors: [Error!]!
}

input ApiKeyRevokeInput {
  id: ID!
}

type ApiKeyRevokePayload {
  apiKey: ApiKey
  errors: [Error!]!
}

input ApiKeyRotateInput {
  id: ID!
}

type ApiKeyRotatePayload {
  apiKey: ApiKeyCreated
  errors: [Error!]!
}

"""Permission scopes for API keys (FIP-07)"""
enum ApiKeyScope {
  """Full administrative access"""
  admin

  """Read transaction history"""
  read_transactions

  """Read-only access to user/account data"""
  read_user

  """Read wallet balances and details"""
  read_wallet

  """Create transactions"""
  write_transactions

  """Modify user/account data"""
  write_user

  """Perform wallet operations (send/receive)"""
  write_wallet
}

"""Lifecycle status of an API key (FIP-07)"""
enum ApiKeyStatus {
  ACTIVE
  EXPIRED
  REVOKED
}

"""An Opaque Bearer token"""
scalar AuthToken

type AuthTokenPayload {
  authToken: AuthToken
  errors: [Error!]!
  totpRequired: Boolean
}

type Bank {
  name: String!
}

type BankAccount {
  accountName: String
  accountNumber: String!
  accountType: String!
  bankBranch: String!
  bankName: String!

  """Account currency (e.g. JMD, USD)"""
  currency: String!

  """ERPNext bank account identifier"""
  id: ID
  isDefault: Boolean!

  """
  The account's in-flight update request when it needs the user's attention —
  Pending (awaiting review) or Rejected (declined). Null once approved/closed,
  or when none exists.
  """
  pendingUpdate: BankAccountUpdateRequest
}

input BankAccountInput {
  accountNumber: AccountNumber!
  accountType: String!
  bankBranch: String!
  bankName: String!
  currency: String!
}

"""
A pending request to change the details of an approved bank account, awaiting admin review.
"""
type BankAccountUpdateRequest {
  """Proposed new account number"""
  accountNumber: String!

  """Proposed new account type"""
  accountType: String!

  """Proposed new bank branch"""
  bankBranch: String!

  """Proposed new bank name"""
  bankName: String!

  """Account currency (unchanged from the current account)"""
  currency: String!

  """Reviewer note, set when status is Rejected"""
  rejectionReason: String

  """Pending | Approved | Rejected | Closed"""
  status: String!
}

input BankAccountUpdateRequestInput {
  accountNumber: AccountNumber!
  accountType: String!

  """ERPNext identifier of the account to update"""
  bankAccountId: ID!
  bankBranch: String!
  bankName: String!

  """Must match the account's current currency (currency is locked)"""
  currency: String!
}

type BankAccountUpdateRequestPayload {
  errors: [Error]

  """Status of the created request (Pending on success)"""
  status: String
}

type BridgeAddExternalAccountPayload {
  errors: [Error!]!
  externalAccount: BridgeExternalAccountLink
}

input BridgeCancelWithdrawalRequestInput {
  withdrawalId: ID!
}

type BridgeCancelWithdrawalRequestPayload {
  errors: [Error!]!
  withdrawal: BridgeWithdrawal
}

input BridgeCreateExternalAccountInput {
  accountNumber: String!
  accountOwnerName: String!
  bankName: String!
  checkingOrSavings: String = "checking"
  city: String!
  country: String!
  postalCode: String!
  routingNumber: String!
  state: String!
  streetLine1: String!
}

type BridgeCreateExternalAccountPayload {
  errors: [Error!]!
  externalAccount: BridgeExternalAccount
}

type BridgeCreateVirtualAccountPayload {
  errors: [Error!]!
  virtualAccount: BridgeVirtualAccount
}

input BridgeDeleteExternalAccountInput {
  externalAccountId: ID!
}

type BridgeDeleteExternalAccountPayload {
  errors: [Error!]!
  externalAccount: BridgeExternalAccount
}

input BridgeExchangePlaidPublicTokenInput {
  linkToken: String!
  publicToken: String!
}

type BridgeExchangePlaidPublicTokenPayload {
  errors: [Error!]!
  message: String
}

type BridgeExternalAccount {
  accountNumberLast4: String!
  bankName: String!
  id: ID!
  isDefault: Boolean!
  status: String!
}

type BridgeExternalAccountLink {
  expiresAt: String!
  linkToken: String!
  linkUrl: String @deprecated(reason: "Use linkToken with the Plaid Link SDK. Hosted-URL linking is being retired; this field is best-effort and may be null.")
}

input BridgeInitiateKycInput {
  email: String
  full_name: String
  type: String
}

type BridgeInitiateKycPayload {
  errors: [Error!]!
  kycLink: BridgeKycLink
}

input BridgeInitiateWithdrawalInput {
  withdrawalId: ID!
}

type BridgeInitiateWithdrawalPayload {
  errors: [Error!]!
  withdrawal: BridgeWithdrawal
}

type BridgeKycLink {
  kycLink: String!
  tosLink: String!
}

input BridgeRequestWithdrawalInput {
  amount: String!
  externalAccountId: ID!
}

type BridgeRequestWithdrawalPayload {
  errors: [Error!]!
  withdrawal: BridgeWithdrawal
}

input BridgeSetDefaultExternalAccountInput {
  externalAccountId: ID!
}

type BridgeSetDefaultExternalAccountPayload {
  errors: [Error!]!
  externalAccount: BridgeExternalAccount
}

type BridgeVirtualAccount {
  accountNumber: String
  accountNumberLast4: String
  bankName: String
  id: ID
  kycLink: String
  message: String
  pending: Boolean
  routingNumber: String
  tosLink: String
}

type BridgeWithdrawal {
  amount: String!
  bridgeDeveloperFee: String
  bridgeExchangeFee: String
  bridgeTransferId: String
  createdAt: String!
  currency: String!
  estimatedBridgeFee: String
  estimatedBridgeFeePercent: String
  estimatedCustomerFee: String
  estimatedGasBuffer: String
  externalAccountId: String
  failureReason: String
  finalAmount: String
  flashFee: String
  flashFeeIsEstimate: Boolean!
  flashFeeNotice: String
  flashFeePercent: String
  id: ID!
  status: String!
  subtotalAmount: String
}

"""
A wallet belonging to an account which contains a BTC balance and a list of transactions.
"""
type BTCWallet implements Wallet {
  accountId: ID!

  """A balance stored in BTC."""
  balance: FractionalCentAmount
  id: ID!
  isExternal: Boolean!
  lnurlp: Lnurl

  """An unconfirmed incoming onchain balance."""
  pendingIncomingBalance: SignedAmount!

  """A list of BTC transactions associated with this wallet."""
  transactions(
    """Returns the items in the list that come after the specified cursor."""
    after: String

    """Returns the items in the list that come before the specified cursor."""
    before: String

    """Returns the first n items from the list."""
    first: Int

    """Returns the last n items from the list."""
    last: Int
  ): TransactionConnection
  transactionsByAddress(
    """Returns the items that include this address."""
    address: OnChainAddress!

    """Returns the items in the list that come after the specified cursor."""
    after: String

    """Returns the items in the list that come before the specified cursor."""
    before: String

    """Returns the first n items from the list."""
    first: Int

    """Returns the last n items from the list."""
    last: Int
  ): TransactionConnection
  walletCurrency: WalletCurrency!
}

type BuildInformation {
  commitHash: String
  helmRevision: Int
}

input BusinessAccountUpgradeRequestInput {
  address: AddressInput!
  bankAccount: BankAccountInput
  fullName: String!
  idDocument: String
  level: AccountLevel!
  terminalsRequested: Int = 0
}

type CallbackEndpoint {
  id: EndpointId!
  url: EndpointUrl!
}

input CallbackEndpointAddInput {
  """callback endpoint to be called"""
  url: EndpointUrl!
}

type CallbackEndpointAddPayload {
  errors: [Error!]!
  id: EndpointId
}

input CallbackEndpointDeleteInput {
  id: EndpointId!
}

type CaptchaCreateChallengePayload {
  errors: [Error!]!
  result: CaptchaCreateChallengeResult
}

type CaptchaCreateChallengeResult {
  challengeCode: String!
  failbackMode: Boolean!
  id: String!
  newCaptcha: Boolean!
}

input CaptchaRequestAuthCodeInput {
  challengeCode: String!
  channel: PhoneCodeChannelType
  phone: Phone!
  secCode: String!
  validationCode: String!
}

type CashoutOffer {
  """The rate used when withdrawing to a JMD bank account"""
  exchangeRate: JMDCents

  """The time at which this offer is no longer accepted by Flash"""
  expiresAt: Timestamp!

  """The amount that Flash is charging for its services"""
  flashFee: USDCents!

  """ID of the offer"""
  offerId: ID!

  """
  The amount Flash owes to the user denominated in JMD cents (null for USD payouts)
  """
  receiveJmd: JMDCents

  """
  The amount Flash owes to the user denominated in USD cents (null for JMD payouts)
  """
  receiveUsd: USDCents

  """The amount the user is sending to flash"""
  send: USDCents!

  """ID for the users USD wallet to send from"""
  walletId: WalletId!
}

type CashoutRate {
  """
  JMD cents per 1 USD at which a JMD cashout would settle right now — the same rate a cashout offer locks in.
  """
  exchangeRate: JMDCents!

  """
  Flash cashout service fee in basis points for the calling account, deducted
  from the USD amount before conversion. Already net of any Fee Discount the
  account is whitelisted for. The offer may still charge more than quoted: up to
  1 bip from rounding when the discount is a fraction of a percent, or the full
  standard fee if the Fee Discount list is unreadable at the moment the offer is built.
  """
  feeBasisPoints: Int!
}

type CashWalletCutover {
  completedAt: Timestamp
  cutoverVersion: Int!
  pauseReason: String
  pausedAt: Timestamp
  runId: String
  scheduledAt: Timestamp
  startedAt: Timestamp
  state: CashWalletCutoverState!
  updatedAt: Timestamp!
  updatedBy: String
}

enum CashWalletCutoverState {
  COMPLETE
  IN_PROGRESS
  PRE
  ROLLED_BACK
}

"""(Positive) Cent amount (1/100 of a dollar)"""
scalar CentAmount

type CentAmountPayload {
  amount: USDCents
  errors: [Error!]!
  invoiceAmount: USDCents
}

type ConsumerAccount implements Account {
  callbackEndpoints: [CallbackEndpoint!]!
  capabilities: AccountCapabilities!

  """
  return CSV stream, base64 encoded, of the list of transactions in the wallet
  """
  csvTransactions(walletIds: [WalletId!]!): String!
  defaultWalletId: WalletId!
  displayCurrency: DisplayCurrency!
  id: ID!

  """
  Internal account level, derived from capabilities (ENG-516). Present capabilities and statusHeadline instead of this.
  """
  level: AccountLevel!
  limits: AccountLimits!
  notificationSettings: NotificationSettings!

  """List the quiz questions of the consumer account"""
  quiz: [Quiz!]!
  realtimePrice: RealtimePrice!
  statusHeadline: AccountStatusHeadline!

  """
  A list of all transactions associated with walletIds optionally passed.
  """
  transactions(
    """Returns the items in the list that come after the specified cursor."""
    after: String

    """Returns the items in the list that come before the specified cursor."""
    before: String

    """Returns the first n items from the list."""
    first: Int

    """Returns the last n items from the list."""
    last: Int
    walletIds: [WalletId]
  ): TransactionConnection
  wallets: [Wallet!]!
}

"""
An alias name that a user can set for a wallet (with which they have transactions)
"""
scalar ContactAlias

type Coordinates {
  latitude: Float!
  longitude: Float!
}

type Country {
  id: CountryCode!
  supportedAuthChannels: [PhoneCodeChannelType!]!
}

"""A CCA2 country code (ex US, FR, etc)"""
scalar CountryCode

input CreateInviteInput {
  contact: String!
  method: InviteMethod!
}

type CreateInvitePayload {
  errors: [String!]!
  invite: Invite
}

type Currency {
  flag: String!
  fractionDigits: Int!
  id: ID!
  name: String!
  symbol: String!
}

type DepositFeesInformation {
  minBankFee: String!

  """below this amount minBankFee will be charged"""
  minBankFeeThreshold: String!

  """ratio to charge as basis points above minBankFeeThreshold amount"""
  ratio: String!
}

input DeviceNotificationTokenCreateInput {
  deviceToken: String!
}

"""Display currency of an account"""
scalar DisplayCurrency

type Email {
  address: EmailAddress
  verified: Boolean
}

"""Email address"""
scalar EmailAddress

"""
An id to be passed between registrationInitiate and registrationValidate for confirming email
"""
scalar EmailRegistrationId

scalar EndpointId

"""Url that will be fetched on events for the account"""
scalar EndpointUrl

interface Error {
  code: String
  message: String!
  path: [String]
}

enum ExchangeCurrencyUnit {
  BTCSAT
  USDCENT
}

"""Feedback shared with our user"""
scalar Feedback

input FeedbackSubmitInput {
  feedback: Feedback!
}

type FeesInformation {
  deposit: DepositFeesInformation!
}

"""
Cent amount (1/100 of a dollar) as a float, can be positive or negative
"""
scalar FractionalCentAmount

"""
A server-authorised card top-up. The amount is signed into the URL, so it is the only amount that can be paid through it.
"""
type FygaroCheckout {
  """
  The authorised amount, echoed back so the client can display what was signed.
  """
  amount: CentAmount!

  """
  After this, the URL is rejected by the payment provider and a new one must be requested.
  """
  expiresAt: Timestamp!

  """
  Open this in the payment webview. The amount and the destination account are
  signed into it and cannot be edited; it stops working at expiresAt.
  """
  url: String!
}

input FygaroCheckoutCreateInput {
  amount: CentAmount!
}

type FygaroCheckoutCreatePayload {
  checkout: FygaroCheckout
  errors: [Error!]!

  """
  How much more could be authorised right now, after this request. Card top-up
  links you have open but have not paid are ALREADY SUBTRACTED, so this is what
  would be accepted this second — not a statement of what the account has spent
  today. Present on refusal too, so the client can say how much would go through
  instead of only saying no. Null when the allowance could not be established.
  """
  remainingAllowance: CentAmount
}

"""
Fee parameters for Fygaro card top-ups, so the client can
compute the net amount a user will receive. Null when the operator settings
are unavailable — clients should degrade gracefully (hide the estimate).
"""
type FygaroTopupInfo {
  """Flash margin fixed fee, in USD."""
  flashFeeFixed: Float!

  """Flash margin percentage fee (e.g. 2.0 = 2.0%)."""
  flashFeePercent: Float!

  """
  Maximum gross card top-up per rolling 24h for level-1 accounts, in USD.
  """
  l1DailyLimit: Float!

  """
  Maximum gross card top-up per rolling 24h for level-2 accounts, in USD.
  """
  l2DailyLimit: Float!

  """
  Maximum gross card top-up per rolling 24h for level-3 (Business) accounts, in USD.
  """
  l3DailyLimit: Float!

  """Minimum top-up amount, in USD."""
  minimumAmount: Float!

  """Payment-processor fixed fee, in USD."""
  processorFeeFixed: Float!

  """Payment-processor percentage fee (e.g. 2.99 = 2.99%)."""
  processorFeePercent: Float!
}

"""
Provides global settings for the application which might have an impact for the user.
"""
type Globals {
  """
  Whether Bridge (international bank transfer) entry points
  should be shown to the user. Controlled by the instance-wide bridge feature flag.
  """
  bridgeEnabled: Boolean!
  buildInformation: BuildInformation!

  """
  Whether cashout (settle to local bank account) entry points
  should be shown to the user. Controlled by the instance-wide cashout feature flag.
  """
  cashoutEnabled: Boolean!
  feesInformation: FeesInformation!

  """
  Fee parameters for Fygaro card top-ups so the app can
  preview the net amount a user will receive. Null when operator settings
  are unavailable — the app should hide the estimate and fall back gracefully.
  """
  fygaroTopup: FygaroTopupInfo

  """
  The domain name for lightning addresses accepted by this Galoy instance
  """
  lightningAddressDomain: String!
  lightningAddressDomainAliases: [String!]!

  """
  Which network (mainnet, testnet, regtest, signet) this instance is running on.
  """
  network: Network!

  """
  A list of public keys for the running lightning nodes.
  This can be used to know if an invoice belongs to one of our nodes.
  """
  nodesIds: [String!]!

  """
  Whether referral-reward entry points (e.g. the "invite a
  friend" home-screen card) should be shown to the user. Controlled by the
  instance-wide referralReward feature flag; when false the referral payout is
  disabled, so reward-promising UI must stay hidden.
  """
  referralRewardEnabled: Boolean!

  """A list of countries and their supported auth channels"""
  supportedCountries: [Country!]!

  """
  Whether wallet top-up entry points (card webview and
  bank-transfer-to-support) should be shown to the user. Controlled by the
  instance-wide topup feature flag.
  """
  topupEnabled: Boolean!
}

type GraphQLApplicationError implements Error {
  code: String
  message: String!
  path: [String]
}

"""Hex-encoded string of 32 bytes"""
scalar Hex32Bytes

input IdDocumentUploadUrlGenerateInput {
  """MIME type (image/jpeg, image/png, image/webp)"""
  contentType: String!

  """Original filename"""
  filename: String!
}

type IdDocumentUploadUrlPayload {
  errors: [Error!]!

  """Storage key for the uploaded file (use to generate read URLs)"""
  fileKey: String

  """Pre-signed URL for uploading the ID document directly to storage"""
  uploadUrl: String
}

input InitiateCashoutInput {
  """The id of the offer being executed."""
  offerId: ID!
  walletId: WalletId!
}

type InitiatedCashoutResponse {
  errors: [Error!]!
  id: ID
}

union InitiationVia = InitiationViaIntraLedger | InitiationViaLn | InitiationViaOnChain

type InitiationViaIntraLedger {
  counterPartyUsername: Username
  counterPartyWalletId: WalletId
}

type InitiationViaLn {
  paymentHash: PaymentHash!
}

type InitiationViaOnChain {
  address: OnChainAddress!
}

input IntraLedgerPaymentSendInput {
  """Amount in satoshis."""
  amount: SatAmount!

  """
  Optional client-supplied key; a repeated send with the same key returns the original result instead of paying again.
  """
  idempotencyKey: String

  """Optional memo to be attached to the payment."""
  memo: Memo
  recipientWalletId: WalletId!

  """The wallet ID of the sender."""
  walletId: WalletId!
}

type IntraLedgerUpdate {
  amount: SatAmount!
  displayCurrencyPerSat: Float!
  txNotificationType: TxNotificationType!
  usdPerSat: Float! @deprecated(reason: "updated over displayCurrencyPerSat")
  walletId: WalletId!
}

input IntraLedgerUsdPaymentSendInput {
  """Amount in cents."""
  amount: FractionalCentAmount!

  """
  Optional client-supplied key; a repeated send with the same key returns the original result instead of paying again.
  """
  idempotencyKey: String

  """Optional memo to be attached to the payment."""
  memo: Memo
  recipientWalletId: WalletId!

  """The wallet ID of the sender."""
  walletId: WalletId!
}

type Invite {
  contact: String!
  createdAt: String!
  expiresAt: String!
  id: ID!
  method: InviteMethod!
  status: InviteStatus!
}

enum InviteMethod {
  EMAIL
  SMS
  WHATSAPP
}

type InvitePreview {
  contact: String!
  expiresAt: String!
  inviterUsername: String
  isValid: Boolean!
  method: String!
}

enum InviteStatus {
  ACCEPTED
  EXPIRED
  PENDING
  SENT
}

enum InvoicePaymentStatus {
  EXPIRED
  PAID
  PENDING
}

input IsFlashNpubInput {
  npub: npub!
}

type IsFlashNpubPayload {
  errors: [Error!]!
  isFlashNpub: Boolean
}

"""Amount in Jamaican cents"""
scalar JMDCents

scalar Language

type LnInvoice {
  paymentHash: PaymentHash!
  paymentRequest: LnPaymentRequest!
  paymentSecret: LnPaymentSecret!
  satoshis: SatAmount
}

input LnInvoiceCreateInput {
  """Amount in satoshis."""
  amount: SatAmount!

  """Optional invoice expiration time in minutes."""
  expiresIn: Minutes

  """Optional memo for the lightning invoice."""
  memo: Memo

  """Wallet ID for a BTC wallet belonging to the current account."""
  walletId: WalletId!
}

input LnInvoiceCreateOnBehalfOfRecipientInput {
  """Amount in satoshis."""
  amount: SatAmount!
  descriptionHash: Hex32Bytes

  """Optional invoice expiration time in minutes."""
  expiresIn: Minutes

  """Optional memo for the lightning invoice."""
  memo: Memo

  """Wallet ID for a BTC wallet which belongs to any account."""
  recipientWalletId: WalletId!
}

input LnInvoiceFeeProbeInput {
  paymentRequest: LnPaymentRequest!
  walletId: WalletId!
}

type LnInvoicePayload {
  errors: [Error!]!
  invoice: LnInvoice
}

input LnInvoicePaymentInput {
  """
  Optional client-supplied key; a repeated send with the same key returns the original result instead of paying again.
  """
  idempotencyKey: String

  """Optional memo to associate with the lightning invoice."""
  memo: Memo

  """Payment request representing the invoice which is being paid."""
  paymentRequest: LnPaymentRequest!

  """
  Wallet ID with sufficient balance to cover amount of invoice.  Must belong to the account of the current user.
  """
  walletId: WalletId!
}

input LnInvoicePaymentStatusInput {
  paymentRequest: LnPaymentRequest!
}

type LnInvoicePaymentStatusPayload {
  errors: [Error!]!
  status: InvoicePaymentStatus
}

type LnNoAmountInvoice {
  paymentHash: PaymentHash!
  paymentRequest: LnPaymentRequest!
  paymentSecret: LnPaymentSecret!
}

input LnNoAmountInvoiceCreateInput {
  """Optional invoice expiration time in minutes."""
  expiresIn: Minutes

  """Optional memo for the lightning invoice."""
  memo: Memo

  """
  ID for either a USD or BTC wallet belonging to the account of the current user.
  """
  walletId: WalletId!
}

input LnNoAmountInvoiceCreateOnBehalfOfRecipientInput {
  """Optional invoice expiration time in minutes."""
  expiresIn: Minutes

  """Optional memo for the lightning invoice."""
  memo: Memo

  """
  ID for either a USD or BTC wallet which belongs to the account of any user.
  """
  recipientWalletId: WalletId!
}

input LnNoAmountInvoiceFeeProbeInput {
  amount: SatAmount!
  paymentRequest: LnPaymentRequest!
  walletId: WalletId!
}

type LnNoAmountInvoicePayload {
  errors: [Error!]!
  invoice: LnNoAmountInvoice
}

input LnNoAmountInvoicePaymentInput {
  """Amount to pay in satoshis."""
  amount: SatAmount!

  """
  Optional client-supplied key; a repeated send with the same key returns the original result instead of paying again.
  """
  idempotencyKey: String

  """Optional memo to associate with the lightning invoice."""
  memo: Memo

  """Payment request representing the invoice which is being paid."""
  paymentRequest: LnPaymentRequest!

  """
  Wallet ID with sufficient balance to cover amount defined in mutation request.
   Must belong to the account of the current user.
  """
  walletId: WalletId!
}

input LnNoAmountUsdInvoiceFeeProbeInput {
  amount: FractionalCentAmount!
  paymentRequest: LnPaymentRequest!
  walletId: WalletId!
}

input LnNoAmountUsdInvoicePaymentInput {
  """Amount to pay in USD cents."""
  amount: FractionalCentAmount!

  """Optional memo to associate with the lightning invoice."""
  memo: Memo

  """Payment request representing the invoice which is being paid."""
  paymentRequest: LnPaymentRequest!

  """
  Wallet ID with sufficient balance to cover amount defined in mutation request.
   Must belong to the account of the current user.
  """
  walletId: WalletId!
}

scalar LnPaymentPreImage

"""BOLT11 lightning invoice payment request with the amount included"""
scalar LnPaymentRequest

scalar LnPaymentSecret

type LnUpdate {
  paymentHash: PaymentHash!
  status: InvoicePaymentStatus!
  walletId: WalletId!
}

"""
A bech32-encoded HTTPS/Onion URL that can be interacted with automatically by a
WALLET in a standard way such that a SERVICE can provide extra services or a
better experience for the user. Ref:
https://github.com/lnurl/luds/blob/luds/01.md 
"""
scalar Lnurl

input LnurlPaymentSendInput {
  """Amount to spend from the USD/USDT wallet, in USD cents."""
  amount: FractionalCentAmount!

  """LNURL-pay value to decode and pay."""
  lnurl: Lnurl!

  """Optional memo for the Lightning payment."""
  memo: Memo

  """Wallet ID with sufficient balance. Must belong to the current user."""
  walletId: WalletId!
}

input LnUsdInvoiceCreateInput {
  """Amount in USD cents."""
  amount: FractionalCentAmount!

  """Optional invoice expiration time in minutes."""
  expiresIn: Minutes

  """Optional memo for the lightning invoice."""
  memo: Memo

  """Wallet ID for a USD wallet belonging to the current user."""
  walletId: WalletId!
}

input LnUsdInvoiceCreateOnBehalfOfRecipientInput {
  """Amount in USD cents."""
  amount: FractionalCentAmount!
  descriptionHash: Hex32Bytes

  """Optional invoice expiration time in minutes."""
  expiresIn: Minutes

  """
  Optional memo for the lightning invoice. Acts as a note to the recipient.
  """
  memo: Memo

  """Wallet ID for a USD wallet which belongs to the account of any user."""
  recipientWalletId: WalletId!
}

input LnUsdInvoiceFeeProbeInput {
  paymentRequest: LnPaymentRequest!
  walletId: WalletId!
}

type MapInfo {
  coordinates: Coordinates!
  title: String!
}

type MapMarker {
  mapInfo: MapInfo!
  username: Username
}

"""Text field in a lightning payment transaction"""
scalar Memo

type Merchant {
  """
  GPS coordinates for the merchant that can be used to place the related business on a map
  """
  coordinates: Coordinates!
  createdAt: Timestamp!
  id: ID!
  title: String!

  """The username of the merchant"""
  username: Username!

  """Whether the merchant has been validated"""
  validated: Boolean!
}

input MerchantMapSuggestInput {
  latitude: Float!
  longitude: Float!
  title: String!
  username: Username!
}

type MerchantPayload {
  errors: [Error!]!
  merchant: Merchant
}

"""(Positive) amount of minutes"""
scalar Minutes

type MobileVersions {
  currentSupported: Int!
  minSupported: Int!
  platform: String!
}

type Mutation {
  accountCapabilityUpgradeRequest(input: AccountCapabilityUpgradeRequestInput!): AccountCapabilityUpgradeRequestPayload!
  accountDelete: AccountDeletePayload!
  accountDisableNotificationCategory(input: AccountDisableNotificationCategoryInput!): AccountUpdateNotificationSettingsPayload!
  accountDisableNotificationChannel(input: AccountDisableNotificationChannelInput!): AccountUpdateNotificationSettingsPayload!
  accountEnableNotificationCategory(input: AccountEnableNotificationCategoryInput!): AccountUpdateNotificationSettingsPayload!
  accountEnableNotificationChannel(input: AccountEnableNotificationChannelInput!): AccountUpdateNotificationSettingsPayload!
  accountUpdateDefaultWalletId(input: AccountUpdateDefaultWalletIdInput!): AccountUpdateDefaultWalletIdPayload!
  accountUpdateDisplayCurrency(input: AccountUpdateDisplayCurrencyInput!): AccountUpdateDisplayCurrencyPayload!

  """
  Generate a new API key for external service authentication. The raw key is only shown once and cannot be retrieved later.
  """
  apiKeyCreate(input: ApiKeyCreateInput!): ApiKeyCreatePayload!

  """
  Revoke an API key. Verification stops honoring it immediately; this cannot be undone.
  """
  apiKeyRevoke(input: ApiKeyRevokeInput!): ApiKeyRevokePayload!

  """
  Rotate an API key: a replacement with a new secret (and keyId) is created with
  the same name, scopes, and expiry, and the old key is revoked. The new raw key
  is only shown once.
  """
  apiKeyRotate(input: ApiKeyRotateInput!): ApiKeyRotatePayload!
  bankAccountUpdateRequest(input: BankAccountUpdateRequestInput!): BankAccountUpdateRequestPayload!
  bridgeAddExternalAccount: BridgeAddExternalAccountPayload!
  bridgeCancelWithdrawalRequest(input: BridgeCancelWithdrawalRequestInput!): BridgeCancelWithdrawalRequestPayload!
  bridgeCreateExternalAccount(input: BridgeCreateExternalAccountInput!): BridgeCreateExternalAccountPayload!
  bridgeCreateVirtualAccount: BridgeCreateVirtualAccountPayload!
  bridgeDeleteExternalAccount(input: BridgeDeleteExternalAccountInput!): BridgeDeleteExternalAccountPayload!
  bridgeExchangePlaidPublicToken(input: BridgeExchangePlaidPublicTokenInput!): BridgeExchangePlaidPublicTokenPayload!
  bridgeInitiateKyc(input: BridgeInitiateKycInput!): BridgeInitiateKycPayload!
  bridgeInitiateWithdrawal(input: BridgeInitiateWithdrawalInput!): BridgeInitiateWithdrawalPayload!
  bridgeRequestWithdrawal(input: BridgeRequestWithdrawalInput!): BridgeRequestWithdrawalPayload!
  bridgeSetDefaultExternalAccount(input: BridgeSetDefaultExternalAccountInput!): BridgeSetDefaultExternalAccountPayload!
  businessAccountUpgradeRequest(input: BusinessAccountUpgradeRequestInput!): AccountUpgradePayload!
  callbackEndpointAdd(input: CallbackEndpointAddInput!): CallbackEndpointAddPayload!
  callbackEndpointDelete(input: CallbackEndpointDeleteInput!): SuccessPayload!
  captchaCreateChallenge: CaptchaCreateChallengePayload!
  captchaRequestAuthCode(input: CaptchaRequestAuthCodeInput!): SuccessPayload!
  createInvite(input: CreateInviteInput!): CreateInvitePayload!
  deviceNotificationTokenCreate(input: DeviceNotificationTokenCreateInput!): SuccessPayload!
  feedbackSubmit(input: FeedbackSubmitInput!): SuccessPayload!
  fygaroCheckoutCreate(input: FygaroCheckoutCreateInput!): FygaroCheckoutCreatePayload!
  idDocumentUploadUrlGenerate(input: IdDocumentUploadUrlGenerateInput!): IdDocumentUploadUrlPayload!

  """
  Start the Cashout process; 
  User sends USD to Flash via Ibex and receives USD or JMD to bank account.
  """
  initiateCashout(input: InitiateCashoutInput!): InitiatedCashoutResponse!

  """
  Actions a payment which is internal to the ledger e.g. it does
  not use onchain/lightning. Returns payment status (success,
  failed, pending, already_paid).
  """
  intraLedgerPaymentSend(input: IntraLedgerPaymentSendInput!): PaymentSendPayload!

  """
  Galoy: Actions a payment which is internal to the ledger e.g. it does
  not use onchain/lightning. Returns payment status (success,
  failed, pending, already_paid).
  
  Flash: We do not currently have an internal ledger. Consequently, intraledger
  payments have been updated to call Ibex instead.
  """
  intraLedgerUsdPaymentSend(input: IntraLedgerUsdPaymentSendInput!): PaymentSendPayload!

  """
  Returns a lightning invoice for an associated wallet.
  When invoice is paid the value will be credited to a BTC wallet.
  Expires after 'expiresIn' or 24 hours.
  """
  lnInvoiceCreate(input: LnInvoiceCreateInput!): LnInvoicePayload!

  """
  Returns a lightning invoice for an associated wallet.
  When invoice is paid the value will be credited to a BTC wallet.
  Expires after 'expiresIn' or 24 hours.
  """
  lnInvoiceCreateOnBehalfOfRecipient(input: LnInvoiceCreateOnBehalfOfRecipientInput!): LnInvoicePayload!
  lnInvoiceFeeProbe(input: LnInvoiceFeeProbeInput!): SatAmountPayload!

  """
  Pay a lightning invoice using a balance from a wallet which is owned by the account of the current user.
  Provided wallet can be USD or BTC and must have sufficient balance to cover amount in lightning invoice.
  Returns payment status (success, failed, pending, already_paid).
  """
  lnInvoicePaymentSend(input: LnInvoicePaymentInput!): PaymentSendPayload!

  """
  Returns a lightning invoice for an associated wallet.
  Can be used to receive any supported currency value (currently USD or BTC).
  Expires after 'expiresIn' or 24 hours for BTC invoices or 5 minutes for USD invoices.
  """
  lnNoAmountInvoiceCreate(input: LnNoAmountInvoiceCreateInput!): LnNoAmountInvoicePayload!

  """
  Returns a lightning invoice for an associated wallet.
  Can be used to receive any supported currency value (currently USD or BTC).
  Expires after 'expiresIn' or 24 hours for BTC invoices or 5 minutes for USD invoices.
  """
  lnNoAmountInvoiceCreateOnBehalfOfRecipient(input: LnNoAmountInvoiceCreateOnBehalfOfRecipientInput!): LnNoAmountInvoicePayload!
  lnNoAmountInvoiceFeeProbe(input: LnNoAmountInvoiceFeeProbeInput!): SatAmountPayload!

  """
  Pay a lightning invoice using a balance from a wallet which is owned by the account of the current user.
  Provided wallet must be BTC and must have sufficient balance to cover amount specified in mutation request.
  Returns payment status (success, failed, pending, already_paid).
  """
  lnNoAmountInvoicePaymentSend(input: LnNoAmountInvoicePaymentInput!): PaymentSendPayload!
  lnNoAmountUsdInvoiceFeeProbe(input: LnNoAmountUsdInvoiceFeeProbeInput!): CentAmountPayload!

  """
  Pay a lightning invoice using a balance from a wallet which is owned by the account of the current user.
  Provided wallet must be USD and have sufficient balance to cover amount specified in mutation request.
  Returns payment status (success, failed, pending, already_paid).
  """
  lnNoAmountUsdInvoicePaymentSend(input: LnNoAmountUsdInvoicePaymentInput!): PaymentSendPayload!

  """
  Returns a lightning invoice denominated in satoshis for an associated wallet.
  When invoice is paid the equivalent value at invoice creation will be credited to a USD wallet.
  Expires after 'expiresIn' or 5 minutes (short expiry time because there is a USD/BTC exchange rate
  associated with the amount).
  """
  lnUsdInvoiceCreate(input: LnUsdInvoiceCreateInput!): LnInvoicePayload!

  """
  Returns a lightning invoice denominated in satoshis for an associated wallet.
  When invoice is paid the equivalent value at invoice creation will be credited to a USD wallet.
  Expires after 'expiresIn' or 5 minutes (short expiry time because there is a USD/BTC exchange rate
    associated with the amount).
  """
  lnUsdInvoiceCreateOnBehalfOfRecipient(input: LnUsdInvoiceCreateOnBehalfOfRecipientInput!): LnInvoicePayload!
  lnUsdInvoiceFeeProbe(input: LnUsdInvoiceFeeProbeInput!): CentAmountPayload!

  """
  Pay a LNURL-pay endpoint using a USD/USDT wallet balance.
  The wallet amount is converted to whole-satoshi millisatoshis before calling IBEX.
  """
  lnurlPaymentSend(input: LnurlPaymentSendInput!): PaymentSendPayload!
  merchantMapSuggest(input: MerchantMapSuggestInput!): MerchantPayload!
  onChainAddressCreate(input: OnChainAddressCreateInput!): OnChainAddressPayload!
  onChainAddressCurrent(input: OnChainAddressCurrentInput!): OnChainAddressPayload!
  onChainPaymentSend(input: OnChainPaymentSendInput!): PaymentSendPayload!
  onChainPaymentSendAll(input: OnChainPaymentSendAllInput!): PaymentSendPayload!
  onChainUsdPaymentSend(input: OnChainUsdPaymentSendInput!): PaymentSendPayload!
  onChainUsdPaymentSendAsBtcDenominated(input: OnChainUsdPaymentSendAsBtcDenominatedInput!): PaymentSendPayload!
  quizCompleted(input: QuizCompletedInput!): QuizCompletedPayload!
  redeemInvite(input: RedeemInviteInput!): RedeemInvitePayload!

  """
  Returns an offer from Flash for a user to withdraw from their USD wallet (denominated in cents).
  The user can review this offer and then execute the withdrawal by calling the initiateCashout mutation.
  """
  requestCashout(input: RequestCashoutInput!): RequestCashoutResponse!
  updateExternalWallet(input: UpdateExternalWalletInput!): UpdateExternalWalletPayload!
  userContactUpdateAlias(input: UserContactUpdateAliasInput!): UserContactUpdateAliasPayload! @deprecated(reason: "will be moved to AccountContact")
  userEmailDelete: UserEmailDeletePayload!
  userEmailRegistrationInitiate(input: UserEmailRegistrationInitiateInput!): UserEmailRegistrationInitiatePayload!
  userEmailRegistrationValidate(input: UserEmailRegistrationValidateInput!): UserEmailRegistrationValidatePayload!
  userLogin(input: UserLoginInput!): AuthTokenPayload!
  userLoginUpgrade(input: UserLoginUpgradeInput!): UpgradePayload!
  userLogout(input: UserLogoutInput): SuccessPayload!
  userPhoneDelete: UserPhoneDeletePayload!
  userPhoneRegistrationInitiate(input: UserPhoneRegistrationInitiateInput!): SuccessPayload!
  userPhoneRegistrationValidate(input: UserPhoneRegistrationValidateInput!): UserPhoneRegistrationValidatePayload!
  userQuizQuestionUpdateCompleted(input: UserQuizQuestionUpdateCompletedInput!): UserQuizQuestionUpdateCompletedPayload! @deprecated(reason: "Use QuizCompletedMutation instead")
  userTotpDelete(input: UserTotpDeleteInput!): UserTotpDeletePayload!
  userTotpRegistrationInitiate(input: UserTotpRegistrationInitiateInput!): UserTotpRegistrationInitiatePayload!
  userTotpRegistrationValidate(input: UserTotpRegistrationValidateInput!): UserTotpRegistrationValidatePayload!
  userUpdateLanguage(input: UserUpdateLanguageInput!): UserUpdateLanguagePayload!
  userUpdateNpub(input: UserUpdateNpubInput!): UserUpdateNpubPayload!
  userUpdateUsername(input: UserUpdateUsernameInput!): UserUpdateUsernamePayload! @deprecated(reason: "Username will be moved to @Handle in Accounts. Also SetUsername naming should be used instead of UpdateUsername to reflect the idempotency of Handles")
}

type MyReferralInvite {
  contact: String!
  createdAt: String!
  id: ID!
  method: InviteMethod!
  myRewardCents: Int
  redeemedAt: String
  rewardPending: Boolean!
  status: InviteStatus!
}

type MyReferrals {
  acceptedCount: Int!
  invites: [MyReferralInvite!]!
  pendingRewardCount: Int!
  totalEarnedCents: Int!
  totalInvites: Int!
}

type MyUpdatesPayload {
  errors: [Error!]!
  me: User
  update: UserUpdate
}

enum Network {
  mainnet
  regtest
  signet
  testnet
}

scalar NotificationCategory

enum NotificationChannel {
  PUSH
}

type NotificationChannelSettings {
  disabledCategories: [NotificationCategory!]!
  enabled: Boolean!
}

type NotificationSettings {
  push: NotificationChannelSettings!
}

"""Nostr Identity public key"""
scalar npub

type npubByUsername {
  """Nostr public key"""
  npub: npub

  """Optional immutable user friendly identifier."""
  username: Username
}

"""An address for an on-chain bitcoin destination"""
scalar OnChainAddress

input OnChainAddressCreateInput {
  walletId: WalletId!
}

input OnChainAddressCurrentInput {
  walletId: WalletId!
}

type OnChainAddressPayload {
  address: OnChainAddress
  errors: [Error!]!
}

input OnChainPaymentSendAllInput {
  address: OnChainAddress!
  memo: Memo
  speed: PayoutSpeed = FAST
  walletId: WalletId!
}

input OnChainPaymentSendInput {
  address: OnChainAddress!
  amount: SatAmount!
  memo: Memo
  speed: PayoutSpeed = FAST
  walletId: WalletId!
}

type OnChainTxFee {
  amount: SatAmount!
}

scalar OnChainTxHash

type OnChainUpdate {
  amount: SatAmount!
  displayCurrencyPerSat: Float!
  txHash: OnChainTxHash!
  txNotificationType: TxNotificationType!
  usdPerSat: Float! @deprecated(reason: "updated over displayCurrencyPerSat")
  walletId: WalletId!
}

input OnChainUsdPaymentSendAsBtcDenominatedInput {
  address: OnChainAddress!
  amount: SatAmount!
  memo: Memo
  speed: PayoutSpeed = FAST
  walletId: WalletId!
}

input OnChainUsdPaymentSendInput {
  address: OnChainAddress!
  amount: FractionalCentAmount!
  memo: Memo
  speed: PayoutSpeed = FAST
  walletId: WalletId!
}

type OnChainUsdTxFee {
  amount: FractionalCentAmount!
}

type OneDayAccountLimit implements AccountLimit {
  """
  The rolling time interval value in seconds for the current 24 hour period.
  """
  interval: Seconds

  """
  The amount of cents remaining below the limit for the current 24 hour period.
  """
  remainingLimit: CentAmount

  """The current maximum limit for a given 24 hour period."""
  totalLimit: CentAmount!
}

"""An authentication code valid for a single use"""
scalar OneTimeAuthCode

"""Information about pagination in a connection."""
type PageInfo {
  """When paginating forwards, the cursor to continue."""
  endCursor: String

  """When paginating forwards, are there more items?"""
  hasNextPage: Boolean!

  """When paginating backwards, are there more items?"""
  hasPreviousPage: Boolean!

  """When paginating backwards, the cursor to continue."""
  startCursor: String
}

scalar PaymentHash

type PaymentSendPayload {
  errors: [Error!]!
  status: PaymentSendResult
}

enum PaymentSendResult {
  ALREADY_PAID
  FAILURE
  PENDING
  SUCCESS
}

enum PayoutSpeed {
  FAST
}

"""Phone number which includes country code"""
scalar Phone

enum PhoneCodeChannelType {
  SMS
  WHATSAPP
}

"""
Price amount expressed in base/offset. To calculate, use: `base / 10^offset`
"""
type Price {
  base: SafeInt!
  currencyUnit: String!
  formattedAmount: String!
  offset: Int!
}

"""The range for the X axis in the BTC price graph"""
enum PriceGraphRange {
  FIVE_YEARS
  ONE_DAY
  ONE_MONTH
  ONE_WEEK
  ONE_YEAR
}

input PriceInput {
  amount: SatAmount!
  amountCurrencyUnit: ExchangeCurrencyUnit!
  priceCurrencyUnit: ExchangeCurrencyUnit!
}

interface PriceInterface {
  base: SafeInt!
  currencyUnit: String! @deprecated(reason: "Deprecated due to type renaming")
  offset: Int!
}

"""Price of 1 sat in base/offset. To calculate, use: `base / 10^offset`"""
type PriceOfOneSatInMinorUnit implements PriceInterface {
  base: SafeInt!
  currencyUnit: String! @deprecated(reason: "Deprecated due to type renaming")
  offset: Int!
}

"""
Price of 1 sat or 1 usd cent in base/offset. To calculate, use: `base / 10^offset`
"""
type PriceOfOneSettlementMinorUnitInDisplayMinorUnit implements PriceInterface {
  base: SafeInt!
  currencyUnit: String! @deprecated(reason: "Deprecated due to type renaming")
  formattedAmount: String! @deprecated(reason: "Deprecated please use `base / 10^offset`")
  offset: Int!
}

"""
Price of 1 usd cent in base/offset. To calculate, use: `base / 10^offset`
"""
type PriceOfOneUsdCentInMinorUnit implements PriceInterface {
  base: SafeInt!
  currencyUnit: String! @deprecated(reason: "Deprecated due to type renaming")
  offset: Int!
}

type PricePayload {
  errors: [Error!]!
  price: Price
}

type PricePoint {
  price: Price!

  """
  Unix timestamp (number of seconds elapsed since January 1, 1970 00:00:00 UTC)
  """
  timestamp: Timestamp!
}

"""
A public view of a generic wallet which stores value in one of our supported currencies.
"""
type PublicWallet {
  id: ID!
  lnurlp: Lnurl
  walletCurrency: WalletCurrency!
}

type Query {
  accountDefaultWallet(username: Username!, walletCurrency: WalletCurrency): PublicWallet!

  """
  All API keys for the calling account, newest first. Never includes secret material.
  """
  apiKeys: [ApiKey!]!
  bridgeExternalAccounts: [BridgeExternalAccount]
  bridgeKycStatus: String
  bridgeVirtualAccount: BridgeVirtualAccount
  bridgeWithdrawalRequest(id: ID!): BridgeWithdrawal
  bridgeWithdrawals: [BridgeWithdrawal]
  btcPrice(currency: DisplayCurrency! = "USD"): Price @deprecated(reason: "Deprecated in favor of realtimePrice")
  btcPriceList(range: PriceGraphRange!): [PricePoint]
  businessMapMarkers: [MapMarker!]!
  cashWalletCutover: CashWalletCutover!
  cashoutRate: CashoutRate!
  currencyList: [Currency!]!
  globals: Globals
  invitePreview(token: String!): InvitePreview
  isFlashNpub(input: IsFlashNpubInput!): IsFlashNpubPayload
  latestAccountUpgradeRequest: AccountUpgradeRequestPayload!
  lnInvoicePaymentStatus(input: LnInvoicePaymentStatusInput!): LnInvoicePaymentStatusPayload!
  me: User
  mobileVersions: [MobileVersions]
  myReferrals(afterId: ID, first: Int): MyReferrals!
  npubByUsername(username: Username!): npubByUsername
  onChainTxFee(address: OnChainAddress!, amount: SatAmount!, speed: PayoutSpeed = FAST, walletId: WalletId!): OnChainTxFee!
  onChainUsdTxFee(address: OnChainAddress!, amount: FractionalCentAmount!, speed: PayoutSpeed = FAST, walletId: WalletId!): OnChainUsdTxFee!
  onChainUsdTxFeeAsBtcDenominated(address: OnChainAddress!, amount: SatAmount!, speed: PayoutSpeed = FAST, walletId: WalletId!): OnChainUsdTxFee!
  quizQuestions: [QuizQuestion] @deprecated(reason: "TODO: remove. we don't need a non authenticated version of this query. the users can only do the query while authenticated")

  """Returns 1 Sat and 1 Usd Cent price for the given currency"""
  realtimePrice(currency: DisplayCurrency = "USD"): RealtimePrice!
  supportedBanks: [Bank!]!
  transactionDetails(input: TransactionDetailsInput!): TransactionDetailsPayload!
  userDefaultWalletId(username: Username!): WalletId! @deprecated(reason: "will be migrated to AccountDefaultWalletId")
  usernameAvailable(username: Username!): Boolean
}

type Quiz {
  """The reward in Satoshis for the quiz question"""
  amount: SatAmount!
  completed: Boolean!
  id: ID!
}

input QuizCompletedInput {
  id: ID!
}

type QuizCompletedPayload {
  errors: [Error!]!
  quiz: Quiz
}

type QuizQuestion {
  """The earn reward in Satoshis for the quiz question"""
  earnAmount: SatAmount!
  id: ID!
}

type RealtimePrice {
  btcSatPrice: PriceOfOneSatInMinorUnit!
  denominatorCurrency: DisplayCurrency!
  id: ID!

  """
  Unix timestamp (number of seconds elapsed since January 1, 1970 00:00:00 UTC)
  """
  timestamp: Timestamp!
  usdCentPrice: PriceOfOneUsdCentInMinorUnit!
}

input RealtimePriceInput {
  currency: DisplayCurrency = "USD"
}

type RealtimePricePayload {
  errors: [Error!]!
  realtimePrice: RealtimePrice
}

input RedeemInviteInput {
  token: String!
}

type RedeemInvitePayload {
  errors: [String!]!
  success: Boolean!
}

input RequestCashoutInput {
  """Amount in USD cents."""
  amount: USDCents!

  """ERPNext bank account identifier to receive the cashout."""
  bankAccountId: ID!

  """ID for a USD wallet belonging to the current user."""
  walletId: WalletId!
}

type RequestCashoutResponse {
  errors: [Error!]!
  offer: CashoutOffer
}

"""
Non-fractional signed whole numeric value between -(2^53) + 1 and 2^53 - 1
"""
scalar SafeInt

"""(Positive) Satoshi amount"""
scalar SatAmount

type SatAmountPayload {
  amount: SatAmount
  errors: [Error!]!
}

"""(Positive) amount of seconds"""
scalar Seconds

union SettlementVia = SettlementViaIntraLedger | SettlementViaLn | SettlementViaOnChain

type SettlementViaIntraLedger {
  """
  Settlement destination: Could be null if the payee does not have a username
  """
  counterPartyUsername: Username
  counterPartyWalletId: WalletId
}

type SettlementViaLn {
  paymentSecret: LnPaymentSecret @deprecated(reason: "Shifting property to 'preImage' to improve granularity of the LnPaymentSecret type")
  preImage: LnPaymentPreImage
}

type SettlementViaOnChain {
  transactionHash: OnChainTxHash
  vout: Int
}

"""An amount (of a currency) that can be negative (e.g. in a transaction)"""
scalar SignedAmount

"""
A string amount (of a currency) that can be negative (e.g. in a transaction)
"""
scalar SignedDisplayMajorAmount

type Subscription {
  lnInvoicePaymentStatus(input: LnInvoicePaymentStatusInput!): LnInvoicePaymentStatusPayload!
  myUpdates: MyUpdatesPayload!
  price(input: PriceInput!): PricePayload!

  """Returns the price of 1 satoshi"""
  realtimePrice(input: RealtimePriceInput!): RealtimePricePayload!
}

type SuccessPayload {
  errors: [Error!]!
  success: Boolean
}

"""
Timestamp field, serialized as Unix time (the number of seconds since the Unix epoch)
"""
scalar Timestamp

"""A time-based one-time password"""
scalar TotpCode

"""An id to be passed between set and verify for confirming totp"""
scalar TotpRegistrationId

"""A secret to generate time-based one-time password"""
scalar TotpSecret

"""
Give details about an individual transaction.
Galoy have a smart routing system which is automatically
settling intraledger when both the payer and payee use the same wallet
therefore it's possible the transactions is being initiated onchain
or with lightning but settled intraledger.
"""
type Transaction {
  createdAt: Timestamp!
  direction: TxDirection!
  id: ID!

  """From which protocol the payment has been initiated."""
  initiationVia: InitiationVia!
  memo: Memo

  """Amount of the settlement currency sent or received."""
  settlementAmount: SignedAmount!

  """Wallet currency for transaction."""
  settlementCurrency: WalletCurrency!
  settlementDisplayAmount: SignedDisplayMajorAmount!
  settlementDisplayCurrency: DisplayCurrency!
  settlementDisplayFee: SignedDisplayMajorAmount!
  settlementFee: SignedAmount!

  """Price in WALLETCURRENCY/SETTLEMENTUNIT at time of settlement."""
  settlementPrice: PriceOfOneSettlementMinorUnitInDisplayMinorUnit!

  """To which protocol the payment has settled on."""
  settlementVia: SettlementVia!
  status: TxStatus!
}

"""A connection to a list of items."""
type TransactionConnection {
  """A list of edges."""
  edges: [TransactionEdge!]

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type TransactionDetails {
  """Account ID associated with the transaction"""
  accountId: String

  """Bitcoin address for onchain transactions"""
  address: String

  """Transaction amount"""
  amount: Float

  """Number of confirmations for onchain transactions"""
  confirmations: Int

  """Transaction creation timestamp"""
  createdAt: String

  """Transaction currency"""
  currency: String

  """Transaction fee"""
  fee: Float

  """Transaction ID"""
  id: String!

  """Lightning invoice (bolt11)"""
  invoice: String

  """Transaction memo/description"""
  memo: String

  """Lightning payment hash"""
  paymentHash: String

  """Lightning payment preimage"""
  paymentPreimage: String

  """Transaction status"""
  status: String

  """Bitcoin transaction ID for onchain transactions"""
  txid: String

  """Transaction type (lightning/onchain)"""
  type: String

  """Transaction last update timestamp"""
  updatedAt: String

  """Output index for onchain transactions"""
  vout: Int
}

type TransactionDetailsError {
  message: String!
}

input TransactionDetailsInput {
  """Transaction ID to fetch details for"""
  transactionId: String!
}

type TransactionDetailsPayload {
  errors: [TransactionDetailsError!]!
  transactionDetails: TransactionDetails
}

"""An edge in a connection."""
type TransactionEdge {
  """A cursor for use in pagination"""
  cursor: String!

  """The item at the end of the edge"""
  node: Transaction!
}

enum TxDirection {
  RECEIVE
  SEND
}

enum TxNotificationType {
  IntraLedgerPayment
  IntraLedgerReceipt
  LnInvoicePaid
  OnchainPayment
  OnchainReceipt
  OnchainReceiptPending
}

enum TxStatus {
  FAILURE
  PENDING
  SUCCESS
}

input UpdateExternalWalletInput {
  lnurlp: Lnurl!
}

type UpdateExternalWalletPayload {
  errors: [Error!]!
  walletId: WalletId
}

type UpgradePayload {
  authToken: AuthToken
  errors: [Error!]!
  success: Boolean!
}

"""Amount in USD cents"""
scalar USDCents

"""
A wallet belonging to an account which contains a USDT balance and a list of transactions.
"""
type UsdtWallet implements Wallet {
  accountId: ID!
  balance: FractionalCentAmount
  id: ID!
  isExternal: Boolean!
  lnurlp: Lnurl

  """An unconfirmed incoming onchain balance."""
  pendingIncomingBalance: SignedAmount!
  transactions(
    """Returns the items in the list that come after the specified cursor."""
    after: String

    """Returns the items in the list that come before the specified cursor."""
    before: String

    """Returns the first n items from the list."""
    first: Int

    """Returns the last n items from the list."""
    last: Int
  ): TransactionConnection
  transactionsByAddress(
    """Returns the items that include this address."""
    address: OnChainAddress!

    """Returns the items in the list that come after the specified cursor."""
    after: String

    """Returns the items in the list that come before the specified cursor."""
    before: String

    """Returns the first n items from the list."""
    first: Int

    """Returns the last n items from the list."""
    last: Int
  ): TransactionConnection
  walletCurrency: WalletCurrency!
}

"""
A wallet belonging to an account which contains a USD balance and a list of transactions.
"""
type UsdWallet implements Wallet {
  accountId: ID!
  balance: FractionalCentAmount
  id: ID!
  isExternal: Boolean!
  lnurlp: Lnurl

  """An unconfirmed incoming onchain balance."""
  pendingIncomingBalance: SignedAmount!
  transactions(
    """Returns the items in the list that come after the specified cursor."""
    after: String

    """Returns the items in the list that come before the specified cursor."""
    before: String

    """Returns the first n items from the list."""
    first: Int

    """Returns the last n items from the list."""
    last: Int
  ): TransactionConnection
  transactionsByAddress(
    """Returns the items that include this address."""
    address: OnChainAddress!

    """Returns the items in the list that come after the specified cursor."""
    after: String

    """Returns the items in the list that come before the specified cursor."""
    before: String

    """Returns the first n items from the list."""
    first: Int

    """Returns the last n items from the list."""
    last: Int
  ): TransactionConnection
  walletCurrency: WalletCurrency!
}

type User {
  """Bank accounts available for cashout"""
  bankAccounts: [BankAccount!]!

  """
  Get single contact details.
  Can include the transactions associated with the contact.
  """
  contactByUsername(username: Username!): UserContact! @deprecated(reason: "will be moved to Accounts")

  """
  Get full list of contacts.
  Can include the transactions associated with each contact.
  """
  contacts: [UserContact!]! @deprecated(reason: "will be moved to account")
  createdAt: Timestamp!
  defaultAccount: Account!

  """Email address"""
  email: Email
  id: ID!

  """
  Preferred language for user.
  When value is 'default' the intent is to use preferred language from OS settings.
  """
  language: Language!

  """Nostr public key"""
  npub: npub

  """Phone number with international calling code."""
  phone: Phone

  """List the quiz questions the user may have completed."""
  quizQuestions: [UserQuizQuestion!]! @deprecated(reason: "use Quiz from Account instead")

  """Whether TOTP is enabled for this user."""
  totpEnabled: Boolean!

  """Optional immutable user friendly identifier."""
  username: Username @deprecated(reason: "will be moved to @Handle in Account and Wallet")
}

type UserContact {
  """
  Alias the user can set for this contact.
  Only the user can see the alias attached to their contact.
  """
  alias: ContactAlias
  id: Username!

  """Paginated list of transactions sent to/from this contact."""
  transactions(
    """Returns the items in the list that come after the specified cursor."""
    after: String

    """Returns the items in the list that come before the specified cursor."""
    before: String

    """Returns the first n items from the list."""
    first: Int

    """Returns the last n items from the list."""
    last: Int
  ): TransactionConnection
  transactionsCount: Int!

  """Actual identifier of the contact."""
  username: Username!
}

input UserContactUpdateAliasInput {
  alias: ContactAlias!
  username: Username!
}

type UserContactUpdateAliasPayload {
  contact: UserContact
  errors: [Error!]!
}

type UserEmailDeletePayload {
  errors: [Error!]!
  me: User
}

input UserEmailRegistrationInitiateInput {
  email: EmailAddress!
}

type UserEmailRegistrationInitiatePayload {
  emailRegistrationId: EmailRegistrationId
  errors: [Error!]!
  me: User
}

input UserEmailRegistrationValidateInput {
  code: OneTimeAuthCode!
  emailRegistrationId: EmailRegistrationId!
}

type UserEmailRegistrationValidatePayload {
  errors: [Error!]!
  me: User
}

input UserLoginInput {
  code: OneTimeAuthCode!
  phone: Phone!
}

input UserLoginUpgradeInput {
  code: OneTimeAuthCode!
  phone: Phone!
}

input UserLogoutInput {
  deviceToken: String!
}

"""Unique identifier of a user"""
scalar Username

type UserPhoneDeletePayload {
  errors: [Error!]!
  me: User
}

input UserPhoneRegistrationInitiateInput {
  channel: PhoneCodeChannelType
  phone: Phone!
}

input UserPhoneRegistrationValidateInput {
  code: OneTimeAuthCode!
  phone: Phone!
}

type UserPhoneRegistrationValidatePayload {
  errors: [Error!]!
  me: User
}

type UserQuizQuestion {
  completed: Boolean!
  question: QuizQuestion!
}

input UserQuizQuestionUpdateCompletedInput {
  id: ID!
}

type UserQuizQuestionUpdateCompletedPayload {
  errors: [Error!]!
  userQuizQuestion: UserQuizQuestion
}

input UserTotpDeleteInput {
  authToken: AuthToken!
}

type UserTotpDeletePayload {
  errors: [Error!]!
  me: User
}

input UserTotpRegistrationInitiateInput {
  authToken: AuthToken!
}

type UserTotpRegistrationInitiatePayload {
  errors: [Error!]!
  totpRegistrationId: TotpRegistrationId
  totpSecret: TotpSecret
}

input UserTotpRegistrationValidateInput {
  authToken: AuthToken!
  totpCode: TotpCode!
  totpRegistrationId: TotpRegistrationId!
}

type UserTotpRegistrationValidatePayload {
  errors: [Error!]!
  me: User
}

union UserUpdate = IntraLedgerUpdate | LnUpdate | OnChainUpdate | Price | RealtimePrice

input UserUpdateLanguageInput {
  language: Language!
}

type UserUpdateLanguagePayload {
  errors: [Error!]!
  user: User
}

input UserUpdateNpubInput {
  npub: npub!
}

type UserUpdateNpubPayload {
  errors: [Error!]!
  user: User
}

input UserUpdateUsernameInput {
  username: Username!
}

type UserUpdateUsernamePayload {
  errors: [Error!]!
  user: User
}

"""
A generic wallet which stores value in one of our supported currencies.
"""
interface Wallet {
  accountId: ID!
  balance: FractionalCentAmount
  id: ID!
  isExternal: Boolean!
  lnurlp: Lnurl
  pendingIncomingBalance: SignedAmount!

  """
  Transactions are ordered anti-chronologically,
  ie: the newest transaction will be first
  """
  transactions(
    """Returns the items in the list that come after the specified cursor."""
    after: String

    """Returns the items in the list that come before the specified cursor."""
    before: String

    """Returns the first n items from the list."""
    first: Int

    """Returns the last n items from the list."""
    last: Int
  ): TransactionConnection

  """
  Transactions are ordered anti-chronologically,
  ie: the newest transaction will be first
  """
  transactionsByAddress(
    """Returns the items that include this address."""
    address: OnChainAddress!

    """Returns the items in the list that come after the specified cursor."""
    after: String

    """Returns the items in the list that come before the specified cursor."""
    before: String

    """Returns the first n items from the list."""
    first: Int

    """Returns the last n items from the list."""
    last: Int
  ): TransactionConnection
  walletCurrency: WalletCurrency!
}

enum WalletCurrency {
  BTC
  USD
  USDT
}

"""Unique identifier of a wallet"""
scalar WalletId