schema.graphql

# source: https://payments.braintree-api.com/graphql
# timestamp: Thu Sep 03 2020 20:14:13 GMT+0000 (Coordinated Universal Time)

"""Top-level input fields for accepting a dispute."""
input AcceptDisputeInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The ID of the dispute to be accepted."""
  disputeId: ID!
}

"""Top-level field returned when accepting a dispute."""
type AcceptDisputePayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """Information about the dispute that was accepted."""
  dispute: Dispute
}

"""An OAuth access token."""
type AccessToken {
  """The access token."""
  accessToken: String

  """The refresh token for getting a new access token."""
  refreshToken: String

  """The type of token."""
  tokenType: OAuthTokenType

  """Expiration in ISO time format."""
  expiresAt: String
}

"""Top-level fields returned when obtaining an OAuth access token."""
type AccessTokenPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The access token."""
  accessToken: AccessToken
}

"""Information about the business's ACH configuration."""
input ACHConfigurationInput {
  """
  The ACH/NACHA company name. Included in the NACHA file to help identify the company.
  """
  companyName: String

  """
  This is included in the NACHA file to help identify the company's business
  type and will appear in the description section of a customer's bank
  statement. Examples: "Bill Pay", "Utility", etc.
  """
  entry: String!

  """
  Should ACH initiation be enabled? If true, any failed transaction will be retried.
  """
  reinitiation: Boolean!

  """
  Additional information that you would like to include on the customer's bank
  statement (e.g. phone number) for ACH transactions. Note: this is up to the
  customer's bank to display, as not all banks support this field.
  """
  softDescriptor: String
}

"""
A NACHA standard entry class (SEC) code, which designates how an ACH transaction was authorized.
"""
enum ACHStandardEntryClassCode {
  """Corporate credit or debit."""
  CCD

  """Prearranged payment and deposit."""
  PPD

  """Telephone-initiated."""
  TEL

  """Internet-initiated/mobile."""
  WEB
}

"""Representation of an address."""
type Address {
  """Company name."""
  company: String

  """The street address."""
  streetAddress: String

  """Extended address information, such as an apartment or suite number."""
  extendedAddress: String

  """First name."""
  firstName: String @deprecated(reason: "Use `fullName` instead.")

  """Last name."""
  lastName: String @deprecated(reason: "Use `fullName` instead.")

  """Full name."""
  fullName: String

  """Locality/city."""
  locality: String

  """State or province."""
  region: String

  """
  Postal code, otherwise known as CAP, CEP, Eircode, NPA, PIN, PLZ, or ZIP code.
  """
  postalCode: String

  """Country code for the address in ISO 3166-1 alpha-3 format."""
  countryCode: CountryCodeAlpha3
}

"""Input fields for an Address."""
input AddressInput {
  """Company name. 255 character maximum."""
  company: String

  """The street address. 255 character maximum."""
  streetAddress: String

  """
  Extended address information, such as an apartment or suite number. 255 character maximum.
  """
  extendedAddress: String

  """First name. 255 character maximum."""
  firstName: String

  """Last name. 255 character maximum."""
  lastName: String

  """Locality/city. 255 character maximum."""
  locality: String

  """State or province. 255 character maximum."""
  region: String

  """
  Postal code in any country's format, otherwise known as CAP, CEP, Eircode,
  NPA, PIN, PLZ, or ZIP code. Nine alphanumeric characters maximum, may also
  contain spaces and hyphens.
  
  *Required for Level 3 processing*.
  """
  postalCode: String

  """
  Country code for the address in ISO 3166-1 alpha-3 format.
  
  *Required for Level 3 processing*.
  """
  countryCode: CountryCodeAlpha3

  """
  Deprecated: This field is included for supporting legacy clients. Please use `countryCode` instead.
  
  Country code for the address in ISO 3166-1 alpha-3 format.
  """
  countryCodeAlpha3: String

  """
  Deprecated: This field is included for supporting legacy clients. Please use `countryCode` instead.
  
  Country code for the address in ISO 3166-1 alpha-2 format.
  """
  countryCodeAlpha2: String

  """
  Deprecated: This field is included for supporting legacy clients. Please use `countryCode` instead.
  
  Country code for the address in ISO 3166-1 numeric format.
  """
  countryCodeNumeric: String

  """
  Deprecated: This field is included for supporting legacy clients. Please use `countryCode` instead.
  
  Country name for the address.
  """
  countryName: String
}

"""Information about the business's relationship with American Express."""
input AmericanExpressRelationshipInput {
  """The business's American Express SE number."""
  serviceEstablishmentNumber: String!
}

"""
A monetary amount, either a whole number or a number with exactly two or three decimal places.
"""
scalar Amount

"""Configuration for Apple Pay on iOS."""
type ApplePayConfiguration {
  """The environment being used for Apple Pay."""
  status: ApplePayStatus

  """The merchant's Apple Pay country code."""
  countryCode: CountryCodeAlpha2

  """The merchant's Apple Pay currency ISO code."""
  currencyCode: CurrencyCodeAlpha

  """
  The merchant identifier that must be supplied when making an Apple Pay request.
  """
  merchantIdentifier: String

  """A list of card brands supported by the merchant for Apple Pay."""
  supportedCardBrands: [CreditCardBrandCode!]
}

"""Additional information about the payment method specific to Apple Pay."""
type ApplePayOriginDetails {
  """
  A human-readable description of the Apple Pay payment method. This usually
  consists of the Apple Pay card type and its last four digits. If there is no
  underlying credit card, this will describe the customer's payment method and
  the parent CreditCardDetail object's last4 field will be null.
  """
  paymentInstrumentName: String

  """
  The first 6 digits of the credit card, known as the Bank Identification
  Number. This BIN may differ from the BIN of the customer's actual card.
  """
  bin: String
}

"""The environment being used for Apple Pay."""
enum ApplePayStatus {
  MOCK
  OFF
  PRODUCTION
  mock
  off
  production
}

"""Configuration for Apple Pay on web."""
type ApplePayWebConfiguration {
  """The merchant's Apple Pay country code."""
  countryCode: CountryCodeAlpha2

  """The merchant's Apple Pay currency ISO code."""
  currencyCode: CurrencyCodeAlpha

  """
  The merchant identifier that must be supplied when making an Apple Pay request.
  """
  merchantIdentifier: String

  """A list of card brands supported by the merchant for Apple Pay."""
  supportedCardBrands: [CreditCardBrandCode!]
}

"""Input fields for a Merchant Account Application bank account object."""
input ApplicationBankAccountInput {
  """The routing number of the bank that holds the account."""
  routingNumber: UsBankRoutingNumber!

  """The account number of the bank account."""
  accountNumber: UsBankAccountNumber!

  """The type of transfer setup on the account."""
  transferType: ApplicationTransferType!

  """The type of account."""
  accountType: ApplicationBankAccountType!

  """The purpose of account."""
  accountPurpose: ApplicationBankAccountPurpose!
}

"""The purpose of the merchant application bank account."""
enum ApplicationBankAccountPurpose {
  CHECKING
  SAVINGS
}

"""The type of merchant application bank account."""
enum ApplicationBankAccountType {
  CORPORATION
  PARTNERSHIP
}

"""The status of a merchant account application."""
enum ApplicationStatus {
  APPROVED
  PROCESSING
  REJECTED
}

"""The type of transfer used for the bank account."""
enum ApplicationTransferType {
  BANK_ACCOUNT_USA
  BANK_ACCOUNT_WIRE_USA
}

"""
Information about the [customer authentication regulation environment](https://developers.braintreepayments.com/guides/3d-secure/migration/javascript/v3#authentication-insight)
that applies to the payment method when processed with the provided merchant account.
"""
type AuthenticationInsight {
  """The merchant account used to determine authentication insight."""
  merchantAccountId: String

  """
  The customer authentication regulation environment that applies when
  transacting with this payment method and merchant account.
  """
  customerAuthenticationRegulationEnvironment: CustomerAuthenticationRegulationEnvironment

  """A value indicating when to perform further customer authentication."""
  customerAuthenticationIndicator: CustomerAuthenticationIndicator
}

"""
Input fields when requesting authentication insight for a payment method.
"""
input AuthenticationInsightInput {
  """
  ID of the merchant account that will be used when charging this payment method.
  """
  merchantAccountId: ID!

  """
  The intended transaction amount to be authorized on this payment method.
  """
  amount: Amount

  """
  A flag indicating whether the customer has consented to further recurring transactions.
  """
  recurringCustomerConsent: Boolean

  """
  The maximum amount permitted for recurring transactions set by the customer.
  """
  recurringMaxAmount: Amount
}

"""
Records of authorization adjustments performed when a transaction is captured
for less or more than its original authorization amount.
"""
type AuthorizationAdjustment {
  """
  Difference between the authorized amount and the amount captured. Negative
  values indicate the authorized amount was adjusted down.
  """
  amount: MonetaryAmount

  """Indicates if the adjustment was successful or not."""
  successful: Boolean

  """Date and time when this adjustment was performed."""
  timestamp: Timestamp

  """Processor response from this adjustment."""
  processorResponse: TransactionAuthorizationAdjustmentProcessorResponse
}

"""Accompanying information for an authorization expired transaction."""
type AuthorizationExpiredEvent implements PaymentStatusEvent {
  """The new status of the transaction."""
  status: PaymentStatus

  """
  Date and time when the authorization for this transaction was marked expired.
  """
  timestamp: Timestamp

  """The amount of the transaction for this status event."""
  amount: MonetaryAmount

  """The source for the transaction change to the new status."""
  source: PaymentSource

  """Whether or not this is the final state for the transaction."""
  terminal: Boolean
}

"""
Top-level input fields for creating a transaction by authorizing a credit card.
"""
input AuthorizeCreditCardInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of a credit card payment method to be authorized."""
  paymentMethodId: ID!

  """Input fields related to the credit card being authorized."""
  options: CreditCardTransactionOptionsInput

  """
  Input fields for the authorization, with details that will define the resulting transaction.
  """
  transaction: TransactionInput!
}

"""Accompanying information for an authorized transaction."""
type AuthorizedEvent implements PaymentStatusEvent {
  """The new status of the transaction."""
  status: PaymentStatus

  """Date and time when the transaction was authorized."""
  timestamp: Timestamp

  """
  The amount the transaction was authorized for. This will match the amount on
  the transaction itself. In most cases, you can't request to settle more than this amount.
  """
  amount: MonetaryAmount

  """The source for the transaction change to the new status."""
  source: PaymentSource

  """
  Fields describing the payment processor response to the authorization request.
  """
  processorResponse: TransactionAuthorizationProcessorResponse

  """Fields describing the network response to the authorization request."""
  networkResponse: PaymentNetworkResponse

  """Risk decision for this transaction."""
  riskDecision: RiskDecision

  """Whether or not this is the final state for the transaction."""
  terminal: Boolean

  """
  The date/time the transaction will expire if it has the authorized status. For
  more details on authorization expiration timeframes, see the [Statuses reference](https://developers.braintreepayments.com/reference/general/statuses#authorization-expired).
  """
  authorizationExpiresAt: Timestamp
}

"""
Top-level input fields for creating a transaction by authorizing a payment method.
"""
input AuthorizePaymentMethodInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of a payment method to be authorized."""
  paymentMethodId: ID!

  """
  Input fields for the authorization, with details that will define the resulting transaction.
  """
  transaction: TransactionInput!
}

"""
Top-level input fields for creating a transaction by authorizing a PayPal account.
"""
input AuthorizePayPalAccountInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of a PayPal payment method to be authorized."""
  paymentMethodId: ID!

  """Input fields related to the PayPal account being authorized."""
  options: AuthorizePayPalAccountOptionsInput

  """
  Input fields for the authorization, with details that will define the resulting transaction.
  """
  transaction: TransactionInput!
}

"""Input fields for authorizing a PayPal account."""
input AuthorizePayPalAccountOptionsInput {
  """
  Variable passed directly to PayPal for your own tracking purposes. Customers do not see this value.
  """
  customField: String

  """
  Description of the transaction that is displayed to customers in PayPal email receipts.
  """
  description: String

  """
  Input fields setting the PayPal transaction context for risk assessment
  purposes. In order to use this field, your PayPal account must be set up to
  use the SetTransactionContext feature. This data will only be passed through
  to PayPal, and won't be stored on the transaction itself.
  """
  riskContext: PayPalTransactionRiskContextInput

  """Deprecated: This field is no longer supported."""
  payee: PayPalPayeeOptionsInput
}

"""
Top-level input fields for creating a transaction by authorizing a Venmo account.
"""
input AuthorizeVenmoAccountInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of a Venmo payment method to be authorized."""
  paymentMethodId: ID!

  """Input fields related to the Venmo account being authorized."""
  options: AuthorizeVenmoAccountOptionsInput

  """
  Input fields for the authorization, with details that will define the resulting transaction.
  """
  transaction: TransactionInput!
}

"""Input fields for authorizing a Venmo account."""
input AuthorizeVenmoAccountOptionsInput {
  """Specifies which Venmo business profile to use for the transaction."""
  profileId: String
}

"""
Response codes from the processing bank's Address Verification System (AVS) and CVV verification.
"""
enum AvsCvvResponseCode {
  BYPASS
  DOES_NOT_MATCH
  ISSUER_DOES_NOT_PARTICIPATE
  MATCHES
  NOT_APPLICABLE
  NOT_PROVIDED
  NOT_VERIFIED
  SYSTEM_ERROR
}

"""Information about the credit card based on its BIN."""
type BinRecord {
  """Whether or not the card is prepaid, such as a gift card."""
  prepaid: BinRecordValue

  """
  Whether the card is designated only to be used for healthcare expenses.
  """
  healthcare: BinRecordValue

  """Whether or not the card is a debit card."""
  debit: BinRecordValue

  """
  Whether the card is regulated by the Durbin Amendment due to the bank's
  assets, and therefore has a maximum interchange rate.
  """
  durbinRegulated: BinRecordValue

  """
  Whether or not the card is a commercial card and capable of processing Level 2 transactions.
  """
  commercial: BinRecordValue

  """Whether or not the card is designated for employee wages."""
  payroll: BinRecordValue

  """The name of the bank that issued the card."""
  issuingBank: String

  """
  The country code of the country that issued the card in ISO 3166-1 alpha-3 format.
  """
  countryOfIssuance: CountryCodeAlpha3

  """
  A code representing any special program from the card issuer the card is part of.
  """
  productId: String
}

"""
A boolean-like value that includes `UNKNOWN` in the case where the information isn't available.
"""
enum BinRecordValue {
  NO
  UNKNOWN
  YES
  No
  Unknown
  Yes
}

"""Configuration for payment methods in legacy clients."""
type BraintreeApiConfiguration {
  """The URL for tokenizing payment methods."""
  url: String

  """The authentication for tokenizing payment methods."""
  accessToken: String
}

"""The biller's ID type."""
enum BusinessIDType {
  EMPLOYER_IDENTIFICATION_NUMBER
}

"""General information about the business associated with the account."""
input BusinessInput {
  """The biller's business type."""
  type: BusinessType!

  """The DBA (Doing Business As) name of the business."""
  dbaName: String!

  """
  The business's legal name. Max 100 characters. Valid characters: letters, numbers, spaces, ! & ' ( ) + , - / : .
  """
  legalName: String!

  """The business's federal tax ID (EIN)."""
  federalTaxId: USTaxIdentificationNumber!

  """The biller's ID type."""
  idType: BusinessIDType

  """The country that issued the business's ID."""
  idIssuer: CountryCodeAlpha3

  """The business's U.S. state of registration."""
  stateOfRegistration: UsStateCode!

  """The business's merchant category code."""
  merchantCategoryCode: MerchantCategoryCode!

  """The business's start date. Must be after 1700."""
  startDate: Date!

  """A URL to an logo image. Required for Venmo onboarding."""
  logoUrl: String

  """The business's email address."""
  email: String!

  """The business's address. No P.O. Boxes."""
  address: AddressInput!

  """The country code for the business's phone number."""
  phoneCountryCode: Int!

  """The business's phone number. 9 digits. No extensions. Numbers only."""
  phoneNumber: String!

  """The type of phone number for the business."""
  phoneType: BusinessPhoneType!

  """The business's website. Must be a valid URL."""
  website: String!

  """
  The business's annual processing volume. Must be less than 1 billion USD.
  """
  annualVolume: Int!

  """
  The business's average transaction size. Must be less than 1 billion USD.
  """
  averageTransactionSize: Int!

  """
  The business's largest transaction size. Must be less than 1 billion USD.
  """
  largestTransactionSize: Int!

  """
  Whether payment is collected in arrears (after goods have been delivered).
  """
  arrears: Boolean

  """
  Percentage of the business's transactions are billed in arrears. Must be between 0 and 100.
  """
  percentageOneTime: Int

  """
  If the biller delivers goods, the number of days after charge they are delivered.
  """
  deliveryDays: Int

  """The business's refund policy."""
  refundPolicy: RefundPolicy

  """
  If applicable, the breakdown of monthly, quarterly, semi-annual, and annual subscriptions offered by the business.
  """
  subscriptions: BusinessSubscriptionInput
}

"""The type of phone number for the business."""
enum BusinessPhoneType {
  BUSINESS
  CUSTOMER_SERVICE
  MOBILE
  WORK
}

"""
A breakdown of the business's subscription frequency. All percentages provided must add up to 100.
"""
input BusinessSubscriptionInput {
  """The percentage of the business's subscriptions that are monthly."""
  percentMonthly: Int!

  """The percentage of the business's subscriptions that are quarterly."""
  percentQuarterly: Int!

  """The percentage of the business's subscriptions that are semi-annual."""
  percentSemiAnnual: Int!

  """The percentage of the business's subscriptions that are annual."""
  percentAnnual: Int!
}

"""The biller's business type."""
enum BusinessType {
  GOVERNMENT_AGENCY
  LIMITED_LIABILITY_CORPORATION
  PARTNERSHIP_LLP
  PRIVATE_CORPORATION
  PUBLIC_CORPORATION
  SOLE_PROPRIETORSHIP
  TAX_EXEMPT
}

"""Top-level input fields for capturing an authorized transaction."""
input CaptureTransactionInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of the transaction to be captured."""
  transactionId: ID!

  """
  Deprecated: This field is included for supporting legacy clients. Please use `transaction.amount` instead.
  
  The amount to capture on the transaction. Must be greater than 0. You can't
  capture more than the authorized amount unless your industry and processor
  support settlement adjustment (capturing a certain percentage over the
  authorized amount); [contact us for assistance](https://help.braintreepayments.com?issue=TransactionProcessingQuestion).
  If you capture an amount that is less than what was authorized, the
  transaction object will return the amount captured.
  """
  amount: Amount

  """
  Input fields for the capture, with details that will define the resulting transaction.
  """
  transaction: CaptureTransactionOptionsInput
}

"""
Input fields for a capture, with details that will define the resulting transaction.
"""
input CaptureTransactionOptionsInput {
  """
  The amount to capture on the transaction. Must be greater than 0. You can't
  capture more than the authorized amount unless your industry and processor
  support settlement adjustment (capturing a certain percentage over the
  authorized amount); [contact us for assistance](https://help.braintreepayments.com?issue=TransactionProcessingQuestion).
  If you capture an amount that is less than what was authorized, the
  transaction object will return the amount captured.
  """
  amount: Amount

  """
  Fields used to define what will appear on a customer's bank statement for a
  specific purchase. If specified, this will update the existing descriptor on
  the transaction.
  """
  descriptor: TransactionDescriptorInput

  """
  Discount amount that was included in the total transaction amount. Does not
  add to the total amount the payment method will be charged. This value can't be negative.
  
  *Required for Level 3 processing*.
  """
  discountAmount: String

  """
  Line items for this transaction. Up to 249 line items may be specified.
  
  *Required for Level 3 processing*.
  """
  lineItems: [TransactionLineItemInput!]

  """
  Additional information about the transaction. On PayPal transactions, this
  field maps to the PayPal invoice number. PayPal invoice numbers must be unique
  in your PayPal business account. Maximum 255 characters or 127 for PayPal
  transactions. If specified, this will update the existing order ID on the transaction.
  """
  orderId: String

  """
  A purchase order identification value you associate with this transaction.
  
  *Required for Level 2 processing*.
  """
  purchaseOrderNumber: String

  """
  Shipping information.
  
  *Required for Level 3 processing*.
  """
  shipping: TransactionShippingInput

  """
  Tax information about the transaction.
  
  *Required for Level 2 processing*.
  """
  tax: TransactionTaxInput
}

"""The type of account to be used when transacting with a combo card."""
enum CardAccountType {
  CREDIT
  DEBIT
}

"""
A list of challenges that are required by the current merchant to process a given credit card.
"""
enum Challenge {
  CVV
  POSTAL_CODE
  cvv
  postal_code
}

"""
Top-level input fields for creating a transaction by charging a credit card.
"""
input ChargeCreditCardInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of a credit card payment method to be charged."""
  paymentMethodId: ID!

  """Input fields for creating a credit card transaction."""
  options: CreditCardTransactionOptionsInput

  """
  Input fields for the charge, with details that will define the resulting transaction.
  """
  transaction: TransactionInput!
}

"""
Top-level input fields for creating a transaction by charging a payment method.
"""
input ChargePaymentMethodInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of a payment method to be charged."""
  paymentMethodId: ID!

  """
  Input fields for the charge, with details that will define the resulting transaction.
  """
  transaction: TransactionInput!
}

"""
Top-level input fields for creating a transaction by charging a PayPal account.
"""
input ChargePayPalAccountInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The ID of an existing PayPal account."""
  paymentMethodId: ID!

  """Input fields related to the PayPal account being charged."""
  options: ChargePayPalAccountOptionsInput

  """
  Input fields for the charge, with details that will define the resulting transaction.
  """
  transaction: TransactionInput!
}

"""Input fields for creating a transaction with a PayPal account."""
input ChargePayPalAccountOptionsInput {
  """
  Variable passed directly to PayPal for your own tracking purposes. Customers do not see this value.
  """
  customField: String

  """
  Description of the transaction that is displayed to customers in PayPal email receipts.
  """
  description: String

  """
  Input fields setting the PayPal transaction context for risk assessment
  purposes. In order to use this field, your PayPal account must be set up to
  use the SetTransactionContext feature. This data will only be passed through
  to PayPal, and won't be stored on the transaction itself.
  """
  riskContext: PayPalTransactionRiskContextInput

  """Deprecated: This field is no longer supported."""
  payee: PayPalPayeeOptionsInput
}

"""
Top-level input fields for creating a transaction by charging a US bank account.
"""
input ChargeUsBankAccountInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The ID of an existing US bank account."""
  paymentMethodId: ID!

  """Input fields related to the US bank account being charged."""
  options: ChargeUsBankAccountOptionsInput

  """
  Input fields for the charge, with details that will define the resulting transaction.
  """
  transaction: TransactionInput!
}

"""Input fields for creating a transaction with a US bank account."""
input ChargeUsBankAccountOptionsInput {
  """
  A NACHA standard entry class (SEC) code, which designates how the transaction
  was authorized. Most internet-based sales should use the `WEB` code.
  """
  standardEntryClassCode: ACHStandardEntryClassCode
}

"""
Top-level input fields for creating a transaction by charging a Venmo account.
"""
input ChargeVenmoAccountInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The ID of an existing Venmo account."""
  paymentMethodId: ID!

  """Input fields for creating a Pay with Venmo transaction."""
  options: ChargeVenmoAccountOptionsInput

  """
  Input fields for the charge, with details that will define the resulting transaction.
  """
  transaction: TransactionInput!
}

"""Input fields for creating a Pay with Venmo transaction."""
input ChargeVenmoAccountOptionsInput {
  """Specifies which Venmo business profile to use for the transaction."""
  profileId: String
}

"""
A partial capture's relationship to its original authorization transaction.
"""
type ChildCapture {
  """The original authorization whose funds have been partially captured."""
  parentAuthorization: Transaction
}

"""Top-level fields returned from the client configuration query."""
type ClientConfiguration {
  """URL to send analytics."""
  analyticsUrl: String @deprecated(reason: "This field is included for supporting SDKs that send analytics.")

  """Configuration for Apple Pay on iOS."""
  applePay: ApplePayConfiguration

  """Configuration for Apple Pay on the web."""
  applePayWeb: ApplePayWebConfiguration

  """
  A URL pointing to the base path of Braintree's web pages used for various browser switches and popups.
  """
  assetsUrl: String

  """A URL pointing to the base path of Braintree's client API."""
  clientApiUrl: String @deprecated(reason: "This field is included for supporting legacy clients.")

  """A list of client features the merchant supports."""
  supportedFeatures: [ClientFeature!] @deprecated(reason: "This field is included for supporting legacy clients.")

  """Configuration for payment methods in legacy clients."""
  braintreeApi: BraintreeApiConfiguration @deprecated(reason: "This field is included for supporting legacy clients.")

  """Configuration for credit card tokenization."""
  creditCard: CreditCardConfiguration

  """The enum of the current environment."""
  environment: ClientConfigurationEnvironment

  """Configuration for fraud protection provider."""
  fraudProvider: FraudProviderConfiguration

  """Configuration for Google Pay on Android and the web."""
  googlePay: GooglePayConfiguration

  """Deprecated, this field will always be null."""
  ideal: IDealConfiguration @deprecated(reason: "This field is included for supporting legacy clients.")

  """
  Deprecated, formerly configuration for Kount fraud tools, now this configuration lives under fraudProvider.
  """
  kount: KountConfiguration @deprecated(reason: "This field is included for supporting legacy clients.")

  """Configuration for Masterpass."""
  masterpass: MasterpassConfiguration

  """The merchant ID."""
  merchantId: String

  """Configuration for PayPal."""
  paypal: PayPalConfiguration

  """Configuration for Samsung Pay."""
  samsungPay: SamsungPayConfiguration

  """Configuration for UnionPay cards."""
  unionPay: UnionPayConfiguration

  """Configuration for US bank account processing."""
  usBankAccount: UsBankAccountConfiguration

  """Configuration for Pay with Venmo."""
  venmo: VenmoConfiguration

  """Configuration for Visa Checkout."""
  visaCheckout: VisaCheckoutConfiguration

  """
  A list of challenges that are required by the current merchant to process a given credit card.
  """
  challenges: [Challenge!]
}

"""The client configuration environment being used."""
enum ClientConfigurationEnvironment {
  DEVELOPMENT
  PRODUCTION
  QA
  SANDBOX
  TEST
  development
  production
  qa
  sandbox
  test
}

"""
A value used by Braintree client SDKs to determine what operations are supported through this GraphQL API.
"""
enum ClientFeature {
  TOKENIZE_CREDIT_CARDS
  tokenize_credit_cards
}

"""Input fields for creating a client token."""
input ClientTokenInput {
  """
  The merchant account ID used to create the client token. Defaults to your default merchant account ID.
  """
  merchantAccountId: ID

  """
  The ID of an existing customer. Including this will allow your customer to vault and manage their payment methods.
  """
  customerId: ID
}

"""Top-level input field for confirming micro-transfer values."""
input ConfirmMicroTransferAmountsInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The ID of the verification from vaulting the bank account."""
  verificationId: ID!

  """
  The amounts, in cents, of two deposits made into the customer's bank account
  after initiating a MICRO_TRANSFERS verification. These values should be
  collected from your customer.
  """
  amountsInCents: [Int!]!
}

"""
Top-level output field from confirming micro-transfer amounts on bank account.
"""
type ConfirmMicroTransferAmountsPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The verification that was run on the payment method prior to vaulting."""
  verification: Verification

  """The status of the micro-transfer amounts confirmation."""
  status: ConfirmMicroTransferAmountsStatus
}

"""The status of a micro-transfer amount confirmation."""
enum ConfirmMicroTransferAmountsStatus {
  AMOUNTS_DO_NOT_MATCH
  CONFIRMED
  TOO_MANY_ATTEMPTS
}

"""
An [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)
country code. Braintree only accepts [specific alpha-2 values](https://developers.braintreepayments.com/reference/general/countries#list-of-countries).
"""
scalar CountryCodeAlpha2

"""
An [ISO 3166-1 alpha-3](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-3)
country code. Braintree only accepts [specific alpha-3 values](https://developers.braintreepayments.com/reference/general/countries#list-of-countries).
"""
scalar CountryCodeAlpha3

"""
Input fields for obtaining an OAuth access token for an in-store reader.
"""
input CreateAccessTokenForReaderInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """A reader specific identification code."""
  deviceCode: String!

  """ A globally unique reader device id generated by the reader."""
  deviceId: ID!
}

"""
Input fields for obtaining an OAuth access token using an authorization grant.
"""
input CreateAccessTokenFromAuthorizationCodeInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """A authorization code."""
  authorizationCode: String!
}

"""Top-level input field for generating a client token."""
input CreateClientTokenInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """Input fields for creating a client token."""
  clientToken: ClientTokenInput
}

"""Top-level fields returned when creating a client token."""
type CreateClientTokenPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """A Base64 encoded string used to initialize client SDKs."""
  clientToken: String
}

"""
Fields that are provided when creating a custom action payment context.
"""
input CreateCustomActionsPaymentContextInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The action you wish to invoke when creating the payment context."""
  actionName: String!

  """
  A list of fields used to create a PaymentContext during execution of a Custom Actions handler (Five (5) entries maximum).
  """
  customFields: [CustomActionsPaymentContextFieldInput!]
}

"""Top-level field for creating a customer."""
input CreateCustomerInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """Input fields for creating a customer."""
  customer: CustomerInput
}

"""Top-level fields returned when creating a customer."""
type CreateCustomerPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """
  Information about the customer that was created. Can be used when vaulting
  payment methods or creating transactions to associate those objects.
  """
  customer: Customer
}

"""Input fields for creating an in store location."""
input CreateInStoreLocationInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """Input fields to create an in-store Location."""
  location: InStoreLocationInput!
}

"""Top-level fields returned when creating an in-store location."""
type CreateInStoreLocationPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The in-store location."""
  location: InStoreLocation
}

"""Input fields for applying for a merchant account."""
input CreateMerchantAccountApplicationInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """A unique identifier to track the progress of individual applications."""
  uniqueIdentifier: String!

  """General information about the business associated with the account."""
  business: BusinessInput!

  """
  A minimum of one and a maximum of five owners can be submitted. One owner must be the authorized signer on the account.
  """
  owners: [OwnerInput!]!

  """Information about the business's relationship with American Express."""
  americanExpressRelationship: AmericanExpressRelationshipInput

  """The bank account to be used for sales."""
  salesAccount: ApplicationBankAccountInput!

  """
  Configuration for businesses registered with various discount programs (MVV, VPP, Loans).
  """
  discountProgramRegistration: DiscountProgramRegistrationInput

  """Configuration for processing via ACH."""
  achConfiguration: ACHConfigurationInput
}

"""A code identifying the card brand."""
enum CreditCardBrandCode {
  AMERICAN_EXPRESS
  DINERS
  DISCOVER
  INTERNATIONAL_MAESTRO
  JCB
  MASTERCARD
  SOLO
  UK_MAESTRO
  UNION_PAY
  UNKNOWN
  VISA
  american_express
  diners
  discover
  international_maestro
  jcb
  mastercard
  solo
  uk_maestro
  union_pay
  unknown
  visa
}

"""Configuration for credit card tokenization."""
type CreditCardConfiguration {
  """
  A list of card brands supported by the merchant for credit card processing.
  """
  supportedCardBrands: [CreditCardBrandCode!]

  """
  A list of challenges that are required by the merchant to process a given credit card.
  """
  challenges: [Challenge!]

  """Whether or not the merchant supports 3D Secure."""
  threeDSecureEnabled: Boolean @deprecated(reason: "Use `threeDSecure` instead.")

  """Configuration for 3D Secure."""
  threeDSecure: ThreeDSecureConfiguration

  """Whether or not fraud data collection is enabled for the merchant."""
  fraudDataCollectionEnabled: Boolean
}

"""Details about a credit card."""
type CreditCardDetails {
  """A static code identifying the card brand."""
  brandCode: CreditCardBrandCode

  """The last four digits of the card number."""
  last4: String

  """
  The first 6 digits of the credit card number, known as the Bank Identification
  Number. If this card originates from a third party such as a wallet provider,
  this BIN may not be present and the PaymentMethodOriginDetails will contain a BIN instead.
  """
  bin: String

  """Information about the card based on its BIN."""
  binData: BinRecord

  """The month of the expiration date, formatted MM."""
  expirationMonth: String

  """The year of the expiration date, formatted YYYY."""
  expirationYear: String

  """The cardholder's name."""
  cardholderName: String

  """
  An identifier that uniquely represents any credit card number, for cards
  stored in a merchant's vault. If the same credit card is added to a merchant's
  vault multiple times, each will have the same identifier. This identifier will
  only be returned if the field "origin" is null.
  """
  uniqueNumberIdentifier: String

  """
  Additional information if the credit card was provided from a third-party
  origin, such as Apple Pay, Google Pay, or another digital wallet.
  """
  origin: PaymentMethodOrigin

  """The billing address associated with the credit card."""
  billingAddress: Address

  """
  Contains relevant data fields if the payment method has been authenticated
  using 3D Secure. Only available on 3D Secure authenticated single-use payment
  methods and 3D Secure paymentMethodSnapshots.
  """
  threeDSecure: ThreeDSecureAuthentication

  """A URL to an image logo representing the card brand."""
  imageUrl: String @deprecated(reason: "This field is included for supporting legacy clients.")

  """The display name of the card brand, e.g. "Visa" or "American Express"."""
  brand: String @deprecated(reason: "Use `brandCode` instead.")
}

"""Input fields for a credit card."""
input CreditCardInput {
  """
  The 12-to-19-digit value that uniquely identifies this credit card, also known as the primary account number or PAN.
  """
  number: String

  """
  The two- or four-digit year associated with a credit card, formatted `YYYY` or `YY`.
  """
  expirationYear: String

  """The expiration month of a credit card, formatted `MM`."""
  expirationMonth: String

  """
  A three- or four-digit card verification value assigned to credit cards. The
  CVV will never be stored, but it can be provided with one-time requests to
  verify the card.
  """
  cvv: String

  """
  When supplied, the cardholder name that will be tokenized with the contents of the fields.
  """
  cardholderName: String

  """The billing address for the credit card."""
  billingAddress: AddressInput
}

"""A four-digit string."""
scalar CreditCardLast4

"""A number that passes Luhn validation."""
scalar CreditCardNumber

"""Credit card specific details on a transaction or verification."""
type CreditCardTransactionDetails {
  """The details of the credit card itself."""
  creditCard: CreditCardDetails

  """
  The network transaction identifier provided by the payment network. If this
  transaction was created in order to verify a payment method before storing it
  in an external vault, then this value can be pased when creating subsequent
  transactions with the same payment method.
  """
  networkTransactionId: String

  """
  For combo cards, what account type was used for this specific transaction.
  """
  accountType: CardAccountType
}

"""
Input fields for creating a transaction by authorizing or charging a credit card.
"""
input CreditCardTransactionOptionsInput {
  """
  Details about this transaction if it's being created from a credit card that
  is or will be stored in an non-Braintree vault.
  """
  externalVault: TransactionExternalVaultOptionsInput

  """
  A billing address to use for the transaction. If a billing address was
  provided when tokenizing or is present on the vaulted credit card, it will be
  *merged* with this input value, with priority given to this input value.
  """
  billingAddress: AddressInput

  """The type of account to be used when transacting with a combo card."""
  accountType: CardAccountType

  """
  The CVV for the credit card to be used when creating this transction, securely tokenized with the `tokenizeCvv` mutation.
  """
  tokenizedCvv: ID
}

"""Information specific to verifications of credit card payment methods."""
type CreditCardVerificationDetails {
  """The amount used when performing the verification. May be 0."""
  amount: MonetaryAmount
}

"""
Input fields for creating a transaction by authorizing or charging a credit card.
"""
input CreditCardVerificationOptionsInput {
  """The type of account to be used when verifying a combo card."""
  accountType: CardAccountType
}

"""
An [ISO 4217 alpha](https://en.wikipedia.org/wiki/ISO_4217) currency code.
Braintree only accepts [specific alpha
values](https://developers.braintreepayments.com/reference/general/currencies).
"""
scalar CurrencyCodeAlpha

"""Top-level fields returned from a Custom Actions payment context."""
type CustomActionsPaymentContext implements Node {
  """The identifier of the payment context."""
  id: ID!

  """An ISO 8601 date string of when the payment context was created."""
  createdAt: String!

  """An ISO 8601 date string of when the payment context was updated."""
  updatedAt: String!

  """
  A list of fields stored on a PaymentContext during execution of a Custom Actions handler (Five (5) entries maximum).
  """
  customFields: [CustomActionsPaymentContextField!]
}

"""
Fields returned by the createPaymentContext custom actions event handler.
"""
type CustomActionsPaymentContextField {
  """
  An alphanumeric string used as a key to lookup a CustomField value (255 characters maximum).
  """
  name: String!

  """
  An alphanumeric string used to store a CustomField value (7168 characters maximum).
  """
  value: String!
}

"""Fields that are provided when creating the payment context."""
input CustomActionsPaymentContextFieldInput {
  """
  An alphanumeric string used as a key to lookup a CustomField value (255 characters maximum).
  """
  name: String!

  """
  An alphanumeric string used to store a CustomField value (7168 characters maximum).
  """
  value: String!
}

"""
Top-level fields returned from a created custom actions payment context.
"""
type CustomActionsPaymentContextPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The payment context data."""
  customActionsPaymentContext: CustomActionsPaymentContext
}

"""Details about a custom actions payment method."""
type CustomActionsPaymentMethodDetails {
  """The action to be invoked when using the payment method."""
  actionName: String

  """Fields that your action requires."""
  fields: [CustomActionsPaymentMethodField!]
}

"""
Fields that are provided during tokenization and are presented to the invoked action to be consumed.
"""
type CustomActionsPaymentMethodField {
  """The name of this field, e.g. "accountNumber"."""
  name: String

  """The value displayed in the Control Panel or API, e.g. "*****6789"."""
  displayValue: String
}

"""
Fields that are provided during tokenization and are presented to the invoked action to be consumed.
"""
input CustomActionsPaymentMethodFieldInput {
  """The name of this field. e.g. "accountNumber"."""
  name: String!

  """The value of this field. e.g. "123456789"."""
  value: String!

  """The value displayed in the Control Panel or API. e.g. "*****6789"."""
  displayValue: String!
}

"""Input fields for a Custom Actions payment method."""
input CustomActionsPaymentMethodInput {
  """The action you wish to invoke when using the tokenized payment method."""
  actionName: String!

  """Fields that your action requires."""
  fields: [CustomActionsPaymentMethodFieldInput!]!
}

"""
Information about a customer and their associated payment methods and transactions.
"""
type Customer implements Node {
  """Unique identifier."""
  id: ID!

  """Legacy unique identifier."""
  legacyId: ID!

  """Company or business name associated with this customer."""
  company: String

  """Date and time at which the customer was created."""
  createdAt: Timestamp

  """
  Collection of custom field/value pairs. Custom fields are [defined in the Control Panel](https://articles.braintreepayments.com/control-panel/custom-fields#store-and-pass-back-fields).
  """
  customFields: [CustomField!]

  """Customer's default payment method."""
  defaultPaymentMethod: PaymentMethod

  """Email address for this customer."""
  email: String

  """Customer's first name."""
  firstName: String

  """Customer's last name."""
  lastName: String

  """The phone number for this customer."""
  phoneNumber: String

  """Payment methods belonging to this customer."""
  paymentMethods(first: Int, after: String): PaymentMethodConnection

  """
  Transactions associated with this customer. This includes transactions created
  by charging a vaulted payment method that belongs or belonged to the customer,
  or by passing a customer ID when charging a single-use payment method.
  """
  transactions(first: Int, after: String): TransactionConnection
}

"""A value indicating when to perform further customer authentication."""
enum CustomerAuthenticationIndicator {
  """Indicates further authentication is optional."""
  OPTIONAL

  """Indicates further authentication should be performed."""
  REQUIRED

  """
  Customer authentication indicator information is unavailable at this time.
  """
  UNAVAILABLE
}

"""
The customer authentication regulation environment that applies to the
transaction, such as [PSD2](https://www.braintreepayments.com/blog/understanding-and-preparing-for-psd2-strong-customer-authentication/).
"""
enum CustomerAuthenticationRegulationEnvironment {
  """
  EU Regulation [PSD2 Strong Customer Authentication](https://www.braintreepayments.com/blog/understanding-and-preparing-for-psd2-strong-customer-authentication/)
  applies to this transaction.
  """
  PSDTWO

  """Reserve Bank of India regulations apply to this transactions."""
  RBI

  """
  Customer authentication regulation environment information is unavailable for this transaction at this time.
  """
  UNAVAILABLE

  """No customer authentication regulations apply to this transaction."""
  UNREGULATED
}

"""A paginated list of customers."""
type CustomerConnection {
  """A list of customers."""
  edges: [CustomerConnectionEdge]

  """Information about the page of customers contained in `edges`."""
  pageInfo: PageInfo!
}

"""A customer within a CustomerConnection."""
type CustomerConnectionEdge {
  """
  This customer's location within the CustomerConnection. Used for requesting additional pages.
  """
  cursor: String

  """The customer."""
  node: Customer
}

"""
Input fields for creating or updating a customer. On update, omitted fields will
not be updated. Passing a null value will assign null to that field.
"""
input CustomerInput {
  """Company or business name associated with the customer."""
  company: String

  """
  Collection of custom field/value pairs. You must [set up each custom field in the Control Panel](https://articles.braintreepayments.com/control-panel/custom-fields#creating-a-custom-field)
  prior to passing it with a request.
  """
  customFields: [CustomFieldInput!]

  """Email address for the customer."""
  email: String

  """Customer's first name."""
  firstName: String

  """Customer's last name."""
  lastName: String

  """The customer's phone number."""
  phoneNumber: String
}

"""Input fields for searching for customers."""
input CustomerSearchInput {
  """Find customers with an id or ids."""
  id: SearchValueInput

  """Find customers with a given company or business name."""
  company: SearchTextInput

  """Find customers with a given created at time."""
  createdAt: SearchTimestampInput

  """Find customers with a given email address."""
  email: SearchTextInput

  """Find customers with a given first name."""
  firstName: SearchTextInput

  """Find customers with a given last name."""
  lastName: SearchTextInput

  """Find customers with a given phone number."""
  phoneNumber: SearchTextInput
}

"""A merchant-defined custom field to store additional information."""
type CustomField {
  """The name of the custom field."""
  name: String

  """The value of the custom field."""
  value: String
}

"""
Custom field name/value pairs. Maximum 255 characters. You must [set up each
custom field in the Control Panel](https://articles.braintreepayments.com/control-panel/custom-fields#creating-a-custom-field)
prior to passing it with a request.
"""
input CustomFieldInput {
  """Name of the custom field as defined in the Control Panel."""
  name: CustomFieldName!

  """
  Value for the named custom field. A null value will ignore (on create) or remove (on update) the custom field.
  """
  value: String
}

"""
A string representing a custom field value. Contains letters, numbers, and underscores.
"""
scalar CustomFieldName

"""
A three- or four-digit string CVV (card verification value), otherwise known as CSC or CVC.
"""
scalar CVV

"""A date in the format YYYY-MM-DD."""
scalar Date

"""Top-level input fields for deleting a customer."""
input DeleteCustomerInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The ID of the customer to be deleted."""
  customerId: ID!
}

"""Top-level output field from deleting a customer."""
type DeleteCustomerPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String
}

"""
Top-level input fields for deleting a payment method referenced by a single-use token.
"""
input DeletePaymentMethodFromSingleUseTokenInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """A single-use token ID referencing a payment method."""
  singleUseTokenId: ID!
}

"""
Top-level output field from deleting a payment method referenced by a single-use token.
"""
type DeletePaymentMethodFromSingleUseTokenPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String
}

"""
Top-level input fields for deleting a multi-use payment method from the vault.
"""
input DeletePaymentMethodFromVaultInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The ID of the multi-use payment method to be deleted."""
  paymentMethodId: ID!
}

"""Top-level output field from deleting a multi-use payment method."""
type DeletePaymentMethodFromVaultPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String
}

"""Specific input fields for describing a detached refund."""
input DetachedRefundInput {
  """The amount to refund."""
  amount: Amount!

  """The refund's order ID."""
  orderId: String
}

"""
Disbursement details contain information about how and when the transaction was
disbursed, including timing and currency information. This field is only
available if you have an eligible merchant account.
"""
type DisbursementDetails {
  """
  The date that the funds associated with this transaction were disbursed.
  """
  date: Date

  """
  Amount of money disbursed in the settlement currency, which may be different
  than the transaction's [presentment
  currency](https://articles.braintreepayments.com/get-started/currencies).
  """
  amount: MonetaryAmount

  """
  The exchange rate from the presentment currency to the settlement currency. If
  the currencies are the same, this will be 1.
  """
  exchangeRate: String

  """
  Indicates whether funds have been withheld from a disbursement to the merchant's account.
  """
  fundsHeld: Boolean
}

"""
Information about the business's particpation in various discount programs.
"""
input DiscountProgramRegistrationInput {
  """The business's MVV (Merchant Verification Value) registration type."""
  registrationType: MVVRegistrationType!

  """
  The business's existing MVV (Merchant Verification Value) registration number, if they have one.
  """
  registrationIdentifier: String

  """
  The number of customers the business has. Required if `registrationType` is `UTIL_RATE` or `LOAN_VPP`.
  """
  numberOfCustomers: Int

  """
  The means by which customers pay their bills. Required if  `registrationType` is `UTIL_RATE` or `LOAN_VPP`.
  """
  acceptanceChannel: [MVVAcceptanceChannel]

  """
  The business's MVV utility type. Required if `registrationType` is `UTIL_RATE`.
  """
  utilityType: [MVVUtilityType]

  """
  Does the business accept payday loans? Required if `registrationType` is `LOAN_VPP`.
  """
  loanPayday: Boolean

  """
  Does the business charge fees for debt repayment? Required if `registrationType` is `LOAN_VPP`.
  """
  loanFee: Boolean
}

"""
[A case raised by a customer to either request information about or to challenge a charge](https://articles.braintreepayments.com/risk-and-security/chargebacks-retrievals/overview).
These are initiated via a customer's payment provider, such as their bank, and
require a merchant to provide evidence or further information.
"""
type Dispute implements Node {
  """Unique identifier."""
  id: ID!

  """Legacy unique identifier."""
  legacyId: ID!

  """
  The amount of money from the original charge that the customer is disputing.
  Can be 0. This amount is debited from a merchant's account and held in a
  third-party account until the dispute is resolved, at which time it is sent to
  either the merchant or customer.
  """
  amountDisputed: MonetaryAmount

  """
  If an amount was disputed, the amount of money awarded back to the merchant if the dispute was reversed.
  """
  amountWon: MonetaryAmount

  """The case number for the dispute."""
  caseNumber: String

  """Date and time at which the dispute was created."""
  createdAt: Timestamp

  """Date the dispute was received by the merchant."""
  receivedDate: Date

  """The transaction reference number for the dispute."""
  referenceNumber: String

  """The deadline for the merchant to submit a response to the dispute."""
  responseDeadline: Timestamp

  """
  The reply by date for the merchant to submit a response to the dispute.
  """
  replyByDate: Date

  """The type of dispute."""
  type: DisputeType

  """Evidence records submitted by the merchant for the dispute."""
  evidence: [DisputeEvidence!]

  """
  If this dispute is a follow-up to a previous chargeback or retrieval, the original dispute.
  """
  originalDispute: Dispute

  """Additional information from the payment processor."""
  processorResponse: DisputeProcessorResponse

  """The status of the dispute."""
  status: DisputeStatus

  """
  A log of history events containing status changes by date for this dispute.
  """
  statusHistory: [DisputeStatusEvent!]

  """
  The disputed transaction which the customer is either requesting further information on or challenging.
  """
  transaction: Transaction
}

"""A paginated list of disputes."""
type DisputeConnection {
  """A list of disputes."""
  edges: [DisputeConnectionEdge]

  """Information about the page of disputes contained in `edges`."""
  pageInfo: PageInfo!
}

"""A dispute within a DisputeConnection."""
type DisputeConnectionEdge {
  """
  This dispute's location within the DisputeConnection. Used for requesting additional pages.
  """
  cursor: String

  """The dispute."""
  node: Dispute
}

"""Evidence provided by a merchant to respond to a dispute."""
interface DisputeEvidence {
  """Unique identifier."""
  id: ID!

  """Legacy unique identifier."""
  legacyId: ID!

  """Date and time when the evidence was created with Braintree."""
  createdAt: Timestamp

  """Date and time when the evidence was sent to the processor."""
  sentToProcessorAt: Timestamp

  """The evidence category."""
  category: String
}

"""Images, files, or other evidence supporting a dispute case."""
type DisputeFileEvidence implements DisputeEvidence {
  """Unique identifier."""
  id: ID!

  """Legacy unique identifier."""
  legacyId: ID!

  """Date and time at which the evidence was created with Braintree."""
  createdAt: Timestamp

  """Date and time at which the evidence was sent to the processor."""
  sentToProcessorAt: Timestamp

  """A URL where you can retrieve the dispute evidence."""
  url: String

  """The evidence category."""
  category: String
}

"""Information about the dispute provided by the processor."""
type DisputeProcessorResponse {
  """Additional comments forwarded by the processor."""
  processorComments: String

  """The reason the dispute was created."""
  reason: DisputeReason

  """The reason code provided by the processor."""
  reasonCode: String

  """The reason code description based on the `reasonCode`."""
  reasonDescription: String

  """Date the dispute was received by the merchant."""
  receivedDate: Date

  """
  The string value representing the reference number provided by the processor (if any).
  """
  referenceNumber: String
}

"""
The reason a customer opened a chargeback, pre-arbitration, or retrieval.
"""
enum DisputeReason {
  CANCELLED_RECURRING_TRANSACTION
  CREDIT_NOT_PROCESSED
  DUPLICATE
  FRAUD
  GENERAL
  INVALID_ACCOUNT
  NOT_RECOGNIZED
  PRODUCT_NOT_RECEIVED
  PRODUCT_UNSATISFACTORY
  RETRIEVAL
  TRANSACTION_AMOUNT_DIFFERS
}

"""Input fields for searching for Disputes."""
input DisputeSearchInput {
  """Find disputes with an id or ids."""
  id: SearchValueInput

  """Find disputes with a given status."""
  status: SearchDisputeStatusInput

  """Find disputes with a given type."""
  type: SearchDisputeTypeInput

  """Find disputes with a given reason description."""
  reason: SearchDisputeReasonInput

  """Find disputes with a given processor's caseNumber."""
  caseNumber: SearchTextInput

  """Find disputes with a given transaction referenceNumber."""
  referenceNumber: SearchTextInput

  """Find disputes for a given amount or currency."""
  amountDisputed: MonetaryAmountSearchInput

  """Find disputes by the amount won."""
  amountWon: MonetaryAmountSearchInput

  """Find disputes by the date received."""
  receivedDate: SearchDateInput

  """Find disputes by the reply by date."""
  replyByDate: SearchDateInput

  """Find disputes by the date a status change history event took effect."""
  effectiveDate: SearchDateInput

  """Find disputes based on a set of transaction criteria."""
  transaction: DisputeTransactionSearchInput
}

"""The status of the dispute."""
enum DisputeStatus {
  ACCEPTED
  DISPUTED
  EXPIRED
  LOST
  OPEN
  WON
}

"""A record of a status the dispute has passed through."""
type DisputeStatusEvent {
  """The date any funds associated with this event were disbursed."""
  disbursementDate: Date

  """The status of the dispute."""
  status: DisputeStatus

  """Date and time when the status event occurred."""
  timestamp: Timestamp

  """The date the status event took effect."""
  effectiveDate: Date
}

"""Text evidence supporting a dispute case."""
type DisputeTextEvidence implements DisputeEvidence {
  """Unique identifier."""
  id: ID!

  """Legacy unique identifier."""
  legacyId: ID!

  """Date and time at which the evidence was created with Braintree."""
  createdAt: Timestamp

  """Date and time at which the evidence was sent to the processor."""
  sentToProcessorAt: Timestamp

  """The body for text evidence."""
  comment: String

  """The evidence category."""
  category: String
}

"""Transaction input fields for searching for disputes."""
input DisputeTransactionSearchInput {
  """Find disputes for a transaction id or ids."""
  transactionId: SearchValueInput

  """Find disputes for a customer id or ids."""
  customerId: SearchValueInput

  """Find disputes with a given transaction source."""
  transactionSource: SearchTransactionSourceInput

  """
  Find disputes on transactions charging payment methods of the given type.
  """
  paymentMethodSnapshotType: SearchPaymentMethodSnapshotTypeInput

  """
  Find disputes on transactions created by a third party via the Grant API using a given OAuth application client ID.
  """
  facilitatorOAuthApplicationClientId: SearchValueInput

  """Find disputes by the transaction's disbursement date."""
  disbursementDate: SearchDateInput

  """
  Find disputes on transactions associated with a merchant account ID or IDs.
  """
  merchantAccountId: SearchValueInput
}

"""Type of dispute."""
enum DisputeType {
  CHARGEBACK

  """
  A [second challenge to a charge](https://articles.braintreepayments.com/risk-and-security/chargebacks-retrievals/overview#pre-arbitrations),
  in the case that you have won an initial chargeback.
  """
  PRE_ARBITRATION
  RETRIEVAL
}

"""
A card brand-specific two-digit string describing the mode of the transaction.
"""
scalar ECommerceIndicator

"""A credit card's assocation with an external vault."""
enum ExternalVaultStatus {
  """
  The payment method for this transaction has been vaulted in an external vault.
  """
  VAULTED

  """
  The payment method has not been vaulted in an exernal vault, but it will be if this transaction is successfully processed.
  """
  WILL_VAULT
}

"""
Fields capturing information about a third party that provided payment
information for this transaction via the Grant API, Shared Vault, or Google Pay.
"""
type FacilitatorDetails {
  """
  The OAuth application that owns the payment information used to create the transaction.
  """
  oauthApplication: OAuthApplication
}

"""
Accompanying information for a transaction that failed because it could not be successfully sent to the processor.
"""
type FailedEvent implements PaymentStatusEvent {
  """The new status of the transaction."""
  status: PaymentStatus

  """Date and time when the transaction failed."""
  timestamp: Timestamp

  """The amount of the transaction for this status event."""
  amount: MonetaryAmount

  """The source for the transaction change to the new status."""
  source: PaymentSource

  """
  Fields describing the payment processor response, or an explanation for the lack thereof.
  """
  processorResponse: TransactionAuthorizationProcessorResponse

  """Fields describing the network response to the authorization request."""
  networkResponse: PaymentNetworkResponse

  """Risk decision for this transaction."""
  riskDecision: RiskDecision

  """Whether or not this is the final state for the transaction."""
  terminal: Boolean
}

"""Configuration for fraud protection provider."""
type FraudProviderConfiguration {
  """
  The merchant ID used by the fraud protection provider to identify the fraud data collection request.
  """
  merchantId: String

  """The name of the fraud provider."""
  name: String
}

"""The third-party provider used to generate the risk decision."""
enum FraudServiceProvider {
  FRAUD_PROTECTION
  FRAUD_PROTECTION_ENTERPRISE
  KOUNT
}

"""Accompanying information for a gateway rejected transaction."""
type GatewayRejectedEvent implements PaymentStatusEvent {
  """The new status of the transaction."""
  status: PaymentStatus

  """Date and time when the transaction was rejected by the gateway."""
  timestamp: Timestamp

  """The amount of the transaction for this status event."""
  amount: MonetaryAmount

  """The source for the transaction change to the new status."""
  source: PaymentSource

  """
  The reason the transaction was rejected, based on your gateway settings.
  """
  gatewayRejectionReason: GatewayRejectionReason

  """
  Fields describing the payment processor response. Depending on your gateway
  settings, the AVS and CVV responses may be the reason for the rejection.
  """
  processorResponse: TransactionAuthorizationProcessorResponse

  """Fields describing the network response to the authorization request."""
  networkResponse: PaymentNetworkResponse

  """
  Risk decision for this transaction. If the gatewayRejectionReason is fraud, this may be the reason for the rejection.
  """
  riskDecision: RiskDecision

  """Whether or not this is the final state for the transaction."""
  terminal: Boolean

  """
  The original transaction if the gateway rejection reason was `DUPLICATE`.
  """
  duplicateOf: Transaction
}

"""Possible reasons why a transaction was rejected by the gateway."""
enum GatewayRejectionReason {
  APPLICATION_INCOMPLETE
  AVS
  AVS_AND_CVV
  CVV
  DUPLICATE
  FRAUD
  MANUAL_TRANSACTIONS_DISABLED
  PAYMENT_METHOD_BLOCKED
  RISK_THRESHOLD
  THREE_D_SECURE
  TOKEN_ISSUANCE
  TOO_MANY_CONFIRMATION_ATTEMPTS
  UNION_PAY_ENROLLMENT_REQUIRED
}

"""Input fields for generating a pairing code to pair an in store reader."""
input GenerateInStoreReaderPairingCodeInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ A globally unique reader device id generated by the reader."""
  deviceId: ID!
}

"""
Top-level fields returned when generating a pairing code for an in-store reader.
"""
type GenerateInStoreReaderPairingCodePayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """Reader specific identification code."""
  deviceCode: String

  """Generated code used to pair this reader with a merchant."""
  userCode: String

  """Redirect URI used for verification of the reader."""
  verificationUri: String

  """Time to expiration of the generated user and device codes."""
  expiresIn: Int
}

"""Configuration for Google Pay on Android and the web."""
type GooglePayConfiguration {
  """A string used to identify the merchant to the customer."""
  displayName: String

  """The environment being used for Google Pay."""
  environment: GooglePayEnvironment

  """Authorization to use when tokenizing a Google Pay payment method."""
  googleAuthorization: String @deprecated(reason: "This field is included for supporting legacy clients.")

  """
  A string used to identify the merchant's PayPal account when generating a PayPal Closed Loop Token.
  """
  paypalClientId: String

  """A list of card brands supported by the merchant for Google Pay."""
  supportedCardBrands: [CreditCardBrandCode!]
}

"""The environment being used for Google Pay."""
enum GooglePayEnvironment {
  PRODUCTION
  SANDBOX
  production
  sandbox
}

"""
Additional information about the payment method specific to Google Pay.
"""
type GooglePayOriginDetails {
  """A reference ID for the Google transaction."""
  googleTransactionId: String

  """
  The first 6 digits of the credit card, known as the Bank Identification
  Number. This BIN may differ from the BIN of the customer's actual card.
  """
  bin: String
}

"""Configuration for iDEAL."""
type IDealConfiguration {
  """The route ID used to process an iDEAL payment."""
  routeId: String

  """A URL used to redirect the customer to the bank's web page."""
  assetsUrl: String
}

"""An in-store location."""
type InStoreLocation {
  """Unique identifier."""
  id: ID!

  """Name of the in-store location."""
  name: String

  """The address of the in-store location."""
  address: InStoreLocationAddress
}

"""Input fields for an in-store location address."""
type InStoreLocationAddress {
  """The street address."""
  streetAddress: String

  """Extended address information, such as an apartment or suite number."""
  extendedAddress: String

  """Locality/city."""
  locality: String

  """State or province."""
  region: String

  """
  Postal code in any country's format, otherwise known as CAP, CEP, Eircode, NPA, PIN, PLZ, or ZIP code.
  """
  postalCode: String

  """Country code for the address in ISO 3166-1 alpha-3 format."""
  countryCode: CountryCodeAlpha3
}

"""Input fields for an in-store Location Address."""
input InStoreLocationAddressInput {
  """The street address."""
  streetAddress: String!

  """Extended address information, such as an apartment or suite number."""
  extendedAddress: String

  """Locality/city."""
  locality: String!

  """State or province."""
  region: String!

  """
  Postal code in any country's format, otherwise known as CAP, CEP, Eircode, NPA, PIN, PLZ, or ZIP code.
  """
  postalCode: String!

  """Country code for the address in ISO 3166-1 alpha-3 format."""
  countryCode: CountryCodeAlpha3!
}

"""Fields required for an instore location."""
input InStoreLocationInput {
  """Name of the Location."""
  name: String!

  """The address of the in-store Location."""
  address: InStoreLocationAddressInput!
}

"""An in-store payment card reader."""
type InStoreReader {
  """Unique identifier."""
  id: ID!

  """Name given to the reader."""
  name: String

  """Vendor-specific information about the reader."""
  vendor: InStoreReaderVendor

  """The in-store location the reader is attached to."""
  location: InStoreLocation

  """Current status of the reader."""
  status: ReaderStatus
}

"""Top-level fields returned for an in-store reader."""
type InStoreReaderPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The reader."""
  reader: InStoreReader
}

"""Fields that are reader specific for pairing a reader."""
input InStoreReaderSetupInput {
  """In-Store Location to attach Reader to."""
  locationId: ID!

  """Name given to the Reader."""
  name: String
}

"""A union of all possible in-store reader vendors."""
union InStoreReaderVendor = VerifoneVendor

"""Configuration for Kount fraud tools."""
type KountConfiguration {
  """
  The Kount merchant ID used to identify the fraud data collection request.
  """
  merchantId: String
}

"""
The type of object the legacy ID represents when converting it to a global ID.
"""
enum LegacyIdType {
  CUSTOMER
  DISPUTE
  MERCHANT_ACCOUNT_APPLICATION
  PAYMENT_METHOD
  REFUND
  TRANSACTION
  US_BANK_ACCOUNT_VERIFICATION
  VERIFICATION
}

"""Local payment specific details on a transaction."""
type LocalPaymentDetails {
  """
  Additional information about the local payment method provided from a
  third-party origin, such as PayPal or another regional payment method provider.
  """
  origin: PaymentMethodOrigin

  """Regional payment method selected by the customer."""
  type: LocalPaymentMethodType

  """Description of the payment method that can be displayed to customers."""
  displayName: String
}

"""A value identifying the type of regional payment method."""
enum LocalPaymentMethodType {
  ALIPAY
  BANCONTACT
  BLIK
  EPS
  GIROPAY
  IDEAL
  MYBANK
  P24
  PAYU
  SEPA
  SOFORT
  SWISH
  TRUSTLY
  VERKKOPANKKI
  VIPPS
  WECHAT_PAY
}

"""Configuration for Masterpass."""
type MasterpassConfiguration {
  """
  The Masterpass merchant checkout ID used to identify the merchant in Masterpass requests.
  """
  merchantCheckoutId: String

  """A list of card brands supported by the merchant for Masterpass."""
  supportedCardBrands: [CreditCardBrandCode!]
}

"""
Additional information about the payment method specific to Masterpass.
"""
type MasterpassOriginDetails {
  """
  The first 6 digits of the credit card, known as the Bank Identification
  Number. This BIN may differ from the BIN of the customer's actual card.
  """
  bin: String
}

"""Details about a merchant and its current settings."""
type Merchant {
  """Unique identifier."""
  id: ID!

  """Current status."""
  status: String

  """Company name."""
  companyName: String

  """The merchant's main website."""
  website: String

  """The timezone that the merchant operates in."""
  timezone: String
}

"""A record of a merchant account application."""
type MerchantAccountApplication {
  """
  A unique ID for the account application. Can be used to query the status of the onboarding request in the future.
  """
  id: ID!

  """Legacy unique ID."""
  legacyId: ID!

  """The status of the application."""
  status: ApplicationStatus
}

"""
Top-level fields returned when submitting an application for a merchant account.
"""
type MerchantAccountApplicationPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The Merchant Account Application."""
  merchantAccountApplication: MerchantAccountApplication
}

"""
An [ISO 18245](https://en.wikipedia.org/wiki/ISO_18245) Merchant Category Code. Four digits.
"""
scalar MerchantCategoryCode

"""A monetary amount with currency."""
type MonetaryAmount {
  """
  The amount of money, either a whole number or a number with up to 3 decimal places.
  """
  value: Amount

  """The ISO code for the money's currency."""
  currencyIsoCode: CurrencyCodeAlpha
}

"""Input fields for searching for a transaction or refund amount."""
input MonetaryAmountSearchInput {
  """Find transactions for a given amount."""
  value: SearchRangeInput

  """Find transactions with a given currency."""
  currencyIsoCode: SearchTextInput
}

"""A two-digit, zero-padded month."""
scalar Month

"""
The top-level Mutation type. Mutations are used to make requests that create or modify data.
"""
type Mutation {
  """
  Authorize an eligible payment method and return a payload that includes details of the resulting transaction.
  """
  authorizePaymentMethod(input: AuthorizePaymentMethodInput!): TransactionPayload

  """
  Authorize an eligible PayPal account and return a payload that includes details of the resulting transaction.
  """
  authorizePayPalAccount(input: AuthorizePayPalAccountInput!): PayPalTransactionPayload

  """
  Authorize an eligible Venmo account and return a payload that includes details of the resulting transaction.
  """
  authorizeVenmoAccount(input: AuthorizeVenmoAccountInput!): TransactionPayload

  """
  Authorize a credit card of any origin and return a payload that includes details of the resulting transaction.
  """
  authorizeCreditCard(input: AuthorizeCreditCardInput!): TransactionPayload

  """
  Capture an authorized transaction and return a payload that includes details of the transaction.
  """
  captureTransaction(input: CaptureTransactionInput!): TransactionPayload

  """
  Charge any payment method and return a payload that includes details of the resulting transaction.
  """
  chargePaymentMethod(input: ChargePaymentMethodInput!): TransactionPayload

  """
  Charge a US bank account and return a payload that includes details of the
  resulting transaction. See
  https://developers.braintreepayments.com/guides/ach/configuration for
  information on eligibility and setup.
  """
  chargeUsBankAccount(input: ChargeUsBankAccountInput!): TransactionPayload

  """
  Charge a PayPal account and return a payload that includes details of the resulting transaction.
  """
  chargePayPalAccount(input: ChargePayPalAccountInput!): PayPalTransactionPayload

  """
  Charge a Venmo account and return a payload that includes details of the
  resulting transaction. See
  https://articles.braintreepayments.com/guides/payment-methods/venmo for
  information on eligibility and setup.
  """
  chargeVenmoAccount(input: ChargeVenmoAccountInput!): TransactionPayload

  """
  Charge a credit card of any origin and return a payload that includes details of the resulting transaction.
  """
  chargeCreditCard(input: ChargeCreditCardInput!): TransactionPayload

  """
  Vault payment information from a single-use payment method and return a
  payload that includes a new multi-use payment method. When vaulting a credit
  card, by default, this mutation will also verify that card before vaulting.
  """
  vaultPaymentMethod(input: VaultPaymentMethodInput!): VaultPaymentMethodPayload

  """
  Vault payment information from a single-use US bank account payment method and
  return a payload that includes a new multi-use payment method.
  """
  vaultUsBankAccount(input: VaultUsBankAccountInput!): VaultPaymentMethodPayload

  """
  Vault payment information from a single-use credit card and return a payload
  that includes a new multi-use payment method. By default, this mutation will
  also verify the card before vaulting.
  """
  vaultCreditCard(input: VaultCreditCardInput!): VaultPaymentMethodPayload

  """
  Refund a settled transaction and return a payload that includes details of the refund.
  """
  refundTransaction(input: RefundTransactionInput!): RefundTransactionPayload

  """
  Reverse a transaction and return a payload that includes either the voided transaction or a refund.
  """
  reverseTransaction(input: ReverseTransactionInput!): ReverseTransactionPayload

  """Reverse a refund and return a payload that includes voided refund."""
  reverseRefund(input: ReverseRefundInput!): RefundTransactionPayload

  """
  Create a detached refund (unassociated with any previous Braintree payment) to
  a credit card and return a payload that includes details of the refund.
  
  We have previously referred to this as issuing a "detached credit," and it is
  disallowed by default. See the [documentation](https://articles.braintreepayments.com/control-panel/transactions/refunds-voids-credits#detached-credits)
  for more information regarding eligibility and configuration.
  """
  refundCreditCard(input: RefundCreditCardInput!): RefundCreditCardPayload

  """
  Update custom fields on a transaction. Custom fields are [defined in the Control Panel](https://articles.braintreepayments.com/control-panel/custom-fields#store-and-pass-back-fields).
  """
  updateTransactionCustomFields(input: UpdateTransactionCustomFieldsInput!): UpdateTransactionCustomFieldsPayload

  """Run a verification on a multi-use payment method."""
  verifyPaymentMethod(input: VerifyPaymentMethodInput!): VerifyPaymentMethodPayload

  """Run a verification on a multi-use credit card payment method."""
  verifyCreditCard(input: VerifyCreditCardInput!): VerifyPaymentMethodPayload

  """Run a verification on a multi-use US bank account payment method."""
  verifyUsBankAccount(input: VerifyUsBankAccountInput!): VerifyPaymentMethodPayload

  """
  Confirm micro-transfer amounts initiated by vaultUsBankAccount or
  verifyUsBankAccount, completing the verification process for a US Bank Account
  via micro-transfer.
  """
  confirmMicroTransferAmounts(input: ConfirmMicroTransferAmountsInput!): ConfirmMicroTransferAmountsPayload

  """Delete a multi-use payment method from the vault."""
  deletePaymentMethodFromVault(input: DeletePaymentMethodFromVaultInput!): DeletePaymentMethodFromVaultPayload

  """
  Create a client token that can be used to initialize a client in order to tokenize payment information.
  """
  createClientToken(input: CreateClientTokenInput): CreateClientTokenPayload

  """
  Partially capture funds from a transaction that was successfully authorized
  and return a payload that includes a new transaction with information about
  the capture. This is only available for PayPal transactions and certain use
  cases. For more information about if this mutation fits your use case [see our docs](https://articles.braintreepayments.com/guides/payment-methods/paypal/processing#multiple-partial-settlements).
  """
  partialCaptureTransaction(input: PartialCaptureTransactionInput!): PartialCaptureTransactionPayload

  """
  Tokenize Custom Actions fields and return a payload that includes a single-use payment method.
  """
  tokenizeCustomActionsPaymentMethod(input: TokenizeCustomActionsPaymentMethodInput!): TokenizeCustomActionsPaymentMethodPayload

  """
  Tokenize credit card fields and return a payload that includes a single-use payment method.
  """
  tokenizeCreditCard(input: TokenizeCreditCardInput!): TokenizeCreditCardPayload

  """
  Tokenize a credit card's CVV and return a payload that includes a single-use payment method.
  """
  tokenizeCvv(input: TokenizeCvvInput!): TokenizeCvvPayload

  """
  Tokenize a network tokenized payment instrument and return a payload that includes a single-use payment method.
  """
  tokenizeNetworkToken(input: TokenizeNetworkTokenInput!): TokenizeNetworkTokenPayload

  """
  Tokenize Samsung Pay card fields and return a payload that includes a single-use payment method.
  """
  tokenizeSamsungPayCard(input: TokenizeSamsungPayCardInput!): TokenizeSamsungPayCardPayload

  """
  Tokenize US bank account fields and return a payload that includes a single-use payment method.
  """
  tokenizeUsBankAccount(input: TokenizeUsBankAccountInput!): TokenizeUsBankAccountPayload

  """
  Tokenize US bank login fields and return a payload that includes a single-use payment method.
  """
  tokenizeUsBankLogin(input: TokenizeUsBankLoginInput!): TokenizeUsBankAccountPayload

  """
  Create a customer for storing individual customer information and/or grouping transactions and multi-use payment methods.
  """
  createCustomer(input: CreateCustomerInput): CreateCustomerPayload

  """Update a customer's information."""
  updateCustomer(input: UpdateCustomerInput!): UpdateCustomerPayload

  """
  Delete a customer, breaking association between any of the customer's
  transactions. Will not delete if the customer has existing payment methods.
  """
  deleteCustomer(input: DeleteCustomerInput!): DeleteCustomerPayload

  """Delete a payment method referenced by a single-use token."""
  deletePaymentMethodFromSingleUseToken(input: DeletePaymentMethodFromSingleUseTokenInput!): DeletePaymentMethodFromSingleUseTokenPayload @deprecated(reason: "Use `deletePaymentMethodFromVault` instead.")

  """
  Set a new billing address for a multi-use credit card payment method. By
  default, this mutation will also verify the card with the new billing address
  before updating.
  """
  updateCreditCardBillingAddress(input: UpdateCreditCardBillingAddressInput!): UpdateCreditCardBillingAddressPayload

  """
  Attempt to perform 3D Secure Authentication on credit card payment method.
  This may consume the payment method and return a new single-use payment method.
  """
  performThreeDSecureLookup(input: PerformThreeDSecureLookupInput!): PerformThreeDSecureLookupPayload

  """
  Accepts a dispute and returns a payload that includes the dispute that was
  accepted. Only disputes with a status of OPEN can be accepted.
  """
  acceptDispute(input: AcceptDisputeInput!): AcceptDisputePayload

  """
  Vault an existing PayPal Billing Agreement that was not created through
  Braintree. Only use this mutation if you need to import PayPal Billing
  Agreements from an existing PayPal integration into your Braintree account.
  """
  vaultPayPalBillingAgreement(input: VaultPayPalBillingAgreementInput!): VaultPayPalBillingAgreementPayload

  """
  Force a transaction to settle in the sandbox environment. Generates an error elsewhere.
  """
  sandboxSettleTransaction(input: SandboxSettleTransactionInput!): TransactionPayload

  """Creates a new In-Store Location to associate Readers."""
  createInStoreLocation(input: CreateInStoreLocationInput!): CreateInStoreLocationPayload

  """Pairs a Reader to an account and In-Store Location."""
  pairInStoreReader(input: PairInStoreReaderInput!): InStoreReaderPayload
}

"""Means by which customers by their bills."""
enum MVVAcceptanceChannel {
  FACE_TO_FACE
  MAIL
  PHONE
  WEB
}

"""Supported MVV (Merchant Verification Value) programs."""
enum MVVRegistrationType {
  LOAN_VPP
  TAX_DEBIT
  UTIL_RATE
  UTIL_VPP
}

"""Supported MVV (Merchant Verification Value) utility types."""
enum MVVUtilityType {
  ELECTRIC
  GAS
  TRASH
  WATER
}

"""Input fields for a network tokenized card."""
input NetworkTokenInput {
  """
  A one-time-use string generated by the token requester to validate the transaction.
  """
  cryptogram: String!

  """
  A two-digit string that should be passed along in the authorization message.
  """
  eCommerceIndicator: ECommerceIndicator!

  """A two-digit string representing the expiration month of the DPAN."""
  expirationMonth: Month!

  """A four-digit string representing the expiration year of the DPAN."""
  expirationYear: Year!

  """
  The card number used in processing. This is a device PAN (DPAN), not the backing card number (FPAN).
  """
  number: CreditCardNumber!
}

"""
Additional information about the payment method specific to Network Token.
"""
type NetworkTokenOriginDetails {
  """
  The first 6 digits of the credit card, known as the Bank Identification
  Number. This BIN may differ from the BIN of the customer's actual card.
  """
  bin: String
}

"""Relay compatible Node interface."""
interface Node {
  """Global ID for a given object."""
  id: ID!
}

"""Information about an OAuth Application."""
type OAuthApplication {
  """The unique identifier of the OAuth application."""
  clientId: String

  """The name of the OAuth application."""
  name: String
}

"""OAuth access token type."""
enum OAuthTokenType {
  BEARER
}

"""The owner's address type."""
enum OwnerAddressType {
  HOME
  MAILING
}

"""The type of identity number provided for the owner."""
enum OwnerIDType {
  SOCIAL_SECURITY_NUMBER
}

"""
An owner of the business. A minimum of one and a maximum of five owners can be
submitted. One owner must be the authorized signer on the account.
"""
input OwnerInput {
  """The role that the owner holds."""
  role: OwnerRole!

  """The position that the owner holds."""
  position: OwnerPosition!

  """The % of the business that the owner owns. Must be between 0 and 100."""
  ownershipPercentage: Int!

  """The owner's first name."""
  firstName: String!

  """The owner's last name."""
  lastName: String!

  """The owner's email address."""
  email: String!

  """The owner's address."""
  address: AddressInput!

  """The owner's address type."""
  addressType: OwnerAddressType!

  """The owner's date of birth. Format: YYYY-MM-DD."""
  dateOfBirth: Date

  """The country code for the owner's phone number."""
  phoneCountryCode: Int!

  """The owner's phone number. No extensions, numbers only."""
  phoneNumber: String!

  """The phone number type for the owner's phone number."""
  phoneType: OwnerPhoneType!

  """The owner's ID type. Required for authorized signer."""
  idType: OwnerIDType

  """The owner's ID number. Must be a valid US SSN or TIN."""
  idNumber: USTaxIdentificationNumber

  """The country that issued the owner's ID."""
  idIssuer: CountryCodeAlpha3
}

"""The owner's phone type."""
enum OwnerPhoneType {
  HOME
  MOBILE
}

"""The position that the owner holds in the business."""
enum OwnerPosition {
  BENEFICIAL_OWNER
  CHAIRMAN
  DIRECTOR
  PARTNER
  SECRETARY
  TREASURER
}

"""The role that the owner holds in the business."""
enum OwnerRole {
  BENEFICIAL_OWNER
  SIGNIFICANT_RESPONSIBILITY
}

"""The page information for a connection."""
type PageInfo {
  """Whether or not there is a next page available."""
  hasNextPage: Boolean!

  """
  Always false; backwards pagination is not supported. Present to comply with Relay specifications.
  """
  hasPreviousPage: Boolean!

  """The cursor for the first item in the connection page."""
  startCursor: String

  """The cursor for the last item in the connection page."""
  endCursor: String
}

"""Input fields for pairing an in store reader."""
input PairInStoreReaderInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """Code displayed on Reader during pairing."""
  userCode: String!

  """Inputs for Reader."""
  reader: InStoreReaderSetupInput!
}

"""
An original authorization's relationship to all its partial capture transactions.
"""
type ParentAuthorization {
  """The captures on a partially captured authorization."""
  childCaptures: [Transaction!]

  """
  The total amount authorized by this transaction. This amount will not change as this transaction is partially captured.
  """
  totalAmountAuthorized: MonetaryAmount
}

"""
A union of all possible relationships of transactions involved in partial
captures. If the transaction has been partially captured, this links to all its
partial capture children; if the transaction represents a partial capture
attempt, this links to the original parent authorization.
"""
union PartialCaptureDetails = ChildCapture | ParentAuthorization

"""
Top-level input fields for capturing outstanding funds authorized by a transaction.
"""
input PartialCaptureTransactionInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of the original authorized transaction to be partially captured."""
  transactionId: ID!

  """
  Input fields for the capture, with details that will define the resulting capture transaction.
  """
  transaction: PartialCaptureTransactionOptionsInput
}

"""
Input fields for the capture, with details that will define the resulting capture transaction.
"""
input PartialCaptureTransactionOptionsInput {
  """
  The amount to capture on the transaction against the parent authorization
  transaction. Must be greater than 0. You can perform multiple partial capture
  transactions as long as the cumulative amount of those transactions is less
  than or equal to the amount authorized by the parent transaction. You can't
  capture more than the authorized amount unless your industry and processor
  support settlement adjustment (capturing a certain percentage over the
  authorized amount); [contact us for assistance](https://help.braintreepayments.com?issue=TransactionProcessingQuestion).
  """
  amount: Amount!

  """
  Discount amount that was included in the total transaction amount. Does not
  add to the total amount the payment method will be charged. This value can't be negative.
  
  *Required for Level 3 processing*.
  """
  discountAmount: String

  """
  Line items for this transaction. Up to 249 line items may be specified.
  
  *Required for Level 3 processing*.
  """
  lineItems: [TransactionLineItemInput!]

  """
  Additional information about the transaction. On PayPal transactions, this
  field maps to the PayPal invoice number. PayPal invoice numbers must be unique
  in your PayPal business account. Maximum 255 characters or 127 for PayPal
  transactions. If specified, this will update the existing order ID on the transaction.
  """
  orderId: String

  """
  A purchase order identification value you associate with this transaction.
  
  *Required for Level 2 processing*.
  """
  purchaseOrderNumber: String

  """
  Shipping information.
  
  *Required for Level 3 processing*.
  """
  shipping: TransactionShippingInput

  """
  Tax information about the transaction.
  
  *Required for Level 2 processing*.
  """
  tax: TransactionTaxInput
}

"""Top-level output field from partially capturing a transaction."""
type PartialCaptureTransactionPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The transaction representing the partial capture."""
  capture: Transaction
}

"""
A merchant-initiated movement of money between the merchant and a customer, by
way of a payment method. Payments can represent money moving either from a
customer to the merchant by charging a payment method (a Transaction), or from
the merchant back to a customer by refunding a previous transaction (a Refund).
"""
interface Payment {
  """Unique identifier."""
  id: ID!

  """Legacy unique identifier."""
  legacyId: ID!

  """Date and time when the payment was created."""
  createdAt: Timestamp

  """
  The amount charged or credited to the payment method. Note that in the case of
  a Transaction, this amount will represent the amount moving from the customer
  to the merchant, and in the case of a Refund, will represent the amount moving
  from the merchant back to the customer.
  """
  amount: MonetaryAmount

  """The order ID."""
  orderId: String

  """The current status of this payment."""
  status: PaymentStatus

  """
  The records of all statuses this payment has passed through, with additional
  information on why each status occurred. Returned in reverse chronological
  order, with the most recent event first in the list.
  """
  statusHistory: [PaymentStatusEvent!]

  """The ID of the merchant account that processed this payment."""
  merchantAccountId: ID

  """How the payment was created."""
  source: PaymentSource
}

"""A paginated list of transactions and refunds."""
type PaymentConnection {
  """A list of transactions and refunds."""
  edges: [PaymentConnectionEdge]

  """
  Information about the page of transactions and refunds contained in `edges`.
  """
  pageInfo: PageInfo!
}

"""A transaction or refund within a PaymentConnection."""
type PaymentConnectionEdge {
  """
  This transaction or refund's location within the PaymentConnection. Used for requesting additional pages.
  """
  cursor: String

  """The transaction or refund."""
  node: Payment
}

"""
The initiator of the payment. Payment can either be merchant-initiated or customer-initiated.
"""
enum PaymentInitiator {
  MOTO
  RECURRING
  RECURRING_FIRST
  UNSCHEDULED
}

"""
The [payment-level fee report (formerly known as the transaction-level fee report)](https://articles.braintreepayments.com/control-panel/reporting/transaction-level-fee-report)
provides a breakdown of fees per individual payments (encompassing transactions and refunds).
"""
type PaymentLevelFeeReport {
  """The URL where you can access the requested report."""
  url: String
}

"""Top-level field representing a payment method."""
type PaymentMethod implements Node {
  """Unique identifier."""
  id: ID!

  """
  Legacy unique identifier. May be the same as ID for single-use payment methods.
  """
  legacyId: ID!

  """Whether a payment method may be used only once or multiple times."""
  usage: PaymentMethodUsage

  """Date and time when the payment method was vaulted."""
  createdAt: Timestamp

  """
  Details about the payment method specific to the type (e.g. credit card, PayPal account).
  """
  details: PaymentMethodDetails

  """
  A paginated list of verifications that have been run against the payment method.
  """
  verifications(first: Int, after: String): VerificationConnection

  """The customer that the payment method belongs to."""
  customer: Customer
}

"""A paginated list of payment methods."""
type PaymentMethodConnection {
  """A list of payment methods."""
  edges: [PaymentMethodConnectionEdge]

  """Information about the page of payment methods contained in `edges`."""
  pageInfo: PageInfo!
}

"""A payment method within a PaymentMethodConnection."""
type PaymentMethodConnectionEdge {
  """
  This payment method's location within the PaymentMethodConnection. Used for requesting additional pages.
  """
  cursor: String

  """The payment method."""
  node: PaymentMethod
}

"""
A union of all possible payment method details. PaymentMethodDetails contain
information for display purposes, payment method management, and processing.
"""
union PaymentMethodDetails = CustomActionsPaymentMethodDetails | CreditCardDetails | PayPalAccountDetails | SamsungPayCardDetails | VenmoAccountDetails | UsBankAccountDetails

"""
Information about how the customer provided a payment method, such as via a digital wallet.
"""
type PaymentMethodOrigin {
  """An enum identifying the origin of the payment method."""
  type: PaymentMethodOriginType

  """When available, additional details specific to the origin."""
  details: PaymentMethodOriginDetails
}

"""
A union of all possible payment method origin details.
PaymentMethodOriginDetails contain additional information specific to the third
party the payment method was provided by.
"""
union PaymentMethodOriginDetails = ApplePayOriginDetails | GooglePayOriginDetails | MasterpassOriginDetails | NetworkTokenOriginDetails | SamsungPayOriginDetails | VisaCheckoutOriginDetails | PayPalLocalPaymentOriginDetails

"""
A value identifying the third-party origin from which a customer provided their payment method.
"""
enum PaymentMethodOriginType {
  APPLE_PAY
  GOOGLE_PAY
  MASTERPASS
  NETWORK_TOKEN
  PAYPAL
  SAMSUNG_PAY
  VISA_CHECKOUT
}

"""
A union of all possible payment method details as they were used in a
transaction or verification. PaymentMethodSnapshot preserves values used to
create a given transaction or verify a payment method at that moment in time.
"""
union PaymentMethodSnapshot = CustomActionsPaymentMethodDetails | CreditCardDetails | PayPalTransactionDetails | VenmoAccountDetails | UsBankAccountDetails | LocalPaymentDetails | CreditCardTransactionDetails

"""
A value identifying the type of payment method used for a transaction. For
certain payment methods such as credit cards, this value also encodes the origin
from which a customer provided that payment method.
"""
enum PaymentMethodSnapshotSearchType {
  CREDIT_CARD
  CREDIT_CARD_VIA_APPLE_PAY
  CREDIT_CARD_VIA_GOOGLE_PAY
  CREDIT_CARD_VIA_MASTERPASS
  CREDIT_CARD_VIA_NETWORK_TOKEN
  CREDIT_CARD_VIA_SAMSUNG_PAY
  CREDIT_CARD_VIA_VISA_CHECKOUT
  PAYPAL
  US_BANK_ACCOUNT
  VENMO_ACCOUNT
}

"""Possible usages for payment methods."""
enum PaymentMethodUsage {
  MULTI_USE
  SINGLE_USE
}

"""
Input fields that specify options for verifying the vaulted payment method. Only
applicable for payment method types that suport verification.
"""
input PaymentMethodVerificationOptionsInput {
  """
  ID of the merchant account to use when verifying the payment method. The
  verification will use the default merchant account if this field is left blank.
  """
  merchantAccountId: ID

  """
  Whether to opt out of verifying the payment method. Defaults to `false` for
  payment methods that support verification. Clients should only pass `true` in
  the uncommon scenario that the payment method has been verified externally to Braintree.
  """
  skip: Boolean
}

"""
The network response.  When present, this field can provide additional detail
about why an authorization or verification was declined, but the
processorResponse should be considered the source of truth.
"""
type PaymentNetworkResponse {
  """
  The network response code for [authorizations](https://developers.braintreepayments.com/reference/response/transaction/#network-response-codes) or [verifications](https://developers.braintreepayments.com/reference/response/credit-card-verification#network-response-codes).
  """
  code: String

  """The network response text."""
  message: String
}

"""Input fields for searching for any type of Payment."""
input PaymentSearchInput {
  """Find payments with an ID or IDs."""
  id: SearchValueInput

  """
  Find payments by their type. Use this field to search for payments by the direction of money movement.
  """
  type: SearchPaymentTypeInput

  """Find payments with a given status."""
  status: SearchPaymentStatusInput

  """
  Find payments based on the time at which they transitioned to a given status.
  """
  statusTransition: SearchPaymentStatusTransitionInput

  """Find payments based on the time they were created."""
  createdAt: SearchTimestampInput

  """Find payments for a given amount or currency."""
  amount: MonetaryAmountSearchInput

  """Find payments with a given orderId."""
  orderId: SearchTextInput

  """Find payments processed through a merchant account ID or IDs."""
  merchantAccountId: SearchValueInput

  """
  Find payments by their disbursement date. Only use this search criteria if you
  have an eligible merchant account. Note that payments can only be disbursed
  after they reach the SETTLED status.
  """
  disbursementDate: SearchDateInput

  """Find payments created with a given source."""
  source: SearchPaymentSourceInput

  """
  Find payments created by a third party via the Grant API using a given OAuth application client ID.
  """
  facilitatorOAuthApplicationClientId: SearchValueInput
}

"""The type of a Payment, based primarily on implementing type."""
enum PaymentSearchType {
  """
  Only use this field if you have processed [detached credits](https://articles.braintreepayments.com/control-panel/transactions/refunds-voids-credits#detached-credits).
  The payment is a Refund, and represents a refund of a transaction not
  processed through your Braintree account.
  """
  DETACHED_REFUND

  """
  The payment is a Refund, and represents a refund of a transaction present in
  this Braintree account. Unless you have processed any [detached credits](https://articles.braintreepayments.com/control-panel/transactions/refunds-voids-credits#detached-credits),
  this type encompasses all refunds.
  """
  REFUND

  """The payment is a Transaction."""
  TRANSACTION
}

"""
The origin of a request that created or changed a transaction or refund.
"""
enum PaymentSource {
  API
  CONTROL_PANEL
  RECURRING
  UNKNOWN
}

"""
The status of the payment, indicating its success or failure, and where it is in its [lifecycle](https://articles.braintreepayments.com/get-started/transaction-lifecycle).
For further details on why any given status occurred, consult the corresponding
`PaymentStatusEvent` in the payment's `statusHistory`.
"""
enum PaymentStatus {
  """
  The transaction spent too much time in the `AUTHORIZED` status and was marked
  as expired. Expiration [time frames](https://developers.braintreepayments.com/reference/general/statuses#authorization-expired)
  differ by card type, transaction type, and, in some cases, merchant category.
  """
  AUTHORIZATION_EXPIRED

  """
  The processor authorized the transaction, putting your customer's funds on
  hold. Your customer may see a pending charge on his or her account. However,
  before the customer is actually charged and before you receive the funds, you
  must use the `captureTransaction` mutation. If you do not want to capture the
  transaction, you should use the `reverseTransaction` mutation to avoid a
  misuse of authorization fee.
  """
  AUTHORIZED

  """
  If a payment remains in a status of `AUTHORIZING`, [contact us for assistance](https://help.braintreepayments.com?issue=TransactionProcessingQuestion).
  """
  AUTHORIZING

  """
  An error occurred when sending the payment to the downstream processor. See
  the payment's `statusHistory` for the exact error.
  """
  FAILED

  """
  The transaction was [rejected](https://articles.braintreepayments.com/control-panel/transactions/gateway-rejections)
  based on one or more settings or rules in your Braintree gateway. See the
  transaction's `statusHistory` to determine which resulted in the decline.
  """
  GATEWAY_REJECTED

  """
  The processor declined the transaction while attempting to authorize it. See
  the transaction's `statusHistory` to determine what reason the processor gave
  for the decline.
  """
  PROCESSOR_DECLINED

  """
  The payment has been settled. For transactions, this means your customer has
  been charged and the process of disbursing the funds to your bank account has
  begun. For refunds, it means that the process of disbursing funds back to the
  customer has begun.
  """
  SETTLED
  SETTLEMENT_CONFIRMED @deprecated(reason: "No longer applicable to any supported payment method types.")

  """
  The processor declined the payment while attempting to capture it. See the
  payment's `statusHistory` to determine why it wasn't settled. This status is
  rare, and only certain types of transactions can be affected.
  """
  SETTLEMENT_DECLINED

  """
  The transaction has not yet fully settled. This status is rare, and will
  generally resolve to a status of `SETTLED`. Only certain types of transactions
  can be affected.
  """
  SETTLEMENT_PENDING

  """
  The payment is in the process of being settled. This is a transitory state, and will resolve to a status of `SETTLED`.
  """
  SETTLING

  """
  The payment has been successfully captured, and will be included in the next
  settlement batch, at which time it will become settled.
  """
  SUBMITTED_FOR_SETTLEMENT

  """
  The payment has been voided or canceled. For transactions, this means it's no
  longer authorized, your customer's funds are no longer on hold, and you can't
  use the `captureTransaction` mutation on this transaction. For refunds, it
  means the customer will not receive the funds from the refund.
  """
  VOIDED
}

"""
Status event in the [lifecycle of a payment](https://articles.braintreepayments.com/get-started/transaction-lifecycle).
"""
interface PaymentStatusEvent {
  """New status of the payment."""
  status: PaymentStatus

  """Date and time when the status event occurred."""
  timestamp: Timestamp

  """
  The payment amount applicable to the status. For instance, the amount when a
  transaction is `SUBMITTED_FOR_SETTLEMENT` might be less than the amount for
  which it was `AUTHORIZED`.
  """
  amount: MonetaryAmount

  """Source that caused the status event to occur."""
  source: PaymentSource

  """
  Whether this is the final state for the payment. If false, this transaction will pass into another subsequent state.
  """
  terminal: Boolean
}

"""Details about a PayPal account."""
type PayPalAccountDetails {
  """The ID of the billing agreement for this PayPal account."""
  billingAgreementId: String

  """The billing address associated with the PayPal account."""
  billingAddress: Address

  """The email address associated with the PayPal account."""
  email: String

  """The PayPal ID of the PayPal account."""
  payerId: String

  """The first name on the PayPal account."""
  firstName: String

  """The last name on the PayPal account."""
  lastName: String

  """The label of the co-branded card used as a funding source."""
  cobrandedCardLabel: String

  """
  Additional information if the PayPal account was provided from a third-party
  origin, such as Apple Pay, Google Pay, or another digital wallet.
  """
  origin: PaymentMethodOrigin
}

"""Input for identifying a PayPal account."""
input PayPalAccountInput {
  """The unique PayPal ID of the PayPal account."""
  payerId: ID
}

"""Configuration for PayPal."""
type PayPalConfiguration {
  """
  The merchant's company name for displaying to customers in the PayPal UI.
  """
  displayName: String

  """The merchant's PayPal client ID."""
  clientId: String

  """The merchant's privacy policy URL."""
  privacyUrl: String

  """The merchant's user agreement URL."""
  userAgreementUrl: String

  """
  A URL pointing to the base path of Braintree's web pages used for various browser switches and popups.
  """
  assetsUrl: String

  """The PayPal environment."""
  environment: PayPalEnvironment

  """For internal use only."""
  environmentNoNetwork: Boolean @deprecated(reason: "This field is only included for internal testing purposes.")

  """Whether or not the merchant has been vetted."""
  unvettedMerchant: Boolean

  """Braintree's PayPal client ID."""
  braintreeClientId: String

  """
  Whether billing agreements are enabled and should be used instead of future payments.
  """
  billingAgreementsEnabled: Boolean

  """
  The merchant account being used. This affects the currency code and other options.
  """
  merchantAccountId: String

  """The currency code to use."""
  currencyCode: CurrencyCodeAlpha

  """
  The email address of the PayPal account that will receive the funds when a transaction is created.
  """
  payeeEmail: String

  """For internal use only."""
  directBaseUrl: String @deprecated(reason: "This field is only included for internal testing purposes.")
}

"""The environment being used for PayPal."""
enum PayPalEnvironment {
  CUSTOM
  LIVE
  OFFLINE
  custom
  live
  offline
}

"""
Additional information about the local payment method specific to PayPal.
"""
type PayPalLocalPaymentOriginDetails {
  """
  If funds for the transaction have settled, the PayPal ID for the capture of funds.
  """
  captureId: String

  """A string of field/value pairs passed directly to PayPal."""
  customField: String

  """The identification value of the payment within PayPal's API."""
  paymentId: String

  """The fee charged by PayPal for the transaction."""
  transactionFee: MonetaryAmount
}

"""PayPal local payment specific refund details."""
type PayPalLocalPaymentRefundDetails {
  """The PayPal refund ID."""
  refundId: String

  """Refunded transaction fee charged by PayPal."""
  refundedFee: MonetaryAmount
}

"""Input fields for a PayPal account receiving transaction funds."""
input PayPalPayeeOptionsInput {
  """The email address associated with the payee PayPal account."""
  email: String
}

"""PayPal-specific refund details."""
type PayPalRefundDetails {
  """The PayPal refund ID."""
  refundId: String

  """Refunded transaction fee charged by PayPal."""
  refundedFee: MonetaryAmount
}

"""PayPal-specific details on a transaction."""
type PayPalTransactionDetails {
  """
  If the transaction was successfully authorized, the PayPal ID for the authorization.
  """
  authorizationId: String

  """
  If funds for the transaction have settled, the PayPal ID for the capture of funds.
  """
  captureId: String

  """A string of field/value pairs passed directly to PayPal."""
  customField: String

  """Details about the payer or owner of the PayPal account."""
  payer: PayPalAccountDetails

  """Details about the PayPal account that received the funds."""
  payee: PayPalAccountDetails

  """Whether or not the PayPal account has been verified by PayPal."""
  payerStatus: String

  """The identification value of the payment within PayPal's API."""
  paymentId: String

  """If the transaction is a refund, the PayPal refund ID."""
  refundId: String @deprecated(reason: "This field will never be populated as it only appears on refunds. Use `details.paypalId` on a refund instead.")

  """Whether or not the transaction qualifies for PayPal Seller Protection."""
  sellerProtectionStatus: String

  """Payer's tax ID. Only returned for payments from Brazilian accounts."""
  taxId: String

  """
  Payer's tax ID type. Only returned for payments from Brazilian accounts. Allowed values BR_CPF or BR_CNPJ.
  """
  taxIdType: String

  """The fee charged by PayPal for the transaction."""
  transactionFee: MonetaryAmount

  """The fee charged by PayPal for the transaction."""
  transactionFeeAmount: String @deprecated(reason: "Use `transactionFee.value` instead.")

  """The currency code for the currency of the PayPal transaction fee."""
  transactionFeeCurrencyIsoCode: String @deprecated(reason: "Use `transactionFee.currencyIsoCode` instead.")

  """
  Description of the transaction that is displayed to customers in PayPal email receipts.
  """
  description: String

  """
  Additional information if the credit card was provided from a third-party origin, such as Google Pay.
  """
  origin: PaymentMethodOrigin
}

"""Top-level output field from creating a PayPal transaction."""
type PayPalTransactionPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The transaction representing the charge on the payment method."""
  transaction: Transaction

  """
  If the paymentMethodId passed to this mutation was a single-use PayPal payment
  method created with the [Billing Agreement with Purchase flow](https://developers.braintreepayments.com/guides/paypal/checkout-with-paypal/javascript/v3#checkout-using-paypal-billing-agreement-with-purchase-flow),
  then this field will be populated with a multi-use PayPal payment method
  created alongside the transaction. Otherwise, this will be null.
  """
  billingAgreementWithPurchasePaymentMethod: PaymentMethod
}

"""A key-value pair for a PayPal SetTransactionContext field."""
input PayPalTransactionRiskContextDataFieldInput {
  """
  The name of the field. Must correspond exactly to the PayPal key/field name.
  """
  name: String

  """The value of the field. Maximum 4000 characters."""
  value: String
}

"""
Input fields setting the PayPal transaction context for risk assessment. In
order to use this, your PayPal account must be set up to use the PayPal
SetTransactionContext feature.
"""
input PayPalTransactionRiskContextInput {
  """Provide a maximum of 100 fields."""
  fields: [PayPalTransactionRiskContextDataFieldInput!]
}

"""Top-level fields for performing a 3D Secure Lookup."""
input PerformThreeDSecureLookupInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """
  ID of the merchant account that will be used when charging the payment method.
  """
  merchantAccountId: ID

  """
  Reference ID used by our MPI provider CardinalCommerce to connect the lookup
  request to the device data that was previously collected.
  """
  dfReferenceId: String

  """The ID of a single-use payment method to perform the lookup on."""
  paymentMethodId: ID!

  """
  The amount you plan to charge the payment method after the 3D Secure authentication.
  """
  amount: Amount!

  """
  Additional information about the transaction when authenticating through 3D Secure.
  """
  transactionInformation: ThreeDSecureLookupTransactionInformationInput

  """
  Additional information about the cardholder when authenticating through 3D Secure.
  """
  cardholderInformation: ThreeDSecureLookupCardholderInformationInput

  """
  When set to true, requests a 3D Secure authentication challenge from the
  issuer. A challenge will result in the acsUrl field being populated on the
  response, requiring you to open the challenge on the client side.
  """
  requestAuthenticationChallenge: Boolean

  """Information about the client-side lookup process."""
  clientInformation: ThreeDSecureLookupClientInformationInput
}

"""Top-level fields returned when performing a 3D Secure Lookup."""
type PerformThreeDSecureLookupPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """
  Data fields containing information from the MPI provider about the 3D Secure Lookup result.
  """
  threeDSecureLookupData: ThreeDSecureLookupData

  """A single-use payment method."""
  paymentMethod: PaymentMethod
}

"""
Top-level fields returned when fetching a customer's preferred payment methods.
"""
type PreferredPaymentMethodsPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """
  Probabilistic determination of whether Venmo is a preferred payment method.
  """
  venmoPreferred: Boolean

  """
  Probabilistic determination of whether PayPal is a preferred payment method.
  """
  paypalPreferred: Boolean
}

"""Accompanying information for a processor declined transaction."""
type ProcessorDeclinedEvent implements PaymentStatusEvent {
  """The new status of the transaction."""
  status: PaymentStatus

  """Date and time when the transaction was declined by the processor."""
  timestamp: Timestamp

  """The amount of the transaction for this status event."""
  amount: MonetaryAmount

  """The source for the transaction change to the new status."""
  source: PaymentSource

  """Whether or not the decline is the result of a temporary issue."""
  declineType: ProcessorDeclineType

  """
  Fields describing the payment processor response and why they declined the transaction.
  """
  processorResponse: TransactionAuthorizationProcessorResponse

  """Fields describing the network response to the authorization request."""
  networkResponse: PaymentNetworkResponse

  """Risk decision for this transaction."""
  riskDecision: RiskDecision

  """Whether or not this is the final state for the transaction."""
  terminal: Boolean
}

"""
Whether the decline is likely to be temporary or persistent. Can be taken into
consideration when determining whether to retry a declined charge.
"""
enum ProcessorDeclineType {
  """
  Hard declines are the result of an error or issue which can't be resolved
  immediately; the decline is not temporary and subsequent charges on the same
  payment method will likely not be successful.
  """
  HARD

  """
  Soft declines result from a temporary issue and can be retried; subsequent
  charges on the same payment method may be successful.
  """
  SOFT
}

"""The top-level Query type. Queries are used to fetch data."""
type Query {
  """Returns the literal string 'pong'."""
  ping: String!

  """The currently authenticated viewer."""
  viewer: Viewer

  """The client-side environment and payment method configuration."""
  clientConfiguration: ClientConfiguration

  """Fetch any object that extends the Node interface using its ID."""
  node(id: ID!): Node

  """
  Get a GraphQL ID from a legacy ID that was returned from an SDK or a legacyId
  field. Does not verify existence except for payment methods.
  """
  idFromLegacyId(legacyId: ID!, type: LegacyIdType!): ID!

  """The available reports."""
  report: Report

  """The available searches."""
  search: Search
}

"""Indicates the status of a Reader."""
enum ReaderStatus {
  OFFLINE
  ONLINE
}

"""The type of recurring payment a transaction represents."""
enum RecurringType {
  FIRST
  SUBSEQUENT
  UNSCHEDULED
}

"""
A refund of a charge on a payment method, representing an attempt to send money
from a previous transaction back to the customer.
"""
type Refund implements Node & Payment {
  """Unique identifier."""
  id: ID!

  """Legacy unique identifier."""
  legacyId: ID!

  """Date and time when the refund was created."""
  createdAt: Timestamp

  """
  The amount that will be refunded, which can be less than or equal to the original charge amount.
  """
  amount: MonetaryAmount

  """
  The order ID for this refund. For PayPal transactions, the PayPal Invoice ID.
  """
  orderId: String

  """The current status of this refund."""
  status: PaymentStatus

  """
  The records of all statuses this refund has passed through, with additional
  information on why each status occurred. Returned in reverse chronological
  order, with the most recent event first in the list.
  """
  statusHistory: [PaymentStatusEvent!]

  """Payment method specific details about the refund."""
  details: RefundPaymentMethodDetails

  """The ID of the merchant account that processed this refund."""
  merchantAccountId: ID

  """How the refund was created."""
  source: PaymentSource

  """
  The original transaction that this refunds. If this is not present, then this
  refund represents a refund of a transaction that does not belong to this
  Braintree gateway account.
  """
  refundedTransaction: Transaction

  """
  Snapshot of payment method details that will receive the refund, typically
  based on the original transaction. This will always be present. Equivalent to
  `refundedTransaction.paymentMethodSnapshot`.
  """
  paymentMethodSnapshot: PaymentMethodSnapshot

  """
  The multi-use payment method that will receive the refund. Only present if a
  multi-use payment method was used to create the original transaction and it
  has not been since deleted. The details of this PaymentMethod may have changed
  since the transaction was created; details used for the transaction can be
  found in the `paymentMethodSnapshot` field. Equivalent to
  `refundedTransaction.paymentMethod` (if present).
  """
  paymentMethod: PaymentMethod

  """
  The customer that the vaulted payment method (if it exists) belongs to.
  Equivalent to `refundedTransaction.customer` (if present).
  """
  customer: Customer

  """Line items for this refund."""
  lineItems: [TransactionLineItem!]
}

"""A paginated list of refunds."""
type RefundConnection {
  """A list of refunds."""
  edges: [RefundConnectionEdge]

  """Information about the page of refunds contained in `edges`."""
  pageInfo: PageInfo!
}

"""A transaction within a RefundConnection."""
type RefundConnectionEdge {
  """
  This refund's location within the RefundConnection. Used for requesting additional pages.
  """
  cursor: String

  """The refund."""
  node: Refund
}

"""Top-level input fields for creating a detached refund."""
input RefundCreditCardInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of the credit card to be refunded."""
  paymentMethodId: ID!

  """Input fields containing details about the refund."""
  refund: DetachedRefundInput!
}

"""
Top-level output field from creating a detached refund for a credit card.
"""
type RefundCreditCardPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The information about the created refund."""
  refund: Refund
}

"""Specific input fields for describing a refund."""
input RefundInput {
  """
  The amount to refund. Must be less than or equal to the amount of the original
  transaction. Defaults to the total amount of the original transaction.
  """
  amount: Amount

  """
  The refund's order ID. Defaults to the order ID of the original transaction.
  """
  orderId: String

  """
  Line items for this refund. Up to 249 line items may be specified.
  
  Only allowed for Custom Actions transactions.
  """
  lineItems: [TransactionLineItemInput!]
}

"""A union of all possible payment method refund details."""
union RefundPaymentMethodDetails = PayPalRefundDetails | PayPalLocalPaymentRefundDetails

"""Supported refund policies."""
enum RefundPolicy {
  EXCHANGE_ONLY
  NO_REFUND_OR_EXCHANGE
  REFUND_CARDHOLDER
}

"""Input fields for searching for refunds."""
input RefundSearchInput {
  """Find refunds with an ID or IDs."""
  id: SearchValueInput

  """Find refunds with the given status."""
  status: SearchTransactionStatusInput

  """
  Find payments based on the time at which they transitioned to a given status.
  """
  statusTransition: SearchPaymentStatusTransitionInput

  """Find refunds based on the time they were created."""
  createdAt: SearchTimestampInput

  """Find refunds with a given amount or currency."""
  amount: MonetaryAmountSearchInput

  """Find refunds with a given orderId."""
  orderId: SearchTextInput

  """
  Find refunds processed through a merchant account ID or IDs. In most cases,
  this will be the merchant account of the original refunded transaction.
  """
  merchantAccountId: SearchValueInput

  """
  Find refunds by their disbursement date. Only use this search criteria if you
  have an eligible merchant account. Note that refunds can only be disbursed
  after they reach the SETTLED status.
  """
  disbursementDate: SearchDateInput

  """Find refunds created with a given source."""
  source: SearchPaymentSourceInput

  """
  Find refunds created by a third party via the Grant API using a given OAuth application client ID.
  """
  facilitatorOAuthApplicationClientId: SearchValueInput
}

"""Top-level input fields for refunding a transaction."""
input RefundTransactionInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The ID of a transaction to be refunded."""
  transactionId: ID!

  """Input fields for the details of the refund."""
  refund: RefundInput
}

"""Top-level output field from refunding a transaction."""
type RefundTransactionPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The information about the created refund."""
  refund: Refund
}

"""Top-level fields returned for a report query."""
type Report {
  """Top-level fields returned in the transaction-level fee report query."""
  transactionLevelFees(date: Date!, merchantAccountId: ID): TransactionLevelFeeReport @deprecated(reason: "This report has been renamed `paymentLevelFees`, since it applies to all types in the Payment interface, including transactions and refunds. Use the `paymentLevelFees` field instead, which returns the same report.")

  """Top-level fields returned in the payment-level fee report query."""
  paymentLevelFees(date: Date!, merchantAccountId: ID): PaymentLevelFeeReport
}

"""Input fields for reversing a refund."""
input ReverseRefundInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The ID of the refund to reverse."""
  refundId: ID!
}

"""Input fields for reversing a transaction."""
input ReverseTransactionInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The ID of the transaction to reverse."""
  transactionId: ID!
}

"""Top-level output field for reversing a transaction."""
type ReverseTransactionPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """
  A transaction (if the original transaction was voided) or refund (if the
  original transaction was refunded). A reversal will attempt to void the
  original transaction if it has not yet settled. If the original transaction
  has settled, a reversal will create a refund for the full amount.
  """
  reversal: TransactionReversal
}

"""A right assigned to a user."""
type Right {
  """A human-readable name."""
  name: String
}

"""Data from advanced risk evaluations."""
type RiskData {
  """Unique identifier."""
  id: ID

  """The risk decision on whether the transaction should be permitted."""
  decision: RiskDecision

  """
  Whether data associated with the customer's device was captured and used in the decision process.
  """
  deviceDataCaptured: Boolean

  """The third-party provider used to generate the risk decision."""
  fraudServiceProvider: FraudServiceProvider
}

"""Input fields for a risk data object."""
input RiskDataInput {
  """
  The User-Agent header provided by the customer's browser, which gives
  information about the browser. Maximum 255 characters.
  """
  customerBrowser: String

  """The customer's IP address."""
  customerIp: String

  """
  Customer device information. Required when creating transactions using cards
  (only if using Advanced Fraud Tools), PayPal (only for one-time Vaulted PayPal
  transactions), and Venmo payment method types. This value will contain a Fraud
  Merchant ID as the unique, numeric identifier for a Kount account and a Device
  Session ID as the unique identifier for a customer device. For PayPal and
  Venmo transactions, this value will also include a PayPal Correlation ID.
  """
  deviceData: String
}

"""
The risk decision provides further context on how a transaction was scored for risk by Braintree.
"""
enum RiskDecision {
  APPROVE
  DECLINE
  NOT_EVALUATED
  REVIEW
}

"""Groups of rights assigned to the user."""
type Role {
  """Unique identifier."""
  id: ID!

  """A human-readable name."""
  name: String

  """Whether the role grants account admin status."""
  isAccountAdmin: Boolean

  """The rights associated with the role."""
  rights: [Right!]
}

"""Details about a Samsung Pay card."""
type SamsungPayCardDetails {
  """The display name of the card brand, e.g. "Visa" or "American Express"."""
  brand: String

  """
  A static code identifying the card brand of the FPAN (the customer's actual backing card).
  """
  brandCode: CreditCardBrandCode

  """
  The first 6 digits of the credit card, known as the Bank Identification
  Number. This BIN will differ from the BIN of the source (customer's actual) card.
  """
  bin: String

  """
  Information about the card based on its BIN. This BIN will differ from the BIN of the source (customer's actual) card.
  """
  binData: BinRecord

  """The last four digits of the FPAN (the customer's actual backing card)."""
  sourceCardLast4: CreditCardLast4
}

"""Input fields for a Samsung Pay card."""
input SamsungPayCardInput {
  """
  A one-time-use string generated by the token requester to validate the transaction.
  """
  cryptogram: String!

  """
  A two-digit string that should be passed along in the authorization message.
  """
  eCommerceIndicator: ECommerceIndicator!

  """A two-digit string representing the expiration month of the DPAN."""
  expirationMonth: Month!

  """A four-digit string representing the expiration year of the DPAN."""
  expirationYear: Year!

  """
  The card number provided by Samsung and used in processing. This is a
  digitized PAN (DPAN), not the backing card number (FPAN).
  """
  number: CreditCardNumber!

  """The last four digits of the FPAN (the cardholder's backing card)."""
  sourceCardLast4: CreditCardLast4!
}

"""Configuration for Samsung Pay on Android."""
type SamsungPayConfiguration {
  """A string used to identify the merchant to the customer."""
  displayName: String

  """The Samsung Pay environment."""
  environment: SamsungPayEnvironment

  """The Samsung Pay service ID."""
  serviceId: String

  """Authorization to use when tokenizing Samsung Pay."""
  samsungAuthorization: String

  """A list of card brands supported by the merchant for Samsung Pay."""
  supportedCardBrands: [CreditCardBrandCode!]
}

"""The environment being used for Samsung Pay."""
enum SamsungPayEnvironment {
  PRODUCTION
  SANDBOX
}

"""
Additional information about the payment method specific to Samsung Pay.
"""
type SamsungPayOriginDetails {
  """
  The first 6 digits of the credit card, known as the Bank Identification
  Number. This BIN may differ from the BIN of the customer's actual card.
  """
  bin: String
}

"""
Top-level input fields for settling a transaction in the sandbox environment.
"""
input SandboxSettleTransactionInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """Id of the transaction to force settlement in the sandbox environment."""
  transactionId: ID!
}

"""Top-level fields returned for a search query."""
type Search {
  """
  A paginated list of transactions that match the TransactionSearchInput.
  """
  transactions(input: TransactionSearchInput!, first: Int, after: String): TransactionConnection

  """A paginated list of refunds that match the RefundSearchInput."""
  refunds(input: RefundSearchInput!, first: Int, after: String): RefundConnection

  """
  A paginated list of all types of Payment that match the PaymentSearchInput.
  """
  payments(input: PaymentSearchInput!, first: Int, after: String): PaymentConnection

  """A paginated list of disputes that match the DisputeSearchInput."""
  disputes(input: DisputeSearchInput!, first: Int, after: String): DisputeConnection

  """
  A paginated list of verifications that match the VerificationSearchInput.
  """
  verifications(input: VerificationSearchInput!, first: Int, after: String): VerificationConnection

  """A paginated list of customers that match the CustomerSearchInput."""
  customers(input: CustomerSearchInput!, first: Int, after: String): CustomerConnection
}

"""Input fields for searching transactions by customer."""
input SearchCustomerInput {
  """Find transactions with a given customer ID."""
  id: SearchValueInput
}

"""
Input fields for searching for a date. These ranges are precise to the day.
"""
input SearchDateInput {
  """Date is greater than or equal to this value."""
  greaterThanOrEqualTo: Date

  """Date is less than or equal to this value."""
  lessThanOrEqualTo: Date
}

"""
Input fields for searching for a dispute with a given reason description.
"""
input SearchDisputeReasonInput {
  """The dispute reason is one of these values."""
  in: [DisputeReason!]
}

"""Input fields for searching for a dispute with a given status."""
input SearchDisputeStatusInput {
  """The dispute status is exactly this value."""
  is: DisputeStatus

  """The dispute status is one of these values."""
  in: [DisputeStatus!]
}

"""Input fields for searching for a dispute with a given type."""
input SearchDisputeTypeInput {
  """The dispute type is exactly this value."""
  is: DisputeType

  """The dispute type is one of these values."""
  in: [DisputeType!]
}

"""
Input fields for searching transactions by payment method snapshot type.
"""
input SearchPaymentMethodSnapshotTypeInput {
  """
  This value represents the payment method type used to create a transaction. In
  the case of credit cards, this value also encode the origin from which a
  customer provided that payment method.
  """
  is: PaymentMethodSnapshotSearchType

  """
  These values represent the payment method type used to create a transaction.
  In the case of credit cards, these values also encode the origin from which a
  customer provided that payment method.
  """
  in: [PaymentMethodSnapshotSearchType!]
}

"""
Input fields for searching for a transaction or refund created with a given source.
"""
input SearchPaymentSourceInput {
  """The transaction source is one of these values."""
  in: [PaymentSource!]
}

"""
Input fields for searching for a transaction or refund with a given status.
"""
input SearchPaymentStatusInput {
  """The transaction status is one of these values."""
  in: [PaymentStatus!]
}

"""Payment status transition times."""
input SearchPaymentStatusTransitionInput {
  """Find transactions with a given failed at time."""
  failedAt: SearchTimestampInput

  """Find transactions with a given settled at time."""
  settledAt: SearchTimestampInput

  """Find transactions with a given submitted for settlement time."""
  submittedForSettlementAt: SearchTimestampInput

  """Find transactions with a given voided at time."""
  voidedAt: SearchTimestampInput
}

"""Input fields for searching for payments by implementing type."""
input SearchPaymentTypeInput {
  """The payment is a transaction and/or a refund."""
  in: [PaymentSearchType!]
}

"""Input fields for searching for a range."""
input SearchRangeInput {
  """Field is exactly this value."""
  is: String

  """Field is greater than or equal to this value."""
  greaterThanOrEqualTo: String

  """Field is less than or equal to this value."""
  lessThanOrEqualTo: String
}

"""Input fields for searching text fields."""
input SearchTextInput {
  """Field is exactly this value."""
  is: String

  """Field is not this value."""
  isNot: String

  """Field starts with this value."""
  startsWith: String

  """Field ends with this value."""
  endsWith: String

  """Field contains this value."""
  contains: String
}

"""
Input fields for searching by timestamp. These ranges are precise to the minute;
the results of searching for an object created between 12/17/2015 17:00 and
12/17/2015 17:00 (i.e., the same minute) will include objects created at
12/17/2015 17:00:59. If no timezone is provided, it will be assumed to be UTC.
"""
input SearchTimestampInput {
  """Timestamp is greater than or equal to this value."""
  greaterThanOrEqualTo: Timestamp

  """Timestamp is less than or equal to this value."""
  lessThanOrEqualTo: Timestamp
}

"""
Input fields for searching for a transaction created with a given source.
"""
input SearchTransactionSourceInput {
  """The transaction source is one of these values."""
  in: [PaymentSource!]
}

"""Input fields for searching for a transaction with a given status."""
input SearchTransactionStatusInput {
  """The transaction status is exactly this value."""
  is: PaymentStatus

  """The transaction status is one of these values."""
  in: [PaymentStatus!]
}

"""Transaction status transition times."""
input SearchTransactionStatusTransitionInput {
  """Find transactions with a given failed at time."""
  failedAt: SearchTimestampInput

  """Find transactions with a given settled at time."""
  settledAt: SearchTimestampInput

  """Find transactions with a given submitted for settlement time."""
  submittedForSettlementAt: SearchTimestampInput

  """Find transactions with a given voided at time."""
  voidedAt: SearchTimestampInput
}

"""Input fields for searching for specific values."""
input SearchValueInput {
  """Field is exactly this value."""
  is: String

  """Field is one of these values."""
  in: [String!]
}

"""Input fields for searching for a verification with a given status."""
input SearchVerificationStatusInput {
  """The verification status is exactly this value."""
  is: VerificationStatus

  """The verification status is one of these values."""
  in: [VerificationStatus!]
}

"""Accompanying information for a settled transaction."""
type SettledEvent implements PaymentStatusEvent {
  """The new status of the transaction."""
  status: PaymentStatus

  """Date and time when the transaction was settled."""
  timestamp: Timestamp

  """
  The amount the transaction was settled for, in the same currency as the
  original authorization (aka the "presentment" currency.) If you have elected
  to settle the transaction into a bank account with a different currency, this
  will not reflect that.
  """
  amount: MonetaryAmount

  """The source for the transaction change to the new status."""
  source: PaymentSource

  """Fields describing the payment processor response."""
  processorResponse: TransactionSettlementProcessorResponse

  """Whether or not this is the final state for the transaction."""
  terminal: Boolean

  """The ID of the settlement batch in which the transaction was processed."""
  settlementBatchId: String
}

"""Accompanying information for a settlement declined transaction."""
type SettlementDeclinedEvent implements PaymentStatusEvent {
  """The new status of the transaction."""
  status: PaymentStatus

  """Date and time when the processor declined to settle this transaction."""
  timestamp: Timestamp

  """The amount of the transaction for this status event."""
  amount: MonetaryAmount

  """The source for the transaction change to the new status."""
  source: PaymentSource

  """
  Fields describing the payment processor response to the settlement request.
  """
  processorResponse: TransactionSettlementProcessorResponse

  """Whether or not this is the final state for the transaction."""
  terminal: Boolean
}

"""
Accompanying information for a settlement pending transaction. This typically only occurs for PayPal transactions.
"""
type SettlementPendingEvent implements PaymentStatusEvent {
  """The new status of the transaction."""
  status: PaymentStatus

  """Date and time when the transaction became settlement pending."""
  timestamp: Timestamp

  """The amount of the transaction for this status event."""
  amount: MonetaryAmount

  """The source for the transaction change to the new status."""
  source: PaymentSource

  """
  Fields describing the payment processor response to the settlement request.
  """
  processorResponse: TransactionSettlementProcessorResponse

  """Whether or not this is the final state for the transaction."""
  terminal: Boolean
}

"""
Accompanying information for a transaction that is settling. This is typically a
transient state during which the transaction is being settled with the processor.
"""
type SettlingEvent implements PaymentStatusEvent {
  """The new status of the transaction."""
  status: PaymentStatus

  """Date and time when the transaction began settling."""
  timestamp: Timestamp

  """
  The amount of the transaction for this status event. This should match the amount submitted for settlement.
  """
  amount: MonetaryAmount

  """The source for the transaction change to the new status."""
  source: PaymentSource

  """Whether or not this is the final state for the transaction."""
  terminal: Boolean
}

"""Input fields for submitting a credit card for Account Updater."""
input SubmitCreditCardForAccountUpdaterInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of the credit card to submit for Account Updater."""
  paymentMethodId: ID!
}

"""
Top-level fields returned when submitting a credit card for Account Updater.
"""
type SubmitCreditCardForAccountUpdaterPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The credit card that was submitted to Account Updater."""
  paymentMethod: PaymentMethod
}

"""
Accompanying information for a transaction that is submitted for settlement.
This status indicates that the transaction is scheduled to be settled.
"""
type SubmittedForSettlementEvent implements PaymentStatusEvent {
  """The new status of the transaction."""
  status: PaymentStatus

  """Date and time when the transaction was submitted for settlement."""
  timestamp: Timestamp

  """
  The amount that was submitted for settlement. This can differ from the authorized amount, but by default is the same.
  """
  amount: MonetaryAmount

  """The source for the transaction change to the new status."""
  source: PaymentSource

  """Whether or not this is the final state for the transaction."""
  terminal: Boolean
}

"""
Data fields for a payment method that has been authenticated using 3D Secure.
"""
type ThreeDSecureAuthentication {
  """
  The cardholder authentication verification value. This value should be
  appended to the authorization message signifying that the transaction has been
  successfully authenticated with 3D Secure. This value will be encoded
  according to the merchant's configuration with CardinalCommerce, with either
  Base64 or Hex encoding. The decoded value will be of different length and
  format per card scheme.
  """
  cavv: String

  """
  A unique identifier for the 3D Secure interaction with the card brand directory server.
  """
  directoryServerTransactionId: String

  """The electronic commerce indicator."""
  eciFlag: ECommerceIndicator

  """A boolean indicating if the card has received liability shift."""
  liabilityShifted: Boolean

  """A boolean indicating if the card is eligible for liability shift."""
  liabilityShiftPossible: Boolean

  """Indicates whether the card is enrolled in a 3D Secure program."""
  cardEnrolled: ThreeDSecureCardEnrolled

  """The 3D Secure authentication status of the card."""
  authenticationStatus: ThreeDSecureAuthenticationStatus

  """The version of the 3D Secure protocol used during authentication."""
  version: String

  """A unique identifier for the 3D Secure interaction with the provider."""
  xId: String

  """
  A unique identifier for the 3D Secure interaction with the 3D Secure server.
  """
  threeDSecureServerTransactionId: String

  """
  A unique identifier for the 3D Secure interaction with the access control server.
  """
  acsTransactionId: String

  """
  Indicates the current status of the 3D Secure authentication from the 3D Secure server for 3D Secure 1.0 authentications.
  """
  paresStatus: ThreeDSecureAuthenticationStatusIndicator

  """
  Indicates the current status of the 3D Secure authentication from the 3D Secure server for 3D Secure 2.0 authentications.
  """
  transactionStatus: ThreeDSecureAuthenticationStatusIndicator

  """
  Indicates the reason for the transaction status. This will be null if status is `SUCCESSFUL_AUTHENTICATION`.
  """
  transactionStatusReason: String
}

"""
An override field that a merchant can pass in to set the challenge window size
to display to the end cardholder. The ACS will reply with content that is
formatted appropriately to this window size to allow for the best user
experience. The sizes are width x height in pixels of the window displayed in
the cardholder browser window.
"""
enum ThreeDSecureAuthenticationAcsWindowSize {
  FULL_PAGE
  W250_H400
  W390_H400
  W500_H600
  W600_H400
}

"""Indicates the delivery timeframe if applicable."""
enum ThreeDSecureAuthenticationDeliveryTimeframe {
  ELECTRONIC_DELIVERY
  OVERNIGHT_SHIPPING
  SAME_DAY_SHIPPING
  TWO_OR_MORE_DAY_SHIPPING
}

"""Merchant product code."""
enum ThreeDSecureAuthenticationMerchantProductCode {
  ACCOMMODATION_RETAIL
  AIRLINE
  CAR_RENTAL
  CASH_DISPENSING
  DIGITAL_GOODS
  FUEL
  GENERAL_RETAIL
  LUXURY_RETAIL
  OTHER
  RESTAURANT
  SERVICES
  TRAVEL
}

"""Indicates the shipping type for the transaction."""
enum ThreeDSecureAuthenticationShippingType {
  DIGITAL_GOODS
  OTHER
  SHIP_TO_ADDRESS_ON_FILE
  SHIP_TO_BILLING_ADDRESS
  SHIP_TO_OTHER_ADDRESS
  SHIP_TO_STORE
  TICKETS_NOT_SHIPPED
}

"""The 3D Secure authentication status of the card."""
enum ThreeDSecureAuthenticationStatus {
  AUTHENTICATE_ATTEMPT_SUCCESSFUL
  AUTHENTICATE_ERROR
  AUTHENTICATE_FAILED
  AUTHENTICATE_REJECTED
  AUTHENTICATE_SIGNATURE_VERIFICATION_FAILED
  AUTHENTICATE_SUCCESSFUL
  AUTHENTICATE_SUCCESSFUL_ISSUER_NOT_PARTICIPATING
  AUTHENTICATE_UNABLE_TO_AUTHENTICATE
  AUTHENTICATION_BYPASSED
  AUTHENTICATION_UNAVAILABLE
  CHALLENGE_REQUIRED
  LOOKUP_BYPASSED
  LOOKUP_ENROLLED
  LOOKUP_ERROR
  LOOKUP_NOT_ENROLLED
  UNSUPPORTED_CARD
}

"""Indicates the current status of the 3D Secure authentication."""
enum ThreeDSecureAuthenticationStatusIndicator {
  AUTHENTICATION_REJECTED
  CHALLENGE_REQUIRED_DECOUPLED_AUTHENTICATION
  CHALLENGE_REQUIRED_FOR_AUTHENTICATION
  FAILED_AUTHENTICATION
  INFORMATIONAL_CHALLENGE_PREFERENCE_ACKNOWLEDGED
  SUCCESSFUL_ATTEMPTS_TRANSACTION
  SUCCESSFUL_AUTHENTICATION
  UNABLE_TO_COMPLETE_AUTHENTICATION
}

"""Indicates the type of transaction for 3D Secure authentication."""
enum ThreeDSecureAuthenticationTransactionType {
  ADD_CARD
  CARDHOLDER_VERIFICATION
  INSTALLMENT
  MAINTAIN_CARD
  PAYMENT
  RECURRING
}

"""Indicates whether the card is enrolled in a 3D Secure program."""
enum ThreeDSecureCardEnrolled {
  """
  Authentication has been bypassed. This status will be returned if you set up
  bypass rules with CardinalCommerce, and they are triggered.
  """
  BYPASS

  """
  There was an error in determining whether the card is enrolled in a 3D Secure program.
  """
  ERROR

  """The card is not enrolled."""
  NO

  """
  The DS (directory server) or ACS (access control server) is not available for authentication at the time of the request.
  """
  UNAVAILABLE

  """The card is enrolled."""
  YES
}

"""
A 3D Secure CAVV algorithm. Possible Values: 2 - CVV with ATN, 3 - Mastercard SPA algorithm.
"""
scalar ThreeDSecureCavvAlgorithm

"""Configuration for 3D Secure."""
type ThreeDSecureConfiguration {
  """
  Authentication information for initializing Cardinal's songbird.js library.
  """
  cardinalAuthenticationJWT: String
}

""" The billing address of the cardholder sent with 3D Secure Lookup requests.
"""
input ThreeDSecureLookupBillingAddressInput {
  """
  The given (first) name associated with the billing address used for verification.
  """
  givenName: String

  """
  The surname (last name) associated with the billing address used for verification.
  """
  surname: String

  """The billing phone number used for verification."""
  phoneNumber: String

  """Line 1 of the billing address used for verification."""
  line1: String

  """Line 2 of the billing address used for verification."""
  line2: String

  """Line 3 of the billing address used for verification."""
  line3: String

  """City or locality of billing address used for verification."""
  locality: String

  """State or region of billing address used for verification."""
  region: String

  """Country code of billing address used for verification."""
  countryCode: String

  """Postal code of billing address used for verification."""
  postalCode: String
}

"""
Additional information about the cardholder when authenticating through 3D Secure.
"""
input ThreeDSecureLookupCardholderInformationInput {
  """The billing address of the cardholder."""
  billingAddress: ThreeDSecureLookupBillingAddressInput
}

"""Information about the client side lookup process."""
input ThreeDSecureLookupClientInformationInput {
  """Version of the Braintree client-side SDK being used."""
  sdkVersion: String

  """Version of 3D Secure requested when performing the lookup."""
  requestedThreeDSecureVersion: String

  """Number of milliseconds taken for the issuer to collect device data."""
  issuerDeviceDataCollectionMillisecondsElapsed: Int

  """Whether device data collection by the issuer succeeded."""
  issuerDeviceDataCollectionResult: Boolean

  """
  Number of milliseconds taken for the 3D Secure server to collect device data.
  """
  threeDSecureServerDeviceDataCollectionMillisecondsElapsed: Int
}

"""
Data fields containing information from the MPI provider about the 3D Secure Lookup result.
"""
type ThreeDSecureLookupData {
  """
  The URL to use to issue a challenge to the cardholder for 3D Secure authentication.
  """
  acsUrl: String

  """
  A unique identifier used by the MPI provider to identify the 3D Secure
  interaction. The MPI provider provides the framework for determining if a card
  is enrolled in a 3D Secure program and for facilitating interactions with the issuer.
  """
  authenticationId: String

  """The version of the 3D Secure protocol used in the authentication."""
  version: String

  """
  The "PAReq" or "Payment Authentication Request" is the encoded request message used to initiate authentication.
  """
  pareq: String

  """
  The unique 3D Secure identifier assigned by Braintree to track the 3D Secure call as it progresses.
  """
  md: String

  """
  A fully qualified URL that the customer will be redirected to once the authentication completes.
  """
  termUrl: String
}

""" The shipping address of the transaction to be sent with 3D Secure Lookup requests.
"""
input ThreeDSecureLookupShippingAddressInput {
  """
  The given (first) name associated with the shipping address used for verification.
  """
  givenName: String

  """
  The surname (last name) associated with the shipping address used for verification.
  """
  surname: String

  """The shipping phone number used for verification."""
  phoneNumber: String

  """Line 1 of the shipping address used for verification."""
  line1: String

  """Line 2 of the shipping address used for verification."""
  line2: String

  """Line 3 of the shipping address used for verification."""
  line3: String

  """City or locality of shipping address used for verification."""
  locality: String

  """State or region of shipping address used for verification."""
  region: String

  """Country code of shipping address used for verification."""
  countryCode: String

  """Postal code of shipping address used for verification."""
  postalCode: String
}

"""
Indicates the shipping method chosen for the transaction in the 3D Secure lookup.
"""
enum ThreeDSecureLookupShippingMethod {
  ELECTRONIC_DELIVERY
  GROUND
  OVERNIGHT_EXPEDITED
  PRIORITY
  SAME_DAY
  SHIP_TO_STORE
}

"""
Additional information about the transaction when authenticating through 3D Secure.
"""
input ThreeDSecureLookupTransactionInformationInput {
  """The email associated with the transaction."""
  email: String

  """
  Indicates the shipping method chosen for the transaction in the 3D Secure lookup.
  """
  shippingMethod: ThreeDSecureLookupShippingMethod

  """The phone number associated with the transaction."""
  phoneNumber: String

  """The shipping address for the transaction."""
  shippingAddress: ThreeDSecureLookupShippingAddressInput

  """The work phone number associated with the transaction."""
  workPhoneNumber: String

  """Indicates the type of transaction."""
  transactionType: ThreeDSecureAuthenticationTransactionType

  """Indicates the delivery timeframe if applicable."""
  deliveryTimeframe: ThreeDSecureAuthenticationDeliveryTimeframe

  """
  For electronic delivery, email address to which the product was delivered.
  """
  deliveryEmail: String

  """Indicates shipping type chosen for the transaction."""
  shippingType: ThreeDSecureAuthenticationShippingType

  """Merchant product code."""
  productCode: ThreeDSecureAuthenticationMerchantProductCode

  """
  Indicates whether the cardholder is reordering merchandise purchased in a previous order.
  """
  reorderIndicator: Boolean

  """
  Indicates whether cardholder is placing an order with a future availability or release date.
  """
  preorderIndicator: Boolean

  """Expected date that a pre-ordered purchase will be available."""
  preorderDate: Date

  """The purchase amount total for prepaid gift cards."""
  giftCardAmount: Amount

  """ISO 4217 currency code for the gift card purchased."""
  giftCardCurrencyCode: CurrencyCodeAlpha

  """Total count of individual prepaid gift cards purchased."""
  giftCardCount: Int

  """
  Indicates whether the cardholder created the account during this transaction.
  """
  accountCreatedDuringTransaction: Boolean

  """Date the cardholder opened the account."""
  accountCreateDate: Date

  """
  Indicates whether the cardholder changed the account during this transaction.
  This includes changes to the billing or shipping address, new payment accounts
  or new users added.
  """
  accountChangedDuringTransaction: Boolean

  """
  Date the cardholder's account was last changed. This includes changes to the
  billing or shipping address, new payment accounts or new users added.
  """
  accountChangeDate: Date

  """
  Indicates whether the cardholder changed or reset the password on the account during this transaction.
  """
  accountPasswordChangedDuringTransaction: Boolean

  """Date the cardholder changed or reset the password on the account."""
  accountPasswordChangeDate: Date

  """
  Indicates whether this transaction represents the first use of this shipping address.
  """
  firstUseOfShippingAddress: Boolean

  """
  Date when the shipping address used for this transaction was first used.
  """
  shippingAddressFirstUsageDate: Date

  """
  Number of transactions (successful or incomplete) for this cardholder account within the last 24 hours.
  """
  transactionCountDay: Int

  """
  Number of transactions (successful or incomplete) for this cardholder account within the last year.
  """
  transactionCountYear: Int

  """
  Number of attempts that have been made to add a card to this account in the last 24 hours.
  """
  addCardAttempts: Int

  """
  Number of purchases with this cardholder account during the previous six months.
  """
  accountPurchases: Int

  """
  Indicates whether the merchant experienced suspicious activity (including previous fraud) on the account.
  """
  suspiciousActivityObserved: Boolean

  """
  Indicates if the cardholder name on the account is identical to the shipping name used for the transaction.
  """
  accountNameMatchesShippingName: Boolean

  """
  Indicates whether the payment method was added to the cardholder account during this transaction.
  """
  paymentMethodAddedDuringTransaction: Boolean

  """Date the payment method was added to the cardholder account."""
  paymentMethodAddedToAccountDate: Date

  """
  An override field that a merchant can pass in to set the challenge window size
  to display to the end cardholder. The ACS will reply with content that is
  formatted appropriately to this window size to allow for the best user
  experience. The sizes are width x height in pixels of the window displayed in
  the cardholder browser window.
  """
  acsWindowSize: ThreeDSecureAuthenticationAcsWindowSize

  """
  This field indicates the maximum amount of time for all 3DS 2.0 messages to be
  communicated between all components (in minutes). Minimum is 05. Defaults to 15.
  """
  sdkMaxTimeout: Int

  """Indicates whether cardholder billing and shipping addresses match."""
  billingAddressMatchesShippingAddress: Boolean

  """Additional cardholder account information."""
  accountId: String

  """
  The IP address of the cardholder. Both IPv4 and IPv6 formats are supported.
  """
  ipAddress: String

  """Brief Description of items purchased."""
  orderDescription: String

  """Tax amount."""
  taxAmount: Amount

  """The exact content of the HTTP user agent header."""
  userAgent: String

  """
  Indicates the maximum number of authorizations for installment payments. An
  integer value greater than 1 indicating the maximum number of permitted
  authorizations for installment payments.
  """
  installment: Int

  """Datetime of original purchase."""
  purchaseDate: Timestamp

  """
  The date after which no further recurring authorizations should be performed.
  """
  recurringEnd: Date

  """
  Integer value indicating the minimum number of days between recurring
  authorizations. A frequency of monthly is indicated by the value 28. Multiple
  of 28 days will be used to indicate months. Example: 6 months = 168.
  """
  recurringFrequency: Int
}

"""Results of a merchant-performed 3D Secure authentication."""
input ThreeDSecurePassThroughInput {
  """
  The value of the electronic commerce indicator (ECI) flag, which indicates the outcome of the 3D Secure authentication.
  """
  eciFlag: ECommerceIndicator!

  """
  Cardholder authentication verification value or CAVV. The main encrypted
  message issuers and card networks use to verify authentication has occurred.
  Mastercard uses an AVV (Authentication Verification Value) message and
  American Express uses an AEVV (American Express Verification Value) message,
  each of which should also be passed in the cavv parameter.
  """
  cavv: String

  """
  Transaction identifier resulting from 3D Secure authentication. Uniquely
  identifies the transaction and sometimes required in the authorization
  message. Must be base64-encoded. This field will no longer be used in 3D
  Secure 2 authentications.
  """
  xId: String

  """
  Transaction identifier resulting from 3D Secure 2 authentication. This field
  must be supplied for Mastercard Identity Check.
  """
  threeDSecureServerTransactionId: String

  """
  The version of 3D Secure authentication used for the transaction. Required on Visa and Mastercard authentications.
  """
  version: ThreeDSecureVersion

  """The 3D Secure authentication response status code."""
  authenticationResponse: ThreeDSecureStatusCode

  """The 3D Secure directory server response."""
  directoryServerResponse: ThreeDSecureStatusCode

  """
  The algorithm used to generate the CAVV value. This is only returned for Mastercard SecureCode transactions (3DS 1.0).
  """
  cavvAlgorithm: ThreeDSecureCavvAlgorithm
}

"""A raw 3D Secure PARes or VARes response code (e.g. 'Y')."""
scalar ThreeDSecureStatusCode

"""
A 3D Secure authentication version. Must be composed of digits separated by periods (e.g. '1.0.2').
"""
scalar ThreeDSecureVersion

"""
An [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601#Times) timestamp with microsecond precision, in UTC.
"""
scalar Timestamp

"""Top-level input fields for tokenizing a credit card."""
input TokenizeCreditCardInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """Input fields for a credit card."""
  creditCard: CreditCardInput!

  """Credit card tokenization options."""
  options: TokenizeCreditCardOptionsInput
}

"""Credit card tokenization options."""
input TokenizeCreditCardOptionsInput {
  """
  Whether to run validations on credit card fields. Validations are not run by default.
  """
  validate: Boolean
}

"""Top-level fields returned from a tokenized credit card."""
type TokenizeCreditCardPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """A one-time-use reference to tokenized sensitive information."""
  token: String @deprecated(reason: "Use `paymentMethod.id` instead.")

  """Details about the tokenized card."""
  creditCard: CreditCardDetails @deprecated(reason: "Use `paymentMethod.details` instead.")

  """A single-use payment method."""
  singleUseToken: PaymentMethod @deprecated(reason: "Use `paymentMethod` instead.")

  """A single-use payment method."""
  paymentMethod: PaymentMethod

  """
  Information about the [customer authentication regulation environment](https://developers.braintreepayments.com/guides/3d-secure/migration/javascript/v3#authentication-insight)
  that applies to the payment method when processed with the provided merchant
  account. This can be used to determine whether to perform 3D Secure
  authentication.
  """
  authenticationInsight(input: AuthenticationInsightInput!): AuthenticationInsight
}

"""Top-level input fields for tokenizing Custom Actions."""
input TokenizeCustomActionsPaymentMethodInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """Input fields for a Custom Actions payment method."""
  customActionsPaymentMethod: CustomActionsPaymentMethodInput!
}

"""
Top-level fields returned from tokenizing a CustomActionsPaymentMethod.
"""
type TokenizeCustomActionsPaymentMethodPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """A single-use payment method."""
  paymentMethod: PaymentMethod
}

"""
Top-level input fields for tokenizing a CVV, otherwise known as CSC or CVC.
"""
input TokenizeCvvInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """
  A 3 or 4 digit card verification value assigned to credit cards. The CVV will
  never be stored, but it can be provided with one-time requests to verify the card.
  """
  cvv: CVV!
}

"""Top-level fields returned from a tokenized CVV."""
type TokenizeCvvPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """A single-use tokenized CVV."""
  tokenizedCvv: TokenizedCvv

  """A single-use payment method representing just a CVV."""
  singleUseToken: PaymentMethod @deprecated(reason: "This mutation does not create a full PaymentMethod. Use `tokenizedCvv` instead.")
}

"""
A single-use, tokenized value representing a CVV (card verification value),
otherwise known as CSC or CVC. This cannot be charged or authorized, since it is
not a payment method, but it can be used alongside a multi-use credit card
payment method.
"""
type TokenizedCvv {
  """Unique identifier for the tokenized CVV."""
  id: ID!
}

"""Top-level input field for tokenizing a network token."""
input TokenizeNetworkTokenInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """Input fields for a network token object."""
  networkToken: NetworkTokenInput!
}

"""Top-level fields returned from a tokenized Network Token."""
type TokenizeNetworkTokenPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """A single-use payment method."""
  paymentMethod: PaymentMethod
}

"""Top-level input field for tokenizing a Samsung Pay card."""
input TokenizeSamsungPayCardInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """Input fields for a Samsung Pay card."""
  samsungPayCard: SamsungPayCardInput!
}

"""Top-level fields returned from a tokenized Samsung Pay card."""
type TokenizeSamsungPayCardPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """A one-time-use reference to tokenized sensitive information."""
  singleUseToken: PaymentMethod @deprecated(reason: "Use `paymentMethod` instead.")

  """A single-use payment method."""
  paymentMethod: PaymentMethod
}

"""Top-level input fields for tokenizing a US bank account."""
input TokenizeUsBankAccountInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """Input fields for a US bank account object."""
  usBankAccount: UsBankAccountInput!
}

"""Top-level fields returned from a tokenized US bank account."""
type TokenizeUsBankAccountPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """A single-use payment method."""
  paymentMethod: PaymentMethod
}

"""Top-level input fields for tokenizing a US bank login."""
input TokenizeUsBankLoginInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """Input fields for a US bank login."""
  usBankLogin: UsBankLoginInput!
}

"""A charge on a payment method."""
type Transaction implements Node & Payment {
  """Unique identifier."""
  id: ID!

  """Legacy unique identifier."""
  legacyId: ID!

  """Date and time when the transaction was created."""
  createdAt: Timestamp

  """
  Snapshot of payment method details used to create the transaction, preserved
  at the time the transaction was created. This will always be present.
  """
  paymentMethodSnapshot: PaymentMethodSnapshot

  """
  The multi-use payment method associated with the transaction. Only present if
  a multi-use payment method was used to create the transaction and it has not
  been deleted. The details of this PaymentMethod may have changed since the
  transaction was created; details used for the transaction can be found in the
  `paymentMethodSnapshot` field.
  """
  paymentMethod: PaymentMethod

  """
  The amount charged in this transaction. For transactions that are partially
  captured, this amount will be the cummulative amount captured on this transaction.
  """
  amount: MonetaryAmount

  """
  Collection of custom field/value pairs. Custom fields are [defined in the Control Panel](https://articles.braintreepayments.com/control-panel/custom-fields#store-and-pass-back-fields).
  """
  customFields: [CustomField!]

  """The ID of the merchant account that processed this transaction."""
  merchantAccountId: ID

  """
  The order ID for this transaction. For PayPal transactions, the PayPal Invoice ID.
  """
  orderId: String

  """
  A purchase order identification value you associate with this transaction.
  """
  purchaseOrderNumber: String

  """The current status of this transaction."""
  status: PaymentStatus

  """Fields describing the payment processor response."""
  processorResponse: TransactionAuthorizationProcessorResponse @deprecated(reason: "Use relevant events in `statusHistory` instead.")

  """Risk data evaluated for this transaction."""
  riskData: RiskData

  """
  Fields used to define what will appear on customers' credit card statements for a specific purchase.
  """
  descriptor: TransactionDescriptor

  """
  The records of all statuses this transaction has passed through, with
  additional information on why each status occurred. Returned in reverse
  chronological order, with the most recent event first in the list.
  """
  statusHistory: [PaymentStatusEvent!]

  """
  If the transaction request was performed through a shopping cart provider or
  Braintree partner, this field will have a string identifier for that shopping
  cart provider or partner. For PayPal transactions, this maps to the PayPal
  account's bn_code.
  """
  channel: String

  """How the transaction was created."""
  source: PaymentSource

  """Customer associated with the transaction, if applicable."""
  customer: Customer

  """Shipping information."""
  shipping: TransactionShipping

  """Tax information."""
  tax: TransactionTaxInformation

  """Discount amount that was included in the total transaction amount."""
  discountAmount: String

  """Line items for this transaction."""
  lineItems: [TransactionLineItem!]

  """The list of refunds issued against this transaction."""
  refunds: [Refund!]

  """
  For transactions created or captured using the `partialCaptureTransaction`
  mutation. This field links a given transaction to its original authorization
  or all its partial captures.
  """
  partialCaptureDetails: PartialCaptureDetails

  """A collection of disputes associated with the transaction."""
  disputes: [Dispute!]

  """
  If the transaction request was performed using payment information from a
  third party via the Grant API, Shared Vault or Google Pay, these fields will
  capture information about the third party. These fields are primarily useful
  for the merchant of record.
  """
  facilitatorDetails: FacilitatorDetails

  """
  The disbursement details associated with this transaction. This field is only
  available after the transaction is SETTLED and if you have an eligible
  merchant account.
  """
  disbursementDetails: DisbursementDetails

  """The billing address associated with the transaction."""
  billingAddress: Address

  """
  A collection of AuthorizationAdjustments associated with the transaction.
  """
  authorizationAdjustments: [AuthorizationAdjustment!]
}

"""
Record of processor response data received in response to authorization adjustment requests.
"""
type TransactionAuthorizationAdjustmentProcessorResponse {
  """
  The [processor response code](https://developers.braintreepayments.com/reference/general/processor-responses/authorization-responses)
  indicating the result of attempting the adjustment.
  """
  legacyCode: String

  """The text explanation of the processor response code."""
  message: String

  """
  Whether or not the decline is the result of a temporary issue. Only present if adjustment is declined.
  """
  declineType: ProcessorDeclineType
}

"""
Detailed response information from the processor when attempting to authorize a transaction.
"""
type TransactionAuthorizationProcessorResponse {
  """
  A code based on the response from the processor, indicating the result of
  attempting to authorize this transaction. See the [list of possible processor
  response codes for authorization](https://developers.braintreepayments.com/reference/general/processor-responses/authorization-responses).
  """
  legacyCode: String

  """The text explanation of the processor response legacyCode."""
  message: String

  """The processing bank's response to the provided CVV."""
  cvvResponse: AvsCvvResponseCode

  """
  The processing bank's response to the provided billing postal or zip code.
  """
  avsPostalCodeResponse: AvsCvvResponseCode

  """The processing bank's response to the provided billing street address."""
  avsStreetAddressResponse: AvsCvvResponseCode

  """The processor's unique ID or "code" for the authorization."""
  authorizationId: String

  """
  If present, any additional information recieved from the processor. May provide further insight into the `legacyCode`.
  """
  additionalInformation: String

  """The processor's reference number for the authorization."""
  retrievalReferenceNumber: String
}

"""A paginated list of transactions."""
type TransactionConnection {
  """A list of transactions."""
  edges: [TransactionConnectionEdge]

  """Information about the page of transactions contained in `edges`."""
  pageInfo: PageInfo!
}

"""A transaction within a TransactionConnection."""
type TransactionConnectionEdge {
  """
  This transaction's location within the TransactionConnection. Used for requesting additional pages.
  """
  cursor: String

  """The transaction."""
  node: Transaction
}

"""
Fields used to define what will appear on a customer's bank statement for a specific purchase.
"""
type TransactionDescriptor {
  """The value in the business name field of a customer's statement."""
  name: String

  """The value in the phone number field of a customer's statement."""
  phone: String

  """The value in the URL/web address field of a customer's statement."""
  url: String
}

"""
Fields used to define what will appear on a customer's bank statement for a specific purchase.
"""
input TransactionDescriptorInput {
  """The value in the business name field of a customer's statement."""
  name: String

  """The value in the phone number field of a customer's statement."""
  phone: String

  """The value in the URL/web address field of a customer's statement."""
  url: String
}

"""
Input for transactions created with credit cards vaulted in an external vault,
not the Braintree Vault. Do not use for transactions created from Braintree
multi-use payment methods, or from single-use payment methods which will not be
stored in an external vault.
"""
input TransactionExternalVaultOptionsInput {
  """The credit card's assocation with an external vault."""
  status: ExternalVaultStatus!

  """
  The network transaction ID of the first _transaction_ after which this payment
  method was stored in the external vault. If the `status` is `WILL_VAULT`, do
  not pass this value; the network transaction ID of the resulting transaction
  can be passed in this field for _subsequent_ transactions. If the `status` is
  `VAULTED`, but the customer is directly initiating the charge, do not pass this value.
  """
  verifyingNetworkTransactionId: String
}

"""Input fields for creating a transaction."""
input TransactionInput {
  """
  Billing amount of the request. This value must be greater than 0, and must
  match the currency format of the merchant account. This can only contain
  numbers and one decimal point (e.g. x.xx). Can't be greater than the maximum
  allowed by the processor.
  """
  amount: Amount!

  """
  Merchant account ID used to process the transaction. Currency is also
  determined by merchant account ID. If no merchant account ID is specified, we
  will use your default merchant account.
  """
  merchantAccountId: ID

  """
  Additional information about the transaction. On PayPal transactions, this
  field maps to the PayPal invoice number. PayPal invoice numbers must be unique
  in your PayPal business account. Maximum 255 characters or 127 for PayPal transactions.
  """
  orderId: String

  """
  A purchase order identification value you associate with this transaction.
  
  *Required for Level 2 processing*.
  """
  purchaseOrderNumber: String

  """
  Customer device information, which is sent directly to supported processors for fraud analysis.
  """
  riskData: RiskDataInput

  """
  Collection of custom field/value pairs. You must [set up each custom field in the Control Panel](https://articles.braintreepayments.com/control-panel/custom-fields#creating-a-custom-field)
  prior to passing it with a request.
  """
  customFields: [CustomFieldInput!]

  """
  Fields used to define what will appear on a customer's bank statement for a specific purchase.
  """
  descriptor: TransactionDescriptorInput

  """
  Deprecated: This field is included for supporting legacy clients. Please use `paymentInitiator` instead.
  """
  recurring: RecurringType

  """
  The initiator of the payment. Payment can either be merchant-initiated or customer-initiated.
  """
  paymentInitiator: PaymentInitiator

  """
  For partners and shopping carts only. If you are a shopping cart provider or
  other Braintree partner, pass a string identifier for your service. For PayPal
  transactions, this maps to paypal.bn_code.
  """
  channel: String

  """
  If charging a single-use payment method, optional ID of a customer to associate the transaction with.
  """
  customerId: ID

  """
  Shipping information.
  
  *Required for Level 3 processing*.
  """
  shipping: TransactionShippingInput

  """
  Tax information about the transaction.
  
  *Required for Level 2 processing*.
  """
  tax: TransactionTaxInput

  """
  Discount amount that was included in the total transaction amount. Does not
  add to the total amount the payment method will be charged. This value can't be negative.
  
  *Required for Level 3 processing*.
  """
  discountAmount: String

  """
  Line items for this transaction. Up to 249 line items may be specified.
  
  *Required for Level 3 processing*.
  """
  lineItems: [TransactionLineItemInput!]

  """
  Results of a merchant-performed 3D Secure authentication. You will only need
  to use these fields if you've performed your own integration with a 3D Secure
  MPI provider (e.g. Cardinal Centinel). Otherwise, Braintree's SDKs handle this
  for you in our standard 3D Secure integration.
  """
  threeDSecurePassThrough: ThreeDSecurePassThroughInput
}

"""
The [transaction-level fee report](https://articles.braintreepayments.com/control-panel/reporting/transaction-level-fee-report)
provides a breakdown of fees per individual transactions and refunds. This type
is no longer in use; see `PaymentLevelFeeReport` instead.
"""
type TransactionLevelFeeReport {
  """The URL where you can access the requested report."""
  url: String
}

"""Data for individual line items on a transaction."""
type TransactionLineItem {
  """Item name."""
  name: String

  """Indicates whether the line item is a sale or refund."""
  kind: TransactionLineItemType

  """Number of units of the item purchased."""
  quantity: String

  """Per-unit price of the item."""
  unitAmount: String

  """
  Total price amount for the line item, i.e. quantity multiplied by unit amount.
  """
  totalAmount: String

  """Per-unit tax price of the item."""
  unitTaxAmount: String

  """Tax amount for the line item."""
  taxAmount: String

  """The discount amount of the line item."""
  discountAmount: String

  """The unit of measure or the unit of measure code."""
  unitOfMeasure: String

  """Product or UPC code for the item."""
  productCode: String

  """
  Code used to classify items purchased and track the total amount spent across
  various categories of products and services. Different corporate purchasing
  organizations may use different standards, but the [United Nations Standard
  Products and Services Code (UNSPSC)](https://www.unspsc.org/) is frequently used.
  """
  commodityCode: String

  """Item description."""
  description: String

  """The URL to product information."""
  url: String

  """The type of the line item, i.e., physical, digital etc."""
  itemType: String
}

"""Data for individual line items on a transaction."""
input TransactionLineItemInput {
  """
  Item name. Maximum 35 characters, or 127 characters for PayPal transactions.
  
  *Required for Level 3 processing*.
  """
  name: String!

  """
  Indicates whether the line item is a sale or refund.
  
  *Required for Level 3 processing*.
  """
  kind: TransactionLineItemType!

  """
  Number of units of the item purchased. Can include up to 4 decimal places. This value can't be negative or zero.
  
  *Required for Level 3 processing*.
  """
  quantity: String!

  """
  Per-unit price of the item. Maximum 4 decimal places, or 2 decimal places for
  PayPal transactions. This value can't be negative or zero.
  
  *Required for Level 3 processing*.
  """
  unitAmount: String!

  """
  Total price amount for the line item: quantity multiplied by unitAmount. Can include up to 2 decimal places.
  
  *Required for Level 3 processing*.
  """
  totalAmount: String!

  """
  Per-unit tax price of the item. Can include up to 2 decimal places. This value can't be negative or zero.
  
  *Required for Level 3 processing*.
  """
  unitTaxAmount: String

  """
  Tax amount for the line item. Can include up to 2 decimal places. This value can't be negative.
  
  *Required for Level 3 processing*.
  """
  taxAmount: String

  """
  Amount of discount for the line item. Can include up to 2 decimal places. This value can't be negative.
  
  *Required for Level 3 processing*.
  """
  discountAmount: String

  """
  The unit of measure or the unit of measure code. Maximum 12 characters.
  
  *Required for Level 3 processing*.
  """
  unitOfMeasure: String

  """
  Product or UPC code for the item. Maximum 12 characters, or 127 characters for PayPal transactions.
  
  *Required for Level 3 processing*.
  """
  productCode: String

  """
  Code used to classify items purchased and track the total amount spent across
  various categories of products and services. Different corporate purchasing
  organizations may use different standards, but the [United Nations Standard
  Products and Services Code (UNSPSC)](https://www.unspsc.org/) is frequently
  used. Maximum 12 characters.
  
  *Required for Level 3 processing*.
  """
  commodityCode: String

  """
  Item description. Maximum 127 characters.
  
  *Required for Level 3 processing*.
  """
  description: String

  """
  A URL to information about the product.
  
  *Required for Level 3 processing*.
  """
  url: String

  """The type of the line item, i.e., physical, digital etc."""
  itemType: String
}

"""
Indicates whether a transaction line item is a debit (sale) or credit (refund).
"""
enum TransactionLineItemType {
  CREDIT
  DEBIT
}

"""Top-level output field from creating a transaction."""
type TransactionPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The transaction representing the charge on the payment method."""
  transaction: Transaction
}

"""
A union of all possible results of a transaction reversal. If the transaction is
settled, a refund will be issued and a Refund object will be returned.
Otherwise, the transaction will be voided and a Transaction object will be returned.
"""
union TransactionReversal = Refund | Transaction

"""Input fields for searching for transactions."""
input TransactionSearchInput {
  """Find transactions with an ID or IDs."""
  id: SearchValueInput

  """Find transactions with a given transaction status."""
  status: SearchTransactionStatusInput

  """
  Find transactions based on the given transaction status transition times.
  """
  statusTransition: SearchTransactionStatusTransitionInput

  """Find transactions based on the time they were created."""
  createdAt: SearchTimestampInput

  """Find transactions for a given amount or currency."""
  amount: MonetaryAmountSearchInput

  """Find transactions with a given orderId."""
  orderId: SearchTextInput

  """Find payments processed through a merchant account ID or IDs."""
  merchantAccountId: SearchValueInput

  """Find transactions with a given customer."""
  customer: SearchCustomerInput

  """
  Find transactions created by charging payment methods of the given type.
  """
  paymentMethodSnapshotType: SearchPaymentMethodSnapshotTypeInput

  """
  Find transactions by their disbursement date. Only use this search criteria if
  you have an eligible merchant account. Note that transactions can only be
  disbursed after they reach the SETTLED status.
  """
  disbursementDate: SearchDateInput

  """Find transactions created with a given transaction source."""
  source: SearchTransactionSourceInput

  """
  Find transactions created by a third party via the Grant API using a given OAuth application client ID.
  """
  facilitatorOAuthApplicationClientId: SearchValueInput
}

"""
Detailed response information from the processor when attempting to settle a transaction.
"""
type TransactionSettlementProcessorResponse {
  """
  A code based on the response from the processor, indicating the result of
  attempting to settle this transaction. See the [list of possible processor
  response codes for settlement](https://developers.braintreepayments.com/reference/general/processor-responses/settlement-responses).
  """
  legacyCode: String

  """The text explanation of the processor response legacyCode."""
  message: String

  """The processing bank's response to the provided CVV."""
  cvvResponse: AvsCvvResponseCode @deprecated(reason: "AVS and CVV checks do not take place when capturing a transaction, only when authorizing. Use the `processorResponse` on an authorization-related `PaymentStatusEvent` instead.")

  """
  The processing bank's response to the provided billing postal or zip code.
  """
  avsPostalCodeResponse: AvsCvvResponseCode @deprecated(reason: "AVS and CVV checks do not take place when capturing a transaction, only when authorizing. Use the `processorResponse` on an authorization-related `PaymentStatusEvent` instead.")

  """The processing bank's response to the provided billing street address."""
  avsStreetAddressResponse: AvsCvvResponseCode @deprecated(reason: "AVS and CVV checks do not take place when capturing a transaction, only when authorizing. Use the `processorResponse` on an authorization-related `PaymentStatusEvent` instead.")
}

"""Information related to shipping a physical product."""
type TransactionShipping {
  """Shipping address information."""
  shippingAddress: Address

  """The shipping cost of the entire transaction."""
  shippingAmount: Amount

  """The postal code of the source shipping location."""
  shipsFromPostalCode: String
}

"""Information related to shipping a physical product."""
input TransactionShippingInput {
  """
  Shipping destination address information.
  
  *Required for Level 3 processing*.
  """
  shippingAddress: AddressInput

  """
  Shipping cost on the entire transaction.
  
  *Required for Level 3 processing*.
  """
  shippingAmount: String

  """
  The postal code of the source shipping location, in any country's format.
  
  *Required for Level 3 processing*.
  """
  shipsFromPostalCode: String
}

"""Information related to taxes on the transaction."""
type TransactionTaxInformation {
  """The amount of tax that was included in the total transaction amount."""
  taxAmount: Amount

  """
  Whether the transaction should be considered eligible for tax exemption.
  """
  taxExempt: Boolean
}

"""Information related to taxes on the transaction."""
input TransactionTaxInput {
  """
  Amount of tax that was included in the total transaction amount. Does not add
  to the total amount the payment method will be charged.
  
  *Required for Level 2 processing* unless `taxExempt` is `true`.
  """
  taxAmount: Amount

  """
  Whether the transaction should be considered eligible for tax exemption.
  
  *Required for Level 2 processing*.
  """
  taxExempt: Boolean
}

"""Configuration for UnionPay cards."""
type UnionPayConfiguration {
  """The Braintree merchant account ID with UnionPay processing enabled."""
  merchantAccountId: String
}

"""
Top-level input fields for updating a multi-use credit card to use a new billing address.
"""
input UpdateCreditCardBillingAddressInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """
  The multi-use credit card for which the billing address will be updated or added.
  """
  paymentMethodId: ID!

  """The new billing address."""
  billingAddress: AddressInput

  """
  Input fields that specify options for verifying the credit card with the new
  billing address. By default, a verification will be performed. If the
  verification fails, the update will not be performed.
  """
  verification: PaymentMethodVerificationOptionsInput
}

"""
Top-level fields returned when updating a multi-use credit card to a new billing address.
"""
type UpdateCreditCardBillingAddressPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """
  The new billing address. Will be `null` if a failed verification prevented the update.
  """
  billingAddress: Address

  """
  The verification that was run on the payment method prior to updating the billing address, if present.
  """
  verification: Verification
}

"""Top-level field for updating a customer."""
input UpdateCustomerInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of the customer to be updated."""
  customerId: ID!

  """Input fields for the updates to be made on the customer."""
  customer: CustomerInput
}

"""Top-level fields returned when updating a customer."""
type UpdateCustomerPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """Information about the customer that was updated."""
  customer: Customer
}

"""Input for creating or updating custom fields on a transaction."""
input UpdateTransactionCustomFieldsInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The ID of the transaction to update."""
  transactionId: ID!

  """
  The list of custom fields to update. You must [set up each custom field in the Control Panel](https://articles.braintreepayments.com/control-panel/custom-fields#creating-a-custom-field)
  prior to passing it with a request.
  """
  customFields: [CustomFieldInput!]!
}

"""
Top-level output field from updating custom fields for a specific transaction.
"""
type UpdateTransactionCustomFieldsPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """
  A list of all custom fields on the updated transaction. Custom fields are
  [defined in the Control Panel](https://articles.braintreepayments.com/control-panel/custom-fields#store-and-pass-back-fields).
  """
  customFields: [CustomField!]
}

"""Details about the customer's acceptance of ACH terms."""
type UsBankAccountAchMandate {
  """The text the customer agreed to when setting up ACH."""
  acceptanceText: String

  """Date and time when the text terms were accepted."""
  acceptedAt: Timestamp
}

"""
A billing address for a US bank account. This is a subset of the fields required on `AddressInput`.
"""
input UsBankAccountBillingAddressInput {
  """The street address."""
  streetAddress: String!

  """The extended address information—such as an apartment or suite number."""
  extendedAddress: String

  """The city."""
  city: String!

  """The state."""
  state: UsStateCode!

  """The ZIP code."""
  zipCode: UsZipCode!
}

"""The name of the owner of a business US bank account."""
input UsBankAccountBusinessOwnerInput {
  """The name of the business that owns the account."""
  businessName: String!
}

"""Configuration for US bank account processing."""
type UsBankAccountConfiguration {
  """The route ID used to process a US bank account payment."""
  routeId: String

  """The public key for Plaid to use to log in to a bank account."""
  plaidPublicKey: String
}

"""Details about a US bank account."""
type UsBankAccountDetails {
  """
  The name of the accountholder. This is either the business name for a business
  account, or the owner's full name for an individual account.
  """
  accountholderName: String

  """The bank account type."""
  accountType: UsBankAccountType

  """The ownership type of the account, i.e. business or personal."""
  ownershipType: UsBankAccountOwnershipType

  """The name of the bank at which the account exists."""
  bankName: String

  """The last four digits of the bank account number."""
  last4: String

  """The routing number of the bank."""
  routingNumber: String

  """
  Whether or not the bank account has been verified and can be transacted on.
  """
  verified: Boolean

  """NACHA-mandated proof of acceptance of ACH terms."""
  achMandate: UsBankAccountAchMandate
}

"""The name of the owner of a personal US bank account."""
input UsBankAccountIndividualOwnerInput {
  """The first name of the accountholder."""
  firstName: String!

  """The last name of the accountholder."""
  lastName: String!
}

"""Input fields for a US bank account object."""
input UsBankAccountInput {
  """The account number of the bank account."""
  accountNumber: UsBankAccountNumber!

  """The routing number of the bank that holds the account."""
  routingNumber: UsBankRoutingNumber!

  """The type of account."""
  accountType: UsBankAccountType!

  """
  Information about the business that owns the account. This should only be specified for business accounts.
  """
  businessOwner: UsBankAccountBusinessOwnerInput

  """
  Information about the individual that owns the account. This should only be specified for individual accounts.
  """
  individualOwner: UsBankAccountIndividualOwnerInput

  """The billing address of the account."""
  billingAddress: UsBankAccountBillingAddressInput

  """
  Language used to prove that you have the customer's explicit permission to debit their bank account.
  """
  achMandate: String!
}

"""An account number containing 1-17 digits."""
scalar UsBankAccountNumber

"""The ownership type of US Bank Account."""
enum UsBankAccountOwnershipType {
  BUSINESS
  PERSONAL
}

"""The type of US Bank Account."""
enum UsBankAccountType {
  CHECKING
  SAVINGS
}

"""
Information specific to verifications of US bank account payment methods.
"""
type UsBankAccountVerificationDetails {
  """Type of US bank account verification performed."""
  method: UsBankAccountVerificationMethod

  """
  Time at which the verification was determined to be successful or not. If
  successful, at this time the payment method will be marked `verified` and you
  will be able to charge it.
  """
  verificationDeterminedAt: Timestamp
}

"""
The type of verification on a US bank account payment method. See our [ACH guide](https://articles.braintreepayments.com/guides/payment-methods/ach#verification-methods).
"""
enum UsBankAccountVerificationMethod {
  """
  Verification conducted independently by the merchant, not through Braintree.
  """
  INDEPENDENT_CHECK

  """
  Verification by micro-deposits transferred to the bank account, which the
  customer must then confirm. The most reliable method, but takes additional time.
  """
  MICRO_TRANSFERS

  """
  Verification via account information. Will complete the verification process
  immediately, but is not supported by all banks.
  """
  NETWORK_CHECK

  """
  Verification at the point of tokenization. Requires integration with a
  third-party provider. Because this requires a different tokenization flow,
  this method of verification is only supported for vaulting tokenized US bank
  account logins, and is not supported when re-verifying a US bank account
  payment method.
  """
  TOKENIZED_CHECK
}

"""Input fields for a US bank login object."""
input UsBankLoginInput {
  """The public token returned from the bank login."""
  publicToken: String!

  """The login provider account ID used for the bank login."""
  accountId: String!

  """The type of account."""
  accountType: UsBankAccountType!

  """
  Information about the business that owns the account. This should only be specified for business accounts.
  """
  businessOwner: UsBankAccountBusinessOwnerInput

  """
  Information about the individual that owns the account. This should only be specified for individual accounts.
  """
  individualOwner: UsBankAccountIndividualOwnerInput

  """The billing address of the account."""
  billingAddress: UsBankAccountBillingAddressInput

  """
  Language used to prove that you have the customer's explicit permission to debit their bank account.
  """
  achMandate: String!
}

"""A routing number containing 8 or 9 digits."""
scalar UsBankRoutingNumber

"""Details about the user."""
type User {
  """Unique identifier."""
  id: ID!

  """Email address."""
  email: String

  """Current status."""
  status: UserStatus

  """Full name."""
  name: String

  """Associated roles."""
  roles: [Role!]
}

"""The status of the user."""
enum UserStatus {
  ACTIVE
  DELETED
  PASSIVE
  PENDING
  SUSPENDED
}

"""A two-letter code representing a US state or territory."""
enum UsStateCode {
  AK
  AL
  AR
  AS
  AZ
  CA
  CO
  CT
  DC
  DE
  FL
  GA
  GU
  HI
  IA
  ID
  IL
  IN
  KS
  KY
  LA
  MA
  MD
  ME
  MI
  MN
  MO
  MP
  MS
  MT
  NC
  ND
  NE
  NH
  NJ
  NM
  NV
  NY
  OH
  OK
  OR
  PA
  PR
  RI
  SC
  SD
  TN
  TX
  UM
  UT
  VA
  VI
  VT
  WA
  WI
  WV
  WY
}

"""A nine-digit Employer Identification Number or Social Security Number."""
scalar USTaxIdentificationNumber

"""A US ZIP code. Supports DDDDD and DDDDD-DDDD formats."""
scalar UsZipCode

"""Options used to indicate when a credit card is externally vaulted."""
input VaultCreditCardExternalVaultOptionsInput {
  """
  For use if this credit card is stored in an external vault. The network
  transaction ID of the first _transaction_ after which this credit card was
  stored in the external vault.
  """
  verifyingNetworkTransactionId: String
}

"""
Top-level input field for vaulting a credit card so it can be used multiple times.
"""
input VaultCreditCardInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of an existing single-use credit card payment method to be vaulted."""
  paymentMethodId: ID!

  """
  Input fields that specify options for verifying the credit card before
  vaulting. By default, a verification will be performed. If the verification
  fails, the credit card will not be vaulted.
  """
  verification: PaymentMethodVerificationOptionsInput

  """Options used to indicate when a credit card is externally vaulted."""
  externalVault: VaultCreditCardExternalVaultOptionsInput

  """
  ID of the customer to associate the resulting multi-use payment method with.
  """
  customerId: ID

  """The type of account to be used when verifying a combo card."""
  accountType: CardAccountType

  """
  A billing address to associate with the vaulted credit card. If billing
  address data was included when tokenizing the credit card, it will be *merged*
  with this input value.
  """
  billingAddress: AddressInput
}

"""Top-level input field for vaulting a limited use PayPal account."""
input VaultLimitedUsePayPalAccountInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """
  ID of an existing single-use PayPal account generated using the order flow.
  """
  paymentMethodId: ID!

  """ID of the customer to associate the resulting payment method with."""
  customerId: ID

  """
  Input fields that provide information about the resulting PayPal account.
  """
  options: VaultLimitedUsePayPalAccountOptionsInput
}

"""
Input fields that provide information about the resulting PayPal account.
"""
input VaultLimitedUsePayPalAccountOptionsInput {
  """
  The total amount of the order. This will be the limit to how much may be captured on the resulting payment method.
  """
  amount: Amount

  """
  Variable passed directly to PayPal for your own tracking purposes. Customers do not see this value.
  """
  customField: String

  """
  Description of the transaction that is displayed to customers in PayPal email receipts.
  """
  description: String

  """
  The PayPal invoice number. It must be unique in your PayPal business account
  and can contain a maximum of 127 characters. If specified, transactions
  created from the resulting payment method will have this orderId.
  """
  orderId: String

  """Shipping destination address information."""
  shippingAddress: AddressInput
}

"""
Top-level input field for vaulting a payment method so it can be used multiple times.
"""
input VaultPaymentMethodInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of an existing single-use payment method to be vaulted."""
  paymentMethodId: ID!

  """
  Deprecated: This field is included for supporting legacy clients. Please use `verification.merchantAccountId` instead.
  
  ID of the merchant account to use when verifying the payment method.
  """
  verificationMerchantAccountId: ID

  """
  Input fields that specify options for verifying the payment method before
  vaulting. Only applicable if the payment method is of a type that supports
  verification. For supported types, verification is performed by default. If
  the verification fails, the payment method will not be vaulted.
  """
  verification: PaymentMethodVerificationOptionsInput

  """
  ID of the customer to associate the resulting multi-use payment method with.
  """
  customerId: ID

  """
  Results of a merchant-performed 3D Secure authentication. You will only need
  to use these fields if you've performed your own integration with a 3D Secure
  MPI provider (e.g. Cardinal Centinel). Otherwise, Braintree's SDKs handle this
  for you in our standard 3D Secure integration.
  """
  threeDSecurePassThrough: ThreeDSecurePassThroughInput
}

"""Top-level output field from vaulting a payment method."""
type VaultPaymentMethodPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """
  A payment method that has been stored in a merchant's vault and can be reused.
  """
  paymentMethod: PaymentMethod

  """The verification that was run on the payment method prior to vaulting."""
  verification: Verification
}

"""
Top-level input fields for importing and vaulting a PayPal Billing Agreement.
"""
input VaultPayPalBillingAgreementInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """
  ID of a PayPal Billing Agreement, that was not created through Braintree, to import and vault.
  """
  billingAgreementId: String!

  """
  Optional ID of the customer to associate the resulting payment method with.
  """
  customerId: ID

  """
  Optional ID of the merchant account associated with the linked PayPal account
  to be used to retrieve billing agreement details from PayPal. Only used for
  merchants with the PayPal multi-account feature enabled in Braintree.
  """
  merchantAccountId: ID

  """
  The merchant (payee) PayPal account associated with the PayPal Billing
  Agreement being vaulted. Only used when the specified merchant account is
  specially configured to handle indirect PayPal accounts.
  """
  indirectPayee: PayPalAccountInput
}

"""
Top-level fields returned when importing and vaulting a PayPal Billing Agreement.
"""
type VaultPayPalBillingAgreementPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """
  The vaulted payment method containing the imported PayPal Billing Agreement.
  """
  paymentMethod: PaymentMethod
}

"""
Top-level input field for vaulting a bank account so it can be used multiple times.
"""
input VaultUsBankAccountInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of an existing single-use payment method to be vaulted."""
  paymentMethodId: ID!

  """ID of the merchant account to use when verifying the payment method."""
  verificationMerchantAccountId: ID

  """
  ID of the customer to associate the resulting multi-use payment method with.
  """
  customerId: ID

  """Type of US bank account verification to perform."""
  verificationMethod: UsBankAccountVerificationMethod!
}

"""Details about a Venmo Account."""
type VenmoAccountDetails {
  """The Venmo username, as chosen by the user."""
  username: String

  """The Venmo user ID."""
  venmoUserId: String
}

"""Configuration for Pay with Venmo."""
type VenmoConfiguration {
  """The Venmo merchant ID."""
  merchantId: String

  """Authorization to use when tokenizing a Venmo payment method."""
  accessToken: String

  """The Venmo environment."""
  environment: VenmoEnvironment
}

"""The environment being used for Pay with Venmo."""
enum VenmoEnvironment {
  PRODUCTION
  SANDBOX
  production
  sandbox
}

"""
A verification reporting whether the payment method has passed your fraud rules
and the issuer has ensured it is associated with a valid account.
"""
type Verification implements Node {
  """Unique identifier."""
  id: ID!

  """Legacy unique identifier."""
  legacyId: ID!

  """
  Snapshot of payment method details that were verified. This will always be present.
  """
  paymentMethodSnapshot: PaymentMethodSnapshot

  """
  The multi-use payment method that was verified, if it was vaulted. The details
  of this PaymentMethod may have changed since it was verified.
  """
  paymentMethod: PaymentMethod

  """For a credit card, the amount used when performing the verification."""
  amount: MonetaryAmount @deprecated(reason: "Depending on the type of payment method being verified, some verifications do not have an amount. On a credit card verification, use `paymentMethodVerificationDetails.amount` instead.")

  """The merchant account used for the verification."""
  merchantAccountId: ID

  """
  The current status of this verification, indicating whether the verification
  was successful. Braintree recommends only vaulting payment methods that are
  successfully verified.
  """
  status: VerificationStatus

  """
  Detailed response information from the processor. Will not be present if the
  verification was rejected prior to contacting the processor.
  """
  processorResponse: VerificationProcessorResponse

  """Fields describing the network response to the verification request."""
  networkResponse: PaymentNetworkResponse

  """Date and time at which the verification was created."""
  createdAt: Timestamp

  """
  The reason the verification was rejected. This will only be set if status is GATEWAY_REJECTED.
  """
  gatewayRejectionReason: GatewayRejectionReason

  """Risk data evaluated for this verification."""
  riskData: RiskData

  """
  Details unique to the verification based on payment method type being verified.
  """
  paymentMethodVerificationDetails: VerificationDetails
}

"""A paginated list of verifications."""
type VerificationConnection {
  """A list of verifications."""
  edges: [VerificationConnectionEdge]

  """Information about the page of verifications contained in `edges`."""
  pageInfo: PageInfo!
}

"""A verification within a VerificationConnection."""
type VerificationConnectionEdge {
  """
  The verification's location within the VerificationConnection. Used for requesting additional pages.
  """
  cursor: String

  """The verification."""
  node: Verification
}

"""
A union of all possible verification details specific to the type of payment method being verified.
"""
union VerificationDetails = UsBankAccountVerificationDetails | CreditCardVerificationDetails

"""Detailed response information from the processor."""
type VerificationProcessorResponse {
  """
  The [processor response code](https://developers.braintreepayments.com/reference/general/processor-responses/authorization-responses)
  indicating the result of attempting the verification.
  """
  legacyCode: String

  """The text explanation of the processor response code."""
  message: String

  """The processing bank's response to the provided CVV."""
  cvvResponse: AvsCvvResponseCode

  """
  The processing bank's response to the provided billing postal or zip code.
  """
  avsPostalCodeResponse: AvsCvvResponseCode

  """The processing bank's response to the provided billing street address."""
  avsStreetAddressResponse: AvsCvvResponseCode

  """
  If present, any additional information recieved from the processor. May provide further insight into the `legacyCode`.
  """
  additionalInformation: String
}

"""Input fields for searching for verifications."""
input VerificationSearchInput {
  """Find verifications with an ID or IDs."""
  id: SearchValueInput

  """Find verifications with a given status."""
  status: SearchVerificationStatusInput

  """Find verifications with a given created at time."""
  createdAt: SearchTimestampInput
}

"""
The status of the verification, indicating whether the payment method was
successfully verified. Braintree recommends only vaulting payment methods with
successful verifications.
"""
enum VerificationStatus {
  """
  Indicates the verification was unsuccessful because of an issue communicating with the processor.
  """
  FAILED

  """
  Indicates that the verification was unsuccessful because the payment method
  failed one or more fraud checks. In this case, the `gatewayRejectionReason`
  will indicate which fraud check failed.
  """
  GATEWAY_REJECTED

  """Indicates that the verification is pending."""
  PENDING

  """
  Indicates that the verification was unsuccessful based on the response from the processor.
  """
  PROCESSOR_DECLINED

  """Indicates that the verification was successful."""
  VERIFIED

  """Indicates that the verification is in the process of verifying."""
  VERIFYING
}

"""Verifone specific in-store reader information."""
type VerifoneVendor {
  """Model name or number of reader."""
  model: String

  """Current OS version running on the reader."""
  osVersion: String
}

"""Top-level input field for verifying a multi-use credit card."""
input VerifyCreditCardInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of an existing multi-use payment method to be vaulted."""
  paymentMethodId: ID!

  """ID of the merchant account to use when verifying the credit card."""
  merchantAccountId: ID

  """Input fields for verifying a credit card."""
  options: CreditCardVerificationOptionsInput
}

"""Top-level input field for verifying a multi-use payment method."""
input VerifyPaymentMethodInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of an existing multi-use payment method to be verified."""
  paymentMethodId: ID!

  """ID of the merchant account to use when verifying the payment method."""
  merchantAccountId: ID
}

"""Top-level output field from verifying a payment method."""
type VerifyPaymentMethodPayload {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """The verification that was run on the payment method."""
  verification: Verification
}

"""Top-level input field for retrying a verification on a bank account."""
input VerifyUsBankAccountInput {
  """An identifier used to reconcile requests and responses."""
  clientMutationId: String

  """ID of an existing multi-use payment method to be vaulted."""
  paymentMethodId: ID!

  """ID of the merchant account to use when verifying the payment method."""
  merchantAccountId: ID

  """Type of US bank account verification to perform."""
  verificationMethod: UsBankAccountVerificationMethod!
}

"""Details about the user and merchant authenticated in this request."""
type Viewer {
  """Unique identifier."""
  id: ID @deprecated(reason: "Use `user` for id instead.")

  """Email address."""
  email: String @deprecated(reason: "Use `user` for email instead.")

  """Current status."""
  status: UserStatus @deprecated(reason: "Use `user` for status instead.")

  """Full name."""
  name: String @deprecated(reason: "Use `user` for name instead.")

  """Associated roles."""
  roles: [Role!] @deprecated(reason: "Use `user` for roles instead.")

  """Details about the authenticated user."""
  user: User

  """Details about the authenticated merchant."""
  merchant: Merchant
}

"""Configuration for Visa Checkout."""
type VisaCheckoutConfiguration {
  """The Visa Checkout API key."""
  apiKey: String

  """The Visa Checkout external client ID."""
  externalClientId: String

  """A list of card brands supported by the merchant for Visa Checkout."""
  supportedCardBrands: [CreditCardBrandCode!]
}

"""
Additional information about the payment method specific to Visa Checkout.
"""
type VisaCheckoutOriginDetails {
  """The Visa assigned identifier for the transaction."""
  callId: String

  """
  The first 6 digits of the credit card, known as the Bank Identification
  Number. This BIN may differ from the BIN of the customer's actual card.
  """
  bin: String
}

"""Accompanying information for a transaction that has been voided."""
type VoidedEvent implements PaymentStatusEvent {
  """The new status of the transaction."""
  status: PaymentStatus

  """Date and time when the transaction was voided."""
  timestamp: Timestamp

  """
  The amount of the voided transaction. This should match the authorization amount.
  """
  amount: MonetaryAmount

  """The source for the transaction change to the new status."""
  source: PaymentSource

  """Whether or not this is the final state for the transaction."""
  terminal: Boolean
}

"""A four-digit year."""
scalar Year