README

Go Stripe

GoDoc Build Status Coverage Status

The official Stripe Go client library.

Installation

Install stripe-go with:

go get -u github.com/stripe/stripe-go

Then, import it using:

import (
    "github.com/stripe/stripe-go"
    "github.com/stripe/stripe-go/customer"
)
Go Module Support

The library currently does not ship with first-class support for Go modules. We put in support for it before, but ran into compatibility problems for existing installations using Dep (see discussion in closer to the bottom of this thread), and reverted support. Our current plan is to wait for better module compatibility in Dep (see a preliminary patch here), give the release a little grace time to become more widely distributed, then bring support back.

For now, require stripe-go in go.mod with a version but without a version suffix in the path like so:

module github.com/my/package

require (
    github.com/stripe/stripe-go v70.15.0
)

And use the same style of import paths as above:

import (
    "github.com/stripe/stripe-go"
    "github.com/stripe/stripe-go/customer"
)

Documentation

For a comprehensive list of examples, check out the API documentation.

For details on all the functionality in this library, see the GoDoc documentation.

Below are a few simple examples:

Customers
params := &stripe.CustomerParams{
	Description: stripe.String("Stripe Developer"),
	Email:       stripe.String("gostripe@stripe.com"),
}

customer, err := customer.New(params)
PaymentIntents
params := &stripe.PaymentIntentListParams{
    Customer: stripe.String(customer.ID),
}

// set this so you can easily retry your request in case of a timeout
params.Params.IdempotencyKey = stripe.NewIdempotencyKey()

i := paymentintent.List(params)
for i.Next() {
	pi := i.PaymentIntent()
}

if err := i.Err(); err != nil {
	// handle
}
Events
i := event.List(nil)
for i.Next() {
	e := i.Event()

	// access event data via e.GetObjectValue("resource_name_based_on_type", "resource_property_name")
	// alternatively you can access values via e.Data.Object["resource_name_based_on_type"].(map[string]interface{})["resource_property_name"]

	// access previous attributes via e.GetPreviousValue("resource_name_based_on_type", "resource_property_name")
	// alternatively you can access values via e.Data.PrevPreviousAttributes["resource_name_based_on_type"].(map[string]interface{})["resource_property_name"]
}

Alternatively, you can use the event.Data.Raw property to unmarshal to the appropriate struct.

Authentication with Connect

There are two ways of authenticating requests when performing actions on behalf of a connected account, one that uses the Stripe-Account header containing an account's ID, and one that uses the account's keys. Usually the former is the recommended approach. See the documentation for more information.

To use the Stripe-Account approach, use SetStripeAccount() on a ListParams or Params class. For example:

// For a list request
listParams := &stripe.CustomerListParams{}
listParams.SetStripeAccount("acct_123")
// For any other kind of request
params := &stripe.CustomerParams{}
params.SetStripeAccount("acct_123")

To use a key, pass it to API's Init function:


import (
	"github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/client"
)

stripe := &client.API{}
stripe.Init("access_token", nil)
Google AppEngine

If you're running the client in a Google AppEngine environment, you'll need to create a per-request Stripe client since the http.DefaultClient is not available. Here's a sample handler:

import (
	"fmt"
	"net/http"

	"google.golang.org/appengine"
	"google.golang.org/appengine/urlfetch"

	"github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/client"
)

func handler(w http.ResponseWriter, r *http.Request) {
        c := appengine.NewContext(r)
        httpClient := urlfetch.Client(c)

        sc := stripeClient.New("sk_test_123", stripe.NewBackends(httpClient))

        params := &stripe.CustomerParams{
            Description: stripe.String("Stripe Developer"),
            Email:       stripe.String("gostripe@stripe.com"),
        }
        customer, err := sc.Customers.New(params)
        if err != nil {
            fmt.Fprintf(w, "Could not create customer: %v", err)
        }
        fmt.Fprintf(w, "Customer created: %v", customer.ID)
}

Usage

While some resources may contain more/less APIs, the following pattern is applied throughout the library for a given $resource$:

Without a Client

If you're only dealing with a single key, you can simply import the packages required for the resources you're interacting with without the need to create a client.

import (
	"github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/$resource$"
)

// Setup
stripe.Key = "sk_key"

stripe.SetBackend("api", backend) // optional, useful for mocking

// Create
$resource$, err := $resource$.New(stripe.$Resource$Params)

// Get
$resource$, err := $resource$.Get(id, stripe.$Resource$Params)

// Update
$resource$, err := $resource$.Update(stripe.$Resource$Params)

// Delete
resourceDeleted, err := $resource$.Del(id, stripe.$Resource$Params)

// List
i := $resource$.List(stripe.$Resource$ListParams)
for i.Next() {
	$resource$ := i.$Resource$()
}

if err := i.Err(); err != nil {
	// handle
}
With a Client

If you're dealing with multiple keys, it is recommended you use client.API. This allows you to create as many clients as needed, each with their own individual key.

import (
	"github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/client"
)

// Setup
sc := &client.API{}
sc.Init("sk_key", nil) // the second parameter overrides the backends used if needed for mocking

// Create
$resource$, err := sc.$Resource$s.New(stripe.$Resource$Params)

// Get
$resource$, err := sc.$Resource$s.Get(id, stripe.$Resource$Params)

// Update
$resource$, err := sc.$Resource$s.Update(stripe.$Resource$Params)

// Delete
resourceDeleted, err := sc.$Resource$s.Del(id, stripe.$Resource$Params)

// List
i := sc.$Resource$s.List(stripe.$Resource$ListParams)
for i.Next() {
	resource := i.$Resource$()
}

if err := i.Err(); err != nil {
	// handle
}
Configuring Automatic Retries

You can enable automatic retries on requests that fail due to a transient problem by configuring the maximum number of retries:

import (
	"github.com/stripe/stripe-go"
	"github.com/stripe/stripe-go/client"
)

config := &stripe.BackendConfig{
    MaxNetworkRetries: 2,
}

sc := &client.API{}
sc.Init("sk_key", &stripe.Backends{
    API:     stripe.GetBackendWithConfig(stripe.APIBackend, config),
    Uploads: stripe.GetBackendWithConfig(stripe.UploadsBackend, config),
})

coupon, err := sc.Coupons.New(...)

Various errors can trigger a retry, like a connection error or a timeout, and also certain API responses like HTTP status 409 Conflict.

Idempotency keys are added to requests to guarantee that retries are safe.

Configuring Logging

Configure logging using the global DefaultLeveledLogger variable:

stripe.DefaultLeveledLogger = &stripe.LeveledLogger{
    Level: stripe.LevelInfo,
}

Or on a per-backend basis:

config := &stripe.BackendConfig{
    LeveledLogger: &stripe.LeveledLogger{
        Level: stripe.LevelInfo,
    },
}

It's possible to use non-Stripe leveled loggers as well. Stripe expects loggers to comply to the following interface:

type LeveledLoggerInterface interface {
	Debugf(format string, v ...interface{})
	Errorf(format string, v ...interface{})
	Infof(format string, v ...interface{})
	Warnf(format string, v ...interface{})
}

Some loggers like Logrus and Zap's SugaredLogger support this interface out-of-the-box so it's possible to set DefaultLeveledLogger to a *logrus.Logger or *zap.SugaredLogger directly. For others it may be necessary to write a thin shim layer to support them.

Writing a Plugin

If you're writing a plugin that uses the library, we'd appreciate it if you identified using stripe.SetAppInfo:

stripe.SetAppInfo(&stripe.AppInfo{
    Name:    "MyAwesomePlugin",
    URL:     "https://myawesomeplugin.info",
    Version: "1.2.34",
})

This information is passed along when the library makes calls to the Stripe API. Note that while Name is always required, URL and Version are optional.

Request latency telemetry

By default, the library sends request latency telemetry to Stripe. These numbers help Stripe improve the overall latency of its API for all users.

You can disable this behavior if you prefer:

config := &stripe.BackendConfig{
	EnableTelemetry: false,
}

Development

Pull requests from the community are welcome. If you submit one, please keep the following guidelines in mind:

  1. Code must be go fmt compliant.
  2. All types, structs and funcs should be documented.
  3. Ensure that make test succeeds.

Test

The test suite needs testify's require package to run:

github.com/stretchr/testify/require

Before running the tests, make sure to grab all of the package's dependencies:

go get -t -v

It also depends on stripe-mock, so make sure to fetch and run it from a background terminal (stripe-mock's README also contains instructions for installing via Homebrew and other methods):

go get -u github.com/stripe/stripe-mock
stripe-mock

Run all tests:

make test

Run tests for one package:

go test ./invoice

Run a single test:

go test ./invoice -run TestInvoiceGet

For any requests, bug or comments, please open an issue or submit a pull request.

Documentation

Overview

    Package stripe provides the binding for Stripe REST APIs.

    Index

    Examples

    Constants

    View Source
    const (
    	EndingBefore  = "ending_before"
    	StartingAfter = "starting_after"
    )

      Contains constants for the names of parameters used for pagination in list APIs.

      View Source
      const (
      	// APIVersion is the currently supported API version
      	APIVersion string = "2020-03-02"
      
      	// APIBackend is a constant representing the API service backend.
      	APIBackend SupportedBackend = "api"
      
      	// APIURL is the URL of the API service backend.
      	APIURL string = "https://api.stripe.com"
      
      	// ConnectURL is the URL for OAuth.
      	ConnectURL string = "https://connect.stripe.com"
      
      	// ConnectBackend is a constant representing the connect service backend for
      	// OAuth.
      	ConnectBackend SupportedBackend = "connect"
      
      	// UnknownPlatform is the string returned as the system name if we couldn't get
      	// one from `uname`.
      	UnknownPlatform string = "unknown platform"
      
      	// UploadsBackend is a constant representing the uploads service backend.
      	UploadsBackend SupportedBackend = "uploads"
      
      	// UploadsURL is the URL of the uploads service backend.
      	UploadsURL string = "https://files.stripe.com"
      )
      View Source
      const (
      	UsageRecordActionIncrement string = "increment"
      	UsageRecordActionSet       string = "set"
      )

        Possible values for the action parameter on usage record creation.

        Variables

        View Source
        var EnableTelemetry = true

          EnableTelemetry is a global override for enabling client telemetry, which sends request performance metrics to Stripe via the `X-Stripe-Client-Telemetry` header. If set to true, all clients will send telemetry metrics. Defaults to true.

          Telemetry can also be disabled on a per-client basis by instead creating a `BackendConfig` with `EnableTelemetry: false`.

            Key is the Stripe API key used globally in the binding.

            View Source
            var LogLevel = 2

              LogLevel is the logging level for this library. 0: no logging 1: errors only 2: errors + informational (default) 3: errors + informational + debug

              Deprecated: Logging should be configured with DefaultLeveledLogger instead.

              Functions

              func Bool

              func Bool(v bool) *bool

                Bool returns a pointer to the bool value passed in.

                func BoolSlice

                func BoolSlice(v []bool) []*bool

                  BoolSlice returns a slice of bool pointers given a slice of bools.

                  func BoolValue

                  func BoolValue(v *bool) bool

                    BoolValue returns the value of the bool pointer passed in or false if the pointer is nil.

                    func Float64

                    func Float64(v float64) *float64

                      Float64 returns a pointer to the float64 value passed in.

                      func Float64Slice

                      func Float64Slice(v []float64) []*float64

                        Float64Slice returns a slice of float64 pointers given a slice of float64s.

                        func Float64Value

                        func Float64Value(v *float64) float64

                          Float64Value returns the value of the float64 pointer passed in or 0 if the pointer is nil.

                          func FormatURLPath

                          func FormatURLPath(format string, params ...string) string

                            FormatURLPath takes a format string (of the kind used in the fmt package) representing a URL path with a number of parameters that belong in the path and returns a formatted string.

                            This is mostly a pass through to Sprintf. It exists to make it it impossible to accidentally provide a parameter type that would be formatted improperly; for example, a string pointer instead of a string.

                            It also URL-escapes every given parameter. This usually isn't necessary for a standard Stripe ID, but is needed in places where user-provided IDs are allowed, like in coupons or plans. We apply it broadly for extra safety.

                            func Int64

                            func Int64(v int64) *int64

                              Int64 returns a pointer to the int64 value passed in.

                              func Int64Slice

                              func Int64Slice(v []int64) []*int64

                                Int64Slice returns a slice of int64 pointers given a slice of int64s.

                                func Int64Value

                                func Int64Value(v *int64) int64

                                  Int64Value returns the value of the int64 pointer passed in or 0 if the pointer is nil.

                                  func NewIdempotencyKey

                                  func NewIdempotencyKey() string

                                    NewIdempotencyKey generates a new idempotency key that can be used on a request.

                                    func ParseID

                                    func ParseID(data []byte) (string, bool)

                                      ParseID attempts to parse a string scalar from a given JSON value which is still encoded as []byte. If the value was a string, it returns the string along with true as the second return value. If not, false is returned as the second return value.

                                      The purpose of this function is to detect whether a given value in a response from the Stripe API is a string ID or an expanded object.

                                      func SetAppInfo

                                      func SetAppInfo(info *AppInfo)

                                        SetAppInfo sets app information. See AppInfo.

                                        func SetBackend

                                        func SetBackend(backend SupportedBackend, b Backend)

                                          SetBackend sets the backend used in the binding.

                                          func SetHTTPClient

                                          func SetHTTPClient(client *http.Client)

                                            SetHTTPClient overrides the default HTTP client. This is useful if you're running in a Google AppEngine environment where the http.DefaultClient is not available.

                                            func String

                                            func String(v string) *string

                                              String returns a pointer to the string value passed in.

                                              func StringSlice

                                              func StringSlice(v []string) []*string

                                                StringSlice returns a slice of string pointers given a slice of strings.

                                                func StringValue

                                                func StringValue(v *string) string

                                                  StringValue returns the value of the string pointer passed in or "" if the pointer is nil.

                                                  Types

                                                  type APIConnectionError

                                                  type APIConnectionError struct {
                                                  	// contains filtered or unexported fields
                                                  }

                                                    APIConnectionError is a failure to connect to the Stripe API.

                                                    func (*APIConnectionError) Error

                                                    func (e *APIConnectionError) Error() string

                                                      Error serializes the error object to JSON and returns it as a string.

                                                      type APIError

                                                      type APIError struct {
                                                      	// contains filtered or unexported fields
                                                      }

                                                        APIError is a catch all for any errors not covered by other types (and should be extremely uncommon).

                                                        func (*APIError) Error

                                                        func (e *APIError) Error() string

                                                          Error serializes the error object to JSON and returns it as a string.

                                                          type Account

                                                          type Account struct {
                                                          	BusinessProfile  *AccountBusinessProfile `json:"business_profile"`
                                                          	BusinessType     AccountBusinessType     `json:"business_type"`
                                                          	Capabilities     *AccountCapabilities    `json:"capabilities"`
                                                          	ChargesEnabled   bool                    `json:"charges_enabled"`
                                                          	Company          *AccountCompany         `json:"company"`
                                                          	Country          string                  `json:"country"`
                                                          	Created          int64                   `json:"created"`
                                                          	DefaultCurrency  Currency                `json:"default_currency"`
                                                          	Deleted          bool                    `json:"deleted"`
                                                          	DetailsSubmitted bool                    `json:"details_submitted"`
                                                          	Email            string                  `json:"email"`
                                                          	ExternalAccounts *ExternalAccountList    `json:"external_accounts"`
                                                          	ID               string                  `json:"id"`
                                                          	Individual       *Person                 `json:"individual"`
                                                          	Metadata         map[string]string       `json:"metadata"`
                                                          	Object           string                  `json:"object"`
                                                          	PayoutsEnabled   bool                    `json:"payouts_enabled"`
                                                          	Requirements     *AccountRequirements    `json:"requirements"`
                                                          	Settings         *AccountSettings        `json:"settings"`
                                                          	TOSAcceptance    *AccountTOSAcceptance   `json:"tos_acceptance"`
                                                          	Type             AccountType             `json:"type"`
                                                          }

                                                            Account is the resource representing your Stripe account. For more details see https://stripe.com/docs/api/#account.

                                                            func (*Account) UnmarshalJSON

                                                            func (a *Account) UnmarshalJSON(data []byte) error

                                                              UnmarshalJSON handles deserialization of an account. This custom unmarshaling is needed because the resulting property may be an ID or the full struct if it was expanded.

                                                              type AccountAddress

                                                              type AccountAddress struct {
                                                              	City       string `json:"city"`
                                                              	Country    string `json:"country"`
                                                              	Line1      string `json:"line1"`
                                                              	Line2      string `json:"line2"`
                                                              	PostalCode string `json:"postal_code"`
                                                              	State      string `json:"state"`
                                                              
                                                              	// Town/cho-me. Note that this is only used for Kana/Kanji representations
                                                              	// of an address.
                                                              	Town string `json:"town"`
                                                              }

                                                                AccountAddress is the structure for an account address.

                                                                type AccountAddressParams

                                                                type AccountAddressParams struct {
                                                                	City       *string `form:"city"`
                                                                	Country    *string `form:"country"`
                                                                	Line1      *string `form:"line1"`
                                                                	Line2      *string `form:"line2"`
                                                                	PostalCode *string `form:"postal_code"`
                                                                	State      *string `form:"state"`
                                                                
                                                                	// Town/cho-me. Note that this is only used for Kana/Kanji representations
                                                                	// of an address.
                                                                	Town *string `form:"town"`
                                                                }

                                                                  AccountAddressParams represents an address during account creation/updates.

                                                                  type AccountBusinessProfile

                                                                  type AccountBusinessProfile struct {
                                                                  	MCC                string   `json:"mcc"`
                                                                  	Name               string   `json:"name"`
                                                                  	ProductDescription string   `json:"product_description"`
                                                                  	SupportAddress     *Address `json:"support_address"`
                                                                  	SupportEmail       string   `json:"support_email"`
                                                                  	SupportPhone       string   `json:"support_phone"`
                                                                  	SupportURL         string   `json:"support_url"`
                                                                  	URL                string   `json:"url"`
                                                                  }

                                                                    AccountBusinessProfile represents optional information related to the business.

                                                                    type AccountBusinessProfileParams

                                                                    type AccountBusinessProfileParams struct {
                                                                    	MCC                *string `form:"mcc"`
                                                                    	Name               *string `form:"name"`
                                                                    	ProductDescription *string `form:"product_description"`
                                                                    	SupportEmail       *string `form:"support_email"`
                                                                    	SupportPhone       *string `form:"support_phone"`
                                                                    	SupportURL         *string `form:"support_url"`
                                                                    	URL                *string `form:"url"`
                                                                    }

                                                                      AccountBusinessProfileParams are the parameters allowed for an account's business information

                                                                      type AccountBusinessType

                                                                      type AccountBusinessType string

                                                                        AccountBusinessType describes the business type associated with an account.

                                                                        const (
                                                                        	AccountBusinessTypeCompany          AccountBusinessType = "company"
                                                                        	AccountBusinessTypeGovernmentEntity AccountBusinessType = "government_entity"
                                                                        	AccountBusinessTypeIndividual       AccountBusinessType = "individual"
                                                                        	AccountBusinessTypeNonProfit        AccountBusinessType = "non_profit"
                                                                        )

                                                                          List of values that AccountBusinessType can take.

                                                                          type AccountCapabilities

                                                                          type AccountCapabilities struct {
                                                                          	AUBECSDebitPayments    AccountCapabilityStatus `json:"au_becs_debit_payments"`
                                                                          	CardPayments           AccountCapabilityStatus `json:"card_payments"`
                                                                          	LegacyPayments         AccountCapabilityStatus `json:"legacy_payments"`
                                                                          	TaxReportingUS1099K    AccountCapabilityStatus `json:"tax_reporting_us_1099_k"`
                                                                          	TaxReportingUS1099MISC AccountCapabilityStatus `json:"tax_reporting_us_1099_misc"`
                                                                          	Transfers              AccountCapabilityStatus `json:"transfers"`
                                                                          }

                                                                            AccountCapabilities is the resource representing the capabilities enabled on that account.

                                                                            type AccountCapability

                                                                            type AccountCapability string

                                                                              AccountCapability maps to a given capability for an account.

                                                                              const (
                                                                              	AccountCapabilityAUBECSDebitPayments    AccountCapability = "au_becs_debit_payments"
                                                                              	AccountCapabilityCardIssuing            AccountCapability = "card_issuing"
                                                                              	AccountCapabilityCardPayments           AccountCapability = "card_payments"
                                                                              	AccountCapabilityLegacyPayments         AccountCapability = "legacy_payments"
                                                                              	AccountCapabilityTaxReportingUS1099K    AccountCapability = "tax_reporting_us_1099_k"
                                                                              	AccountCapabilityTaxReportingUS1099MISC AccountCapability = "tax_reporting_us_1099_misc"
                                                                              	AccountCapabilityTransfers              AccountCapability = "transfers"
                                                                              )

                                                                                List of values that AccountCapability can take.

                                                                                type AccountCapabilityStatus

                                                                                type AccountCapabilityStatus string

                                                                                  AccountCapabilityStatus is the status a given capability can have

                                                                                  const (
                                                                                  	AccountCapabilityStatusActive   AccountCapabilityStatus = "active"
                                                                                  	AccountCapabilityStatusInactive AccountCapabilityStatus = "inactive"
                                                                                  	AccountCapabilityStatusPending  AccountCapabilityStatus = "pending"
                                                                                  )

                                                                                    List of values that AccountCapabilityStatus can take.

                                                                                    type AccountCompany

                                                                                    type AccountCompany struct {
                                                                                    	Address            *AccountAddress             `json:"address"`
                                                                                    	AddressKana        *AccountAddress             `json:"address_kana"`
                                                                                    	AddressKanji       *AccountAddress             `json:"address_kanji"`
                                                                                    	DirectorsProvided  bool                        `json:"directors_provided"`
                                                                                    	ExecutivesProvided bool                        `json:"executives_provided"`
                                                                                    	Name               string                      `json:"name"`
                                                                                    	NameKana           string                      `json:"name_kana"`
                                                                                    	NameKanji          string                      `json:"name_kanji"`
                                                                                    	OwnersProvided     bool                        `json:"owners_provided"`
                                                                                    	Phone              string                      `json:"phone"`
                                                                                    	Structure          AccountCompanyStructure     `json:"structure"`
                                                                                    	TaxIDProvided      bool                        `json:"tax_id_provided"`
                                                                                    	TaxIDRegistrar     string                      `json:"tax_id_registrar"`
                                                                                    	VATIDProvided      bool                        `json:"vat_id_provided"`
                                                                                    	Verification       *AccountCompanyVerification `json:"verification"`
                                                                                    }

                                                                                      AccountCompany represents details about the company or business associated with the account.

                                                                                      type AccountCompanyParams

                                                                                      type AccountCompanyParams struct {
                                                                                      	Address            *AccountAddressParams             `form:"address"`
                                                                                      	AddressKana        *AccountAddressParams             `form:"address_kana"`
                                                                                      	AddressKanji       *AccountAddressParams             `form:"address_kanji"`
                                                                                      	DirectorsProvided  *bool                             `form:"directors_provided"`
                                                                                      	ExecutivesProvided *bool                             `form:"executives_provided"`
                                                                                      	Name               *string                           `form:"name"`
                                                                                      	NameKana           *string                           `form:"name_kana"`
                                                                                      	NameKanji          *string                           `form:"name_kanji"`
                                                                                      	OwnersProvided     *bool                             `form:"owners_provided"`
                                                                                      	Structure          *string                           `form:"structure"`
                                                                                      	Phone              *string                           `form:"phone"`
                                                                                      	TaxID              *string                           `form:"tax_id"`
                                                                                      	TaxIDRegistrar     *string                           `form:"tax_id_registrar"`
                                                                                      	VATID              *string                           `form:"vat_id"`
                                                                                      	Verification       *AccountCompanyVerificationParams `form:"verification"`
                                                                                      }

                                                                                        AccountCompanyParams are the parameters describing the company associated with the account.

                                                                                        type AccountCompanyStructure

                                                                                        type AccountCompanyStructure string

                                                                                          AccountCompanyStructure describes the structure associated with a company.

                                                                                          const (
                                                                                          	AccountCompanyStructureGovernmentInstrumentality          AccountCompanyStructure = "government_instrumentality"
                                                                                          	AccountCompanyStructureGovernmentalUnit                   AccountCompanyStructure = "governmental_unit"
                                                                                          	AccountCompanyStructureIncorporatedNonProfit              AccountCompanyStructure = "incorporated_non_profit"
                                                                                          	AccountCompanyStructureMultiMemberLLC                     AccountCompanyStructure = "multi_member_llc"
                                                                                          	AccountCompanyStructurePrivateCorporation                 AccountCompanyStructure = "private_corporation"
                                                                                          	AccountCompanyStructurePrivatePartnership                 AccountCompanyStructure = "private_partnership"
                                                                                          	AccountCompanyStructurePublicCorporation                  AccountCompanyStructure = "public_corporation"
                                                                                          	AccountCompanyStructurePublicPartnership                  AccountCompanyStructure = "public_partnership"
                                                                                          	AccountCompanyStructureTaxExemptGovernmentInstrumentality AccountCompanyStructure = "tax_exempt_government_instrumentality"
                                                                                          	AccountCompanyStructureUnincorporatedAssociation          AccountCompanyStructure = "unincorporated_association"
                                                                                          	AccountCompanyStructureUnincorporatedNonProfit            AccountCompanyStructure = "unincorporated_non_profit"
                                                                                          )

                                                                                            List of values that AccountCompanyStructure can take.

                                                                                            type AccountCompanyVerification

                                                                                            type AccountCompanyVerification struct {
                                                                                            	Document *AccountCompanyVerificationDocument `json:"document"`
                                                                                            }

                                                                                              AccountCompanyVerification represents details about a company's verification state.

                                                                                              type AccountCompanyVerificationDocument

                                                                                              type AccountCompanyVerificationDocument struct {
                                                                                              	Back        *File                                         `json:"back"`
                                                                                              	Details     string                                        `json:"details"`
                                                                                              	DetailsCode AccountCompanyVerificationDocumentDetailsCode `json:"details_code"`
                                                                                              	Front       *File                                         `json:"front"`
                                                                                              }

                                                                                                AccountCompanyVerificationDocument represents details about a company's verification state.

                                                                                                type AccountCompanyVerificationDocumentDetailsCode

                                                                                                type AccountCompanyVerificationDocumentDetailsCode string

                                                                                                  AccountCompanyVerificationDocumentDetailsCode is a machine-readable code specifying the verification state of a document associated with a company.

                                                                                                  const (
                                                                                                  	AccountCompanyVerificationDocumentDetailsCodeDocumentCorrupt        AccountCompanyVerificationDocumentDetailsCode = "document_corrupt"
                                                                                                  	AccountCompanyVerificationDocumentDetailsCodeDocumentFailedCopy     AccountCompanyVerificationDocumentDetailsCode = "document_failed_copy"
                                                                                                  	AccountCompanyVerificationDocumentDetailsCodeDocumentFailedOther    AccountCompanyVerificationDocumentDetailsCode = "document_failed_other"
                                                                                                  	AccountCompanyVerificationDocumentDetailsCodeDocumentFailedTestMode AccountCompanyVerificationDocumentDetailsCode = "document_failed_test_mode"
                                                                                                  	AccountCompanyVerificationDocumentDetailsCodeDocumentFraudulent     AccountCompanyVerificationDocumentDetailsCode = "document_fraudulent"
                                                                                                  	AccountCompanyVerificationDocumentDetailsCodeDocumentInvalid        AccountCompanyVerificationDocumentDetailsCode = "document_invalid"
                                                                                                  	AccountCompanyVerificationDocumentDetailsCodeDocumentManipulated    AccountCompanyVerificationDocumentDetailsCode = "document_manipulated"
                                                                                                  	AccountCompanyVerificationDocumentDetailsCodeDocumentNotReadable    AccountCompanyVerificationDocumentDetailsCode = "document_not_readable"
                                                                                                  	AccountCompanyVerificationDocumentDetailsCodeDocumentNotUploaded    AccountCompanyVerificationDocumentDetailsCode = "document_not_uploaded"
                                                                                                  	AccountCompanyVerificationDocumentDetailsCodeDocumentTooLarge       AccountCompanyVerificationDocumentDetailsCode = "document_too_large"
                                                                                                  )

                                                                                                    List of values that AccountCompanyVerificationDocumentDetailsCode can take.

                                                                                                    type AccountCompanyVerificationDocumentParams

                                                                                                    type AccountCompanyVerificationDocumentParams struct {
                                                                                                    	Back  *string `form:"back"`
                                                                                                    	Front *string `form:"front"`
                                                                                                    }

                                                                                                      AccountCompanyVerificationDocumentParams are the parameters allowed to pass for a document verifying a company.

                                                                                                      type AccountCompanyVerificationParams

                                                                                                      type AccountCompanyVerificationParams struct {
                                                                                                      	Document *AccountCompanyVerificationDocumentParams `form:"document"`
                                                                                                      }

                                                                                                        AccountCompanyVerificationParams are the parameters allowed to verify a company.

                                                                                                        type AccountDeclineOn

                                                                                                        type AccountDeclineOn struct {
                                                                                                        	AVSFailure bool `json:"avs_failure"`
                                                                                                        	CVCFailure bool `json:"cvc_failure"`
                                                                                                        }

                                                                                                          AccountDeclineOn represents card charges decline behavior for that account.

                                                                                                          type AccountDeclineSettingsParams

                                                                                                          type AccountDeclineSettingsParams struct {
                                                                                                          	AVSFailure *bool `form:"avs_failure"`
                                                                                                          	CVCFailure *bool `form:"cvc_failure"`
                                                                                                          }

                                                                                                            AccountDeclineSettingsParams represents the parameters allowed for configuring card declines on connected accounts.

                                                                                                            type AccountExternalAccountParams

                                                                                                            type AccountExternalAccountParams struct {
                                                                                                            	Params            `form:"*"`
                                                                                                            	AccountNumber     *string `form:"account_number"`
                                                                                                            	AccountHolderName *string `form:"account_holder_name"`
                                                                                                            	AccountHolderType *string `form:"account_holder_type"`
                                                                                                            	Country           *string `form:"country"`
                                                                                                            	Currency          *string `form:"currency"`
                                                                                                            	RoutingNumber     *string `form:"routing_number"`
                                                                                                            	Token             *string `form:"token"`
                                                                                                            }

                                                                                                              AccountExternalAccountParams are the parameters allowed to reference an external account when creating an account. It should either have Token set or everything else.

                                                                                                              func (*AccountExternalAccountParams) AppendTo

                                                                                                              func (p *AccountExternalAccountParams) AppendTo(body *form.Values, keyParts []string)

                                                                                                                AppendTo implements custom encoding logic for AccountExternalAccountParams so that we can send the special required `object` field up along with the other specified parameters or the token value.

                                                                                                                type AccountLink struct {
                                                                                                                	Created   int64  `json:"created"`
                                                                                                                	ExpiresAt int64  `json:"expires_at"`
                                                                                                                	Object    string `json:"object"`
                                                                                                                	URL       string `json:"url"`
                                                                                                                }

                                                                                                                  AccountLink is the resource representing an account link. For more details see https://stripe.com/docs/api/#account_links.

                                                                                                                  type AccountLinkCollect

                                                                                                                  type AccountLinkCollect string

                                                                                                                    AccountLinkCollect describes what information the platform wants to collect with the account link.

                                                                                                                    const (
                                                                                                                    	AccountLinkCollectCurrentlyDue  AccountLinkCollect = "currently_due"
                                                                                                                    	AccountLinkCollectEventuallyDue AccountLinkCollect = "eventually_due"
                                                                                                                    )

                                                                                                                      List of values that AccountLinkCollect can take.

                                                                                                                      type AccountLinkParams

                                                                                                                      type AccountLinkParams struct {
                                                                                                                      	Params     `form:"*"`
                                                                                                                      	Account    *string `form:"account"`
                                                                                                                      	Collect    *string `form:"collect"`
                                                                                                                      	FailureURL *string `form:"failure_url"`
                                                                                                                      	SuccessURL *string `form:"success_url"`
                                                                                                                      	Type       *string `form:"type"`
                                                                                                                      }

                                                                                                                        AccountLinkParams are the parameters allowed during an account link creation.

                                                                                                                        type AccountLinkType

                                                                                                                        type AccountLinkType string

                                                                                                                          AccountLinkType is the type of an account link.

                                                                                                                          const (
                                                                                                                          	AccountLinkTypeCustomAccountUpdate       AccountLinkType = "custom_account_update"
                                                                                                                          	AccountLinkTypeCustomAccountVerification AccountLinkType = "custom_account_verification"
                                                                                                                          )

                                                                                                                            List of values that AccountLinkType can take.

                                                                                                                            type AccountList

                                                                                                                            type AccountList struct {
                                                                                                                            	ListMeta
                                                                                                                            	Data []*Account `json:"data"`
                                                                                                                            }

                                                                                                                              AccountList is a list of accounts as returned from a list endpoint.

                                                                                                                              type AccountListParams

                                                                                                                              type AccountListParams struct {
                                                                                                                              	ListParams `form:"*"`
                                                                                                                              }

                                                                                                                                AccountListParams are the parameters allowed during account listing.

                                                                                                                                type AccountParams

                                                                                                                                type AccountParams struct {
                                                                                                                                	Params                `form:"*"`
                                                                                                                                	AccountToken          *string                       `form:"account_token"`
                                                                                                                                	BusinessProfile       *AccountBusinessProfileParams `form:"business_profile"`
                                                                                                                                	BusinessType          *string                       `form:"business_type"`
                                                                                                                                	Company               *AccountCompanyParams         `form:"company"`
                                                                                                                                	Country               *string                       `form:"country"`
                                                                                                                                	DefaultCurrency       *string                       `form:"default_currency"`
                                                                                                                                	Email                 *string                       `form:"email"`
                                                                                                                                	ExternalAccount       *AccountExternalAccountParams `form:"external_account"`
                                                                                                                                	Individual            *PersonParams                 `form:"individual"`
                                                                                                                                	RequestedCapabilities []*string                     `form:"requested_capabilities"`
                                                                                                                                	Settings              *AccountSettingsParams        `form:"settings"`
                                                                                                                                	TOSAcceptance         *AccountTOSAcceptanceParams   `form:"tos_acceptance"`
                                                                                                                                	Type                  *string                       `form:"type"`
                                                                                                                                }

                                                                                                                                  AccountParams are the parameters allowed during account creation/updates.

                                                                                                                                  type AccountPayoutSchedule

                                                                                                                                  type AccountPayoutSchedule struct {
                                                                                                                                  	DelayDays     int64          `json:"delay_days"`
                                                                                                                                  	Interval      PayoutInterval `json:"interval"`
                                                                                                                                  	MonthlyAnchor int64          `json:"monthly_anchor"`
                                                                                                                                  	WeeklyAnchor  string         `json:"weekly_anchor"`
                                                                                                                                  }

                                                                                                                                    AccountPayoutSchedule is the structure for an account's payout schedule.

                                                                                                                                    type AccountRejectParams

                                                                                                                                    type AccountRejectParams struct {
                                                                                                                                    	Params `form:"*"`
                                                                                                                                    	Reason *string `form:"reason"`
                                                                                                                                    }

                                                                                                                                      AccountRejectParams is the structure for the Reject function.

                                                                                                                                      type AccountRejectReason

                                                                                                                                      type AccountRejectReason string

                                                                                                                                        AccountRejectReason describes the valid reason to reject an account

                                                                                                                                        const (
                                                                                                                                        	AccountRejectReasonFraud          AccountRejectReason = "fraud"
                                                                                                                                        	AccountRejectReasonOther          AccountRejectReason = "other"
                                                                                                                                        	AccountRejectReasonTermsOfService AccountRejectReason = "terms_of_service"
                                                                                                                                        )

                                                                                                                                          List of values that AccountRejectReason can take.

                                                                                                                                          type AccountRequirements

                                                                                                                                          type AccountRequirements struct {
                                                                                                                                          	CurrentDeadline     int64                             `json:"current_deadline"`
                                                                                                                                          	CurrentlyDue        []string                          `json:"currently_due"`
                                                                                                                                          	DisabledReason      AccountRequirementsDisabledReason `json:"disabled_reason"`
                                                                                                                                          	Errors              []*AccountRequirementsError       `json:"errors"`
                                                                                                                                          	EventuallyDue       []string                          `json:"eventually_due"`
                                                                                                                                          	PastDue             []string                          `json:"past_due"`
                                                                                                                                          	PendingVerification []string                          `json:"pending_verification"`
                                                                                                                                          }

                                                                                                                                            AccountRequirements represents information that needs to be collected for an account.

                                                                                                                                            type AccountRequirementsDisabledReason

                                                                                                                                            type AccountRequirementsDisabledReason string

                                                                                                                                              AccountRequirementsDisabledReason describes why an account is disabled.

                                                                                                                                              const (
                                                                                                                                              	AccountRequirementsDisabledReasonFieldsNeeded           AccountRequirementsDisabledReason = "fields_needed"
                                                                                                                                              	AccountRequirementsDisabledReasonListed                 AccountRequirementsDisabledReason = "listed"
                                                                                                                                              	AccountRequirementsDisabledReasonOther                  AccountRequirementsDisabledReason = "other"
                                                                                                                                              	AccountRequirementsDisabledReasonRejectedFraud          AccountRequirementsDisabledReason = "rejected.fraud"
                                                                                                                                              	AccountRequirementsDisabledReasonRejectedListed         AccountRequirementsDisabledReason = "rejected.listed"
                                                                                                                                              	AccountRequirementsDisabledReasonRejectedOther          AccountRequirementsDisabledReason = "rejected.other"
                                                                                                                                              	AccountRequirementsDisabledReasonRejectedTermsOfService AccountRequirementsDisabledReason = "rejected.terms_of_service"
                                                                                                                                              	AccountRequirementsDisabledReasonUnderReview            AccountRequirementsDisabledReason = "under_review"
                                                                                                                                              )

                                                                                                                                                List of values that AccountRequirementsDisabledReason can take.

                                                                                                                                                type AccountRequirementsError

                                                                                                                                                type AccountRequirementsError struct {
                                                                                                                                                	Code        string `json:"code"`
                                                                                                                                                	Reason      string `json:"reason"`
                                                                                                                                                	Requirement string `json:"requirement"`
                                                                                                                                                }

                                                                                                                                                  AccountRequirementsError represents details about an error with a requirement.

                                                                                                                                                  type AccountSettings

                                                                                                                                                  type AccountSettings struct {
                                                                                                                                                  	Branding     *AccountSettingsBranding     `json:"branding"`
                                                                                                                                                  	CardPayments *AccountSettingsCardPayments `json:"card_payments"`
                                                                                                                                                  	Dashboard    *AccountSettingsDashboard    `json:"dashboard"`
                                                                                                                                                  	Payments     *AccountSettingsPayments     `json:"payments"`
                                                                                                                                                  	Payouts      *AccountSettingsPayouts      `json:"payouts"`
                                                                                                                                                  }

                                                                                                                                                    AccountSettings represents options for customizing how the account functions within Stripe.

                                                                                                                                                    type AccountSettingsBranding

                                                                                                                                                    type AccountSettingsBranding struct {
                                                                                                                                                    	Icon           *File  `json:"icon"`
                                                                                                                                                    	PrimaryColor   string `json:"primary_color"`
                                                                                                                                                    	SecondaryColor string `json:"secondary_color"`
                                                                                                                                                    }

                                                                                                                                                      AccountSettingsBranding represents settings specific to the account's branding.

                                                                                                                                                      type AccountSettingsBrandingParams

                                                                                                                                                      type AccountSettingsBrandingParams struct {
                                                                                                                                                      	Icon           *string `form:"icon"`
                                                                                                                                                      	PrimaryColor   *string `form:"primary_color"`
                                                                                                                                                      	SecondaryColor *string `form:"secondary_color"`
                                                                                                                                                      }

                                                                                                                                                        AccountSettingsBrandingParams represent allowed parameters to configure settings specific to the account’s branding.

                                                                                                                                                        type AccountSettingsCardPayments

                                                                                                                                                        type AccountSettingsCardPayments struct {
                                                                                                                                                        	DeclineOn                 *AccountDeclineOn `json:"decline_on"`
                                                                                                                                                        	StatementDescriptorPrefix string            `json:"statement_descriptor_prefix"`
                                                                                                                                                        }

                                                                                                                                                          AccountSettingsCardPayments represents settings specific to card charging on the account.

                                                                                                                                                          type AccountSettingsCardPaymentsParams

                                                                                                                                                          type AccountSettingsCardPaymentsParams struct {
                                                                                                                                                          	DeclineOn                 *AccountDeclineSettingsParams `form:"decline_on"`
                                                                                                                                                          	StatementDescriptorPrefix *string                       `form:"statement_descriptor_prefix"`
                                                                                                                                                          }

                                                                                                                                                            AccountSettingsCardPaymentsParams represent allowed parameters to configure settings specific to card charging on the account.

                                                                                                                                                            type AccountSettingsDashboard

                                                                                                                                                            type AccountSettingsDashboard struct {
                                                                                                                                                            	DisplayName string `json:"display_name"`
                                                                                                                                                            	Timezone    string `json:"timezone"`
                                                                                                                                                            }

                                                                                                                                                              AccountSettingsDashboard represents settings specific to the account's Dashboard.

                                                                                                                                                              type AccountSettingsDashboardParams

                                                                                                                                                              type AccountSettingsDashboardParams struct {
                                                                                                                                                              	DisplayName *string `form:"display_name"`
                                                                                                                                                              	Timezone    *string `form:"timezone"`
                                                                                                                                                              }

                                                                                                                                                                AccountSettingsDashboardParams represent allowed parameters to configure settings for the account's Dashboard.

                                                                                                                                                                type AccountSettingsParams

                                                                                                                                                                type AccountSettingsParams struct {
                                                                                                                                                                	Branding     *AccountSettingsBrandingParams     `form:"branding"`
                                                                                                                                                                	CardPayments *AccountSettingsCardPaymentsParams `form:"card_payments"`
                                                                                                                                                                	Dashboard    *AccountSettingsDashboardParams    `form:"dashboard"`
                                                                                                                                                                	Payments     *AccountSettingsPaymentsParams     `form:"payments"`
                                                                                                                                                                	Payouts      *AccountSettingsPayoutsParams      `form:"payouts"`
                                                                                                                                                                }

                                                                                                                                                                  AccountSettingsParams are the parameters allowed for the account's settings.

                                                                                                                                                                  type AccountSettingsPayments

                                                                                                                                                                  type AccountSettingsPayments struct {
                                                                                                                                                                  	StatementDescriptor      string `json:"statement_descriptor"`
                                                                                                                                                                  	StatementDescriptorKana  string `json:"statement_descriptor_kana"`
                                                                                                                                                                  	StatementDescriptorKanji string `json:"statement_descriptor_kanji"`
                                                                                                                                                                  }

                                                                                                                                                                    AccountSettingsPayments represents settings that apply across payment methods for charging on the account.

                                                                                                                                                                    type AccountSettingsPaymentsParams

                                                                                                                                                                    type AccountSettingsPaymentsParams struct {
                                                                                                                                                                    	StatementDescriptor      *string `form:"statement_descriptor"`
                                                                                                                                                                    	StatementDescriptorKana  *string `form:"statement_descriptor_kana"`
                                                                                                                                                                    	StatementDescriptorKanji *string `form:"statement_descriptor_kanji"`
                                                                                                                                                                    }

                                                                                                                                                                      AccountSettingsPaymentsParams represent allowed parameters to configure settings across payment methods for charging on the account.

                                                                                                                                                                      type AccountSettingsPayouts

                                                                                                                                                                      type AccountSettingsPayouts struct {
                                                                                                                                                                      	DebitNegativeBalances bool                   `json:"debit_negative_balances"`
                                                                                                                                                                      	Schedule              *AccountPayoutSchedule `json:"schedule"`
                                                                                                                                                                      	StatementDescriptor   string                 `json:"statement_descriptor"`
                                                                                                                                                                      }

                                                                                                                                                                        AccountSettingsPayouts represents settings specific to the account’s payouts.

                                                                                                                                                                        type AccountSettingsPayoutsParams

                                                                                                                                                                        type AccountSettingsPayoutsParams struct {
                                                                                                                                                                        	DebitNegativeBalances *bool                 `form:"debit_negative_balances"`
                                                                                                                                                                        	Schedule              *PayoutScheduleParams `form:"schedule"`
                                                                                                                                                                        	StatementDescriptor   *string               `form:"statement_descriptor"`
                                                                                                                                                                        }

                                                                                                                                                                          AccountSettingsPayoutsParams represent allowed parameters to configure settings specific to the account’s payouts.

                                                                                                                                                                          type AccountTOSAcceptance

                                                                                                                                                                          type AccountTOSAcceptance struct {
                                                                                                                                                                          	Date      int64  `json:"date"`
                                                                                                                                                                          	IP        string `json:"ip"`
                                                                                                                                                                          	UserAgent string `json:"user_agent"`
                                                                                                                                                                          }

                                                                                                                                                                            AccountTOSAcceptance represents status of acceptance of our terms of services for the account.

                                                                                                                                                                            type AccountTOSAcceptanceParams

                                                                                                                                                                            type AccountTOSAcceptanceParams struct {
                                                                                                                                                                            	Date      *int64  `form:"date"`
                                                                                                                                                                            	IP        *string `form:"ip"`
                                                                                                                                                                            	UserAgent *string `form:"user_agent"`
                                                                                                                                                                            }

                                                                                                                                                                              AccountTOSAcceptanceParams represents tos_acceptance during account creation/updates.

                                                                                                                                                                              type AccountType

                                                                                                                                                                              type AccountType string

                                                                                                                                                                                AccountType is the type of an account.

                                                                                                                                                                                const (
                                                                                                                                                                                	AccountTypeCustom   AccountType = "custom"
                                                                                                                                                                                	AccountTypeExpress  AccountType = "express"
                                                                                                                                                                                	AccountTypeStandard AccountType = "standard"
                                                                                                                                                                                )

                                                                                                                                                                                  List of values that AccountType can take.

                                                                                                                                                                                  type Address

                                                                                                                                                                                  type Address struct {
                                                                                                                                                                                  	City       string `json:"city"`
                                                                                                                                                                                  	Country    string `json:"country"`
                                                                                                                                                                                  	Line1      string `json:"line1"`
                                                                                                                                                                                  	Line2      string `json:"line2"`
                                                                                                                                                                                  	PostalCode string `json:"postal_code"`
                                                                                                                                                                                  	State      string `json:"state"`
                                                                                                                                                                                  }

                                                                                                                                                                                    Address describes common properties for an Address hash.

                                                                                                                                                                                    type AddressParams

                                                                                                                                                                                    type AddressParams struct {
                                                                                                                                                                                    	City       *string `form:"city"`
                                                                                                                                                                                    	Country    *string `form:"country"`
                                                                                                                                                                                    	Line1      *string `form:"line1"`
                                                                                                                                                                                    	Line2      *string `form:"line2"`
                                                                                                                                                                                    	PostalCode *string `form:"postal_code"`
                                                                                                                                                                                    	State      *string `form:"state"`
                                                                                                                                                                                    }

                                                                                                                                                                                      AddressParams describes the common parameters for an Address.

                                                                                                                                                                                      type Amount

                                                                                                                                                                                      type Amount struct {
                                                                                                                                                                                      	Currency    Currency                    `json:"currency"`
                                                                                                                                                                                      	SourceTypes map[BalanceSourceType]int64 `json:"source_types"`
                                                                                                                                                                                      	Value       int64                       `json:"amount"`
                                                                                                                                                                                      }

                                                                                                                                                                                        Amount is a structure wrapping an amount value and its currency.

                                                                                                                                                                                        type AppInfo

                                                                                                                                                                                        type AppInfo struct {
                                                                                                                                                                                        	Name      string `json:"name"`
                                                                                                                                                                                        	PartnerID string `json:"partner_id"`
                                                                                                                                                                                        	URL       string `json:"url"`
                                                                                                                                                                                        	Version   string `json:"version"`
                                                                                                                                                                                        }

                                                                                                                                                                                          AppInfo contains information about the "app" which this integration belongs to. This should be reserved for plugins that wish to identify themselves with Stripe.

                                                                                                                                                                                          type ApplePayDomain

                                                                                                                                                                                          type ApplePayDomain struct {
                                                                                                                                                                                          	Created    int64  `json:"created"`
                                                                                                                                                                                          	Deleted    bool   `json:"deleted"`
                                                                                                                                                                                          	DomainName string `json:"domain_name"`
                                                                                                                                                                                          	ID         string `json:"id"`
                                                                                                                                                                                          	Livemode   bool   `json:"livemode"`
                                                                                                                                                                                          }

                                                                                                                                                                                            ApplePayDomain is the resource representing a Stripe ApplePayDomain object

                                                                                                                                                                                            type ApplePayDomainList

                                                                                                                                                                                            type ApplePayDomainList struct {
                                                                                                                                                                                            	ListMeta
                                                                                                                                                                                            	Data []*ApplePayDomain `json:"data"`
                                                                                                                                                                                            }

                                                                                                                                                                                              ApplePayDomainList is a list of ApplePayDomains as returned from a list endpoint.

                                                                                                                                                                                              type ApplePayDomainListParams

                                                                                                                                                                                              type ApplePayDomainListParams struct {
                                                                                                                                                                                              	ListParams `form:"*"`
                                                                                                                                                                                              }

                                                                                                                                                                                                ApplePayDomainListParams are the parameters allowed during ApplePayDomain listing.

                                                                                                                                                                                                type ApplePayDomainParams

                                                                                                                                                                                                type ApplePayDomainParams struct {
                                                                                                                                                                                                	Params     `form:"*"`
                                                                                                                                                                                                	DomainName *string `form:"domain_name"`
                                                                                                                                                                                                }

                                                                                                                                                                                                  ApplePayDomainParams is the set of parameters that can be used when creating an ApplePayDomain object.

                                                                                                                                                                                                  type Application

                                                                                                                                                                                                  type Application struct {
                                                                                                                                                                                                  	ID   string `json:"id"`
                                                                                                                                                                                                  	Name string `json:"name"`
                                                                                                                                                                                                  }

                                                                                                                                                                                                    Application describes the properties for an Application.

                                                                                                                                                                                                    func (*Application) UnmarshalJSON

                                                                                                                                                                                                    func (a *Application) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                      UnmarshalJSON handles deserialization of an Application. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

                                                                                                                                                                                                      type ApplicationFee

                                                                                                                                                                                                      type ApplicationFee struct {
                                                                                                                                                                                                      	Account                *Account            `json:"account"`
                                                                                                                                                                                                      	Amount                 int64               `json:"amount"`
                                                                                                                                                                                                      	AmountRefunded         int64               `json:"amount_refunded"`
                                                                                                                                                                                                      	Application            string              `json:"application"`
                                                                                                                                                                                                      	BalanceTransaction     *BalanceTransaction `json:"balance_transaction"`
                                                                                                                                                                                                      	Charge                 *Charge             `json:"charge"`
                                                                                                                                                                                                      	Created                int64               `json:"created"`
                                                                                                                                                                                                      	Currency               Currency            `json:"currency"`
                                                                                                                                                                                                      	ID                     string              `json:"id"`
                                                                                                                                                                                                      	Livemode               bool                `json:"livemode"`
                                                                                                                                                                                                      	OriginatingTransaction *Charge             `json:"originating_transaction"`
                                                                                                                                                                                                      	Refunded               bool                `json:"refunded"`
                                                                                                                                                                                                      	Refunds                *FeeRefundList      `json:"refunds"`
                                                                                                                                                                                                      }

                                                                                                                                                                                                        ApplicationFee is the resource representing a Stripe application fee. For more details see https://stripe.com/docs/api#application_fees.

                                                                                                                                                                                                        func (*ApplicationFee) UnmarshalJSON

                                                                                                                                                                                                        func (f *ApplicationFee) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                          UnmarshalJSON handles deserialization of an ApplicationFee. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

                                                                                                                                                                                                          type ApplicationFeeList

                                                                                                                                                                                                          type ApplicationFeeList struct {
                                                                                                                                                                                                          	ListMeta
                                                                                                                                                                                                          	Data []*ApplicationFee `json:"data"`
                                                                                                                                                                                                          }

                                                                                                                                                                                                            ApplicationFeeList is a list of application fees as retrieved from a list endpoint.

                                                                                                                                                                                                            type ApplicationFeeListParams

                                                                                                                                                                                                            type ApplicationFeeListParams struct {
                                                                                                                                                                                                            	ListParams   `form:"*"`
                                                                                                                                                                                                            	Charge       *string           `form:"charge"`
                                                                                                                                                                                                            	Created      *int64            `form:"created"`
                                                                                                                                                                                                            	CreatedRange *RangeQueryParams `form:"created"`
                                                                                                                                                                                                            }

                                                                                                                                                                                                              ApplicationFeeListParams is the set of parameters that can be used when listing application fees. For more details see https://stripe.com/docs/api#list_application_fees.

                                                                                                                                                                                                              type ApplicationFeeParams

                                                                                                                                                                                                              type ApplicationFeeParams struct {
                                                                                                                                                                                                              	Params `form:"*"`
                                                                                                                                                                                                              }

                                                                                                                                                                                                                ApplicationFeeParams is the set of parameters that can be used when refunding an application fee. For more details see https://stripe.com/docs/api#refund_application_fee.

                                                                                                                                                                                                                type AuthenticationError

                                                                                                                                                                                                                type AuthenticationError struct {
                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  AuthenticationError is a failure to properly authenticate during a request.

                                                                                                                                                                                                                  func (*AuthenticationError) Error

                                                                                                                                                                                                                  func (e *AuthenticationError) Error() string

                                                                                                                                                                                                                    Error serializes the error object to JSON and returns it as a string.

                                                                                                                                                                                                                    type AuthorizationControlsParams

                                                                                                                                                                                                                    type AuthorizationControlsParams struct {
                                                                                                                                                                                                                    	AllowedCategories []*string                                           `form:"allowed_categories"`
                                                                                                                                                                                                                    	BlockedCategories []*string                                           `form:"blocked_categories"`
                                                                                                                                                                                                                    	MaxApprovals      *int64                                              `form:"max_approvals"`
                                                                                                                                                                                                                    	SpendingLimits    []*IssuingAuthorizationControlsSpendingLimitsParams `form:"spending_limits"`
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// The following parameter only applies to Cardholder
                                                                                                                                                                                                                    	SpendingLimitsCurrency *string `form:"spending_limits_currency"`
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// The following parameter is deprecated
                                                                                                                                                                                                                    	MaxAmount *int64 `form:"max_amount"`
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      AuthorizationControlsParams is the set of parameters that can be used for the shipping parameter. This is deprecated and will be removed in the next major version.

                                                                                                                                                                                                                      type AuthorizeURLParams

                                                                                                                                                                                                                      type AuthorizeURLParams struct {
                                                                                                                                                                                                                      	Params                `form:"*"`
                                                                                                                                                                                                                      	AlwaysPrompt          *bool                  `form:"always_prompt"`
                                                                                                                                                                                                                      	ClientID              *string                `form:"client_id"`
                                                                                                                                                                                                                      	RedirectURI           *string                `form:"redirect_uri"`
                                                                                                                                                                                                                      	ResponseType          *string                `form:"response_type"`
                                                                                                                                                                                                                      	Scope                 *string                `form:"scope"`
                                                                                                                                                                                                                      	State                 *string                `form:"state"`
                                                                                                                                                                                                                      	StripeLanding         *string                `form:"stripe_landing"`
                                                                                                                                                                                                                      	StripeUser            *OAuthStripeUserParams `form:"stripe_user"`
                                                                                                                                                                                                                      	SuggestedCapabilities []*string              `form:"suggested_capabilities"`
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Express is not sent as a parameter, but is used to modify the authorize URL
                                                                                                                                                                                                                      	// path to use the express OAuth path.
                                                                                                                                                                                                                      	Express *bool `form:"-"`
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        AuthorizeURLParams for creating OAuth AuthorizeURLs.

                                                                                                                                                                                                                        type Backend

                                                                                                                                                                                                                        type Backend interface {
                                                                                                                                                                                                                        	Call(method, path, key string, params ParamsContainer, v interface{}) error
                                                                                                                                                                                                                        	CallRaw(method, path, key string, body *form.Values, params *Params, v interface{}) error
                                                                                                                                                                                                                        	CallMultipart(method, path, key, boundary string, body *bytes.Buffer, params *Params, v interface{}) error
                                                                                                                                                                                                                        	SetMaxNetworkRetries(maxNetworkRetries int)
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          Backend is an interface for making calls against a Stripe service. This interface exists to enable mocking for during testing if needed.

                                                                                                                                                                                                                          func GetBackend

                                                                                                                                                                                                                          func GetBackend(backendType SupportedBackend) Backend

                                                                                                                                                                                                                            GetBackend returns one of the library's supported backends based off of the given argument.

                                                                                                                                                                                                                            It returns an existing default backend if one's already been created.

                                                                                                                                                                                                                            func GetBackendWithConfig

                                                                                                                                                                                                                            func GetBackendWithConfig(backendType SupportedBackend, config *BackendConfig) Backend

                                                                                                                                                                                                                              GetBackendWithConfig is the same as GetBackend except that it can be given a configuration struct that will configure certain aspects of the backend that's return.

                                                                                                                                                                                                                              type BackendConfig

                                                                                                                                                                                                                              type BackendConfig struct {
                                                                                                                                                                                                                              	// EnableTelemetry allows request metrics (request id and duration) to be sent
                                                                                                                                                                                                                              	// to Stripe in subsequent requests via the `X-Stripe-Client-Telemetry` header.
                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                              	// Defaults to false.
                                                                                                                                                                                                                              	EnableTelemetry bool
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// HTTPClient is an HTTP client instance to use when making API requests.
                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                              	// If left unset, it'll be set to a default HTTP client for the package.
                                                                                                                                                                                                                              	HTTPClient *http.Client
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// LeveledLogger is the logger that the backend will use to log errors,
                                                                                                                                                                                                                              	// warnings, and informational messages.
                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                              	// LeveledLoggerInterface is implemented by LeveledLogger, and one can be
                                                                                                                                                                                                                              	// initialized at the desired level of logging.  LeveledLoggerInterface
                                                                                                                                                                                                                              	// also provides out-of-the-box compatibility with a Logrus Logger, but may
                                                                                                                                                                                                                              	// require a thin shim for use with other logging libraries that use less
                                                                                                                                                                                                                              	// standard conventions like Zap.
                                                                                                                                                                                                                              	LeveledLogger LeveledLoggerInterface
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// LogLevel is the logging level of the library and defined by:
                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                              	// 0: no logging
                                                                                                                                                                                                                              	// 1: errors only
                                                                                                                                                                                                                              	// 2: errors + informational (default)
                                                                                                                                                                                                                              	// 3: errors + informational + debug
                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                              	// Defaults to 0 (no logging), so please make sure to set this if you want
                                                                                                                                                                                                                              	// to see logging output in your custom configuration.
                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                              	// Deprecated: Logging should be configured with LeveledLogger instead.
                                                                                                                                                                                                                              	LogLevel int
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// Logger is where this backend will write its logs.
                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                              	// If left unset, it'll be set to Logger.
                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                              	// Deprecated: Logging should be configured with LeveledLogger instead.
                                                                                                                                                                                                                              	Logger Printfer
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// MaxNetworkRetries sets maximum number of times that the library will
                                                                                                                                                                                                                              	// retry requests that appear to have failed due to an intermittent
                                                                                                                                                                                                                              	// problem.
                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                              	// Defaults to 0.
                                                                                                                                                                                                                              	MaxNetworkRetries int
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// URL is the base URL to use for API paths.
                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                              	// If left empty, it'll be set to the default for the SupportedBackend.
                                                                                                                                                                                                                              	URL string
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                BackendConfig is used to configure a new Stripe backend.

                                                                                                                                                                                                                                type BackendImplementation

                                                                                                                                                                                                                                type BackendImplementation struct {
                                                                                                                                                                                                                                	Type              SupportedBackend
                                                                                                                                                                                                                                	URL               string
                                                                                                                                                                                                                                	HTTPClient        *http.Client
                                                                                                                                                                                                                                	LeveledLogger     LeveledLoggerInterface
                                                                                                                                                                                                                                	MaxNetworkRetries int
                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  BackendImplementation is the internal implementation for making HTTP calls to Stripe.

                                                                                                                                                                                                                                  The public use of this struct is deprecated. It will be unexported in a future version.

                                                                                                                                                                                                                                  func (*BackendImplementation) Call

                                                                                                                                                                                                                                  func (s *BackendImplementation) Call(method, path, key string, params ParamsContainer, v interface{}) error

                                                                                                                                                                                                                                    Call is the Backend.Call implementation for invoking Stripe APIs.

                                                                                                                                                                                                                                    func (*BackendImplementation) CallMultipart

                                                                                                                                                                                                                                    func (s *BackendImplementation) CallMultipart(method, path, key, boundary string, body *bytes.Buffer, params *Params, v interface{}) error

                                                                                                                                                                                                                                      CallMultipart is the Backend.CallMultipart implementation for invoking Stripe APIs.

                                                                                                                                                                                                                                      func (*BackendImplementation) CallRaw

                                                                                                                                                                                                                                      func (s *BackendImplementation) CallRaw(method, path, key string, form *form.Values, params *Params, v interface{}) error

                                                                                                                                                                                                                                        CallRaw is the implementation for invoking Stripe APIs internally without a backend.

                                                                                                                                                                                                                                        func (*BackendImplementation) Do

                                                                                                                                                                                                                                        func (s *BackendImplementation) Do(req *http.Request, body *bytes.Buffer, v interface{}) error

                                                                                                                                                                                                                                          Do is used by Call to execute an API request and parse the response. It uses the backend's HTTP client to execute the request and unmarshals the response into v. It also handles unmarshaling errors returned by the API.

                                                                                                                                                                                                                                          func (*BackendImplementation) NewRequest

                                                                                                                                                                                                                                          func (s *BackendImplementation) NewRequest(method, path, key, contentType string, params *Params) (*http.Request, error)

                                                                                                                                                                                                                                            NewRequest is used by Call to generate an http.Request. It handles encoding parameters and attaching the appropriate headers.

                                                                                                                                                                                                                                            func (*BackendImplementation) ResponseToError

                                                                                                                                                                                                                                            func (s *BackendImplementation) ResponseToError(res *http.Response, resBody []byte) error

                                                                                                                                                                                                                                              ResponseToError converts a stripe response to an Error.

                                                                                                                                                                                                                                              func (*BackendImplementation) SetMaxNetworkRetries

                                                                                                                                                                                                                                              func (s *BackendImplementation) SetMaxNetworkRetries(maxNetworkRetries int)

                                                                                                                                                                                                                                                SetMaxNetworkRetries sets max number of retries on failed requests

                                                                                                                                                                                                                                                This function is deprecated. Please use GetBackendWithConfig instead.

                                                                                                                                                                                                                                                func (*BackendImplementation) SetNetworkRetriesSleep

                                                                                                                                                                                                                                                func (s *BackendImplementation) SetNetworkRetriesSleep(sleep bool)

                                                                                                                                                                                                                                                  SetNetworkRetriesSleep allows the normal sleep between network retries to be enabled or disabled.

                                                                                                                                                                                                                                                  This function is available for internal testing only and should never be used in production.

                                                                                                                                                                                                                                                  func (*BackendImplementation) UnmarshalJSONVerbose

                                                                                                                                                                                                                                                  func (s *BackendImplementation) UnmarshalJSONVerbose(statusCode int, body []byte, v interface{}) error

                                                                                                                                                                                                                                                    UnmarshalJSONVerbose unmarshals JSON, but in case of a failure logs and produces a more descriptive error.

                                                                                                                                                                                                                                                    type Backends

                                                                                                                                                                                                                                                    type Backends struct {
                                                                                                                                                                                                                                                    	API, Connect, Uploads Backend
                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                      Backends are the currently supported endpoints.

                                                                                                                                                                                                                                                      func NewBackends

                                                                                                                                                                                                                                                      func NewBackends(httpClient *http.Client) *Backends

                                                                                                                                                                                                                                                        NewBackends creates a new set of backends with the given HTTP client. You should only need to use this for testing purposes or on App Engine.

                                                                                                                                                                                                                                                        type Balance

                                                                                                                                                                                                                                                        type Balance struct {
                                                                                                                                                                                                                                                        	Available       []*Amount `json:"available"`
                                                                                                                                                                                                                                                        	ConnectReserved []*Amount `json:"connect_reserved"`
                                                                                                                                                                                                                                                        	Livemode        bool      `json:"livemode"`
                                                                                                                                                                                                                                                        	Pending         []*Amount `json:"pending"`
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          Balance is the resource representing your Stripe balance. For more details see https://stripe.com/docs/api/#balance.

                                                                                                                                                                                                                                                          type BalanceParams

                                                                                                                                                                                                                                                          type BalanceParams struct {
                                                                                                                                                                                                                                                          	Params `form:"*"`
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            BalanceParams is the set of parameters that can be used when retrieving a balance. For more details see https://stripe.com/docs/api#balance.

                                                                                                                                                                                                                                                            type BalanceSourceType

                                                                                                                                                                                                                                                            type BalanceSourceType string

                                                                                                                                                                                                                                                              BalanceSourceType is the list of allowed values for the balance amount's source_type field keys.

                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                              	BalanceSourceTypeAlipayAccount   BalanceSourceType = "alipay_account"
                                                                                                                                                                                                                                                              	BalanceSourceTypeBankAccount     BalanceSourceType = "bank_account"
                                                                                                                                                                                                                                                              	BalanceSourceTypeBitcoinReceiver BalanceSourceType = "bitcoin_receiver"
                                                                                                                                                                                                                                                              	BalanceSourceTypeCard            BalanceSourceType = "card"
                                                                                                                                                                                                                                                              	BalanceSourceTypeFPX             BalanceSourceType = "fpx"
                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                List of values that BalanceSourceType can take.

                                                                                                                                                                                                                                                                type BalanceTransaction

                                                                                                                                                                                                                                                                type BalanceTransaction struct {
                                                                                                                                                                                                                                                                	Amount            int64                               `json:"amount"`
                                                                                                                                                                                                                                                                	AvailableOn       int64                               `json:"available_on"`
                                                                                                                                                                                                                                                                	Created           int64                               `json:"created"`
                                                                                                                                                                                                                                                                	Currency          Currency                            `json:"currency"`
                                                                                                                                                                                                                                                                	Description       string                              `json:"description"`
                                                                                                                                                                                                                                                                	ExchangeRate      float64                             `json:"exchange_rate"`
                                                                                                                                                                                                                                                                	ID                string                              `json:"id"`
                                                                                                                                                                                                                                                                	Fee               int64                               `json:"fee"`
                                                                                                                                                                                                                                                                	FeeDetails        []*BalanceTransactionFee            `json:"fee_details"`
                                                                                                                                                                                                                                                                	Net               int64                               `json:"net"`
                                                                                                                                                                                                                                                                	Recipient         string                              `json:"recipient"`
                                                                                                                                                                                                                                                                	ReportingCategory BalanceTransactionReportingCategory `json:"reporting_category"`
                                                                                                                                                                                                                                                                	Source            *BalanceTransactionSource           `json:"source"`
                                                                                                                                                                                                                                                                	Status            BalanceTransactionStatus            `json:"status"`
                                                                                                                                                                                                                                                                	Type              BalanceTransactionType              `json:"type"`
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                  BalanceTransaction is the resource representing the balance transaction. For more details see https://stripe.com/docs/api/#balance.

                                                                                                                                                                                                                                                                  func (*BalanceTransaction) UnmarshalJSON

                                                                                                                                                                                                                                                                  func (t *BalanceTransaction) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                                                                                    UnmarshalJSON handles deserialization of a Transaction. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

                                                                                                                                                                                                                                                                    type BalanceTransactionFee

                                                                                                                                                                                                                                                                    type BalanceTransactionFee struct {
                                                                                                                                                                                                                                                                    	Amount      int64    `json:"amount"`
                                                                                                                                                                                                                                                                    	Application string   `json:"application"`
                                                                                                                                                                                                                                                                    	Currency    Currency `json:"currency"`
                                                                                                                                                                                                                                                                    	Description string   `json:"description"`
                                                                                                                                                                                                                                                                    	Type        string   `json:"type"`
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      BalanceTransactionFee is a structure that breaks down the fees in a transaction.

                                                                                                                                                                                                                                                                      type BalanceTransactionList

                                                                                                                                                                                                                                                                      type BalanceTransactionList struct {
                                                                                                                                                                                                                                                                      	ListMeta
                                                                                                                                                                                                                                                                      	Data []*BalanceTransaction `json:"data"`
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                        BalanceTransactionList is a list of transactions as returned from a list endpoint.

                                                                                                                                                                                                                                                                        type BalanceTransactionListParams

                                                                                                                                                                                                                                                                        type BalanceTransactionListParams struct {
                                                                                                                                                                                                                                                                        	ListParams       `form:"*"`
                                                                                                                                                                                                                                                                        	AvailableOn      *int64            `form:"available_on"`
                                                                                                                                                                                                                                                                        	AvailableOnRange *RangeQueryParams `form:"available_on"`
                                                                                                                                                                                                                                                                        	Created          *int64            `form:"created"`
                                                                                                                                                                                                                                                                        	CreatedRange     *RangeQueryParams `form:"created"`
                                                                                                                                                                                                                                                                        	Currency         *string           `form:"currency"`
                                                                                                                                                                                                                                                                        	Payout           *string           `form:"payout"`
                                                                                                                                                                                                                                                                        	Source           *string           `form:"source"`
                                                                                                                                                                                                                                                                        	Type             *string           `form:"type"`
                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                          BalanceTransactionListParams is the set of parameters that can be used when listing balance transactions. For more details see https://stripe.com/docs/api/#balance_history.

                                                                                                                                                                                                                                                                          type BalanceTransactionParams

                                                                                                                                                                                                                                                                          type BalanceTransactionParams struct {
                                                                                                                                                                                                                                                                          	Params `form:"*"`
                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                            BalanceTransactionParams is the set of parameters that can be used when retrieving a transaction. For more details see https://stripe.com/docs/api#retrieve_balance_transaction.

                                                                                                                                                                                                                                                                            type BalanceTransactionReportingCategory

                                                                                                                                                                                                                                                                            type BalanceTransactionReportingCategory string

                                                                                                                                                                                                                                                                              BalanceTransactionReportingCategory represents reporting categories for balance transactions.

                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryAdvance                     BalanceTransactionReportingCategory = "advance"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryAdvanceFunding              BalanceTransactionReportingCategory = "advance_funding"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryCharge                      BalanceTransactionReportingCategory = "charge"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryChargeFailure               BalanceTransactionReportingCategory = "charge_failure"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryConnectCollectionTransfer   BalanceTransactionReportingCategory = "connect_collection_transfer"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryConnectReservedFunds        BalanceTransactionReportingCategory = "connect_reserved_funds"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryDispute                     BalanceTransactionReportingCategory = "dispute"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryDisputeReversal             BalanceTransactionReportingCategory = "dispute_reversal"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryFee                         BalanceTransactionReportingCategory = "fee"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryIssuingAuthorizationHold    BalanceTransactionReportingCategory = "issuing_authorization_hold"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryIssuingAuthorizationRelease BalanceTransactionReportingCategory = "issuing_authorization_release"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryIssuingTransaction          BalanceTransactionReportingCategory = "issuing_transaction"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryOtherAdjustment             BalanceTransactionReportingCategory = "other_adjustment"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryPartialCaptureReversal      BalanceTransactionReportingCategory = "partial_capture_reversal"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryPayout                      BalanceTransactionReportingCategory = "payout"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryPayoutReversal              BalanceTransactionReportingCategory = "payout_reversal"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryPlatformEarning             BalanceTransactionReportingCategory = "platform_earning"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryPlatformEarningRefund       BalanceTransactionReportingCategory = "platform_earning_refund"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryRefund                      BalanceTransactionReportingCategory = "refund"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryRefundFailure               BalanceTransactionReportingCategory = "refund_failure"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryRiskReservedFunds           BalanceTransactionReportingCategory = "risk_reserved_funds"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryTax                         BalanceTransactionReportingCategory = "tax"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryTopup                       BalanceTransactionReportingCategory = "topup"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryTopupReversal               BalanceTransactionReportingCategory = "topup_reversal"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryTransfer                    BalanceTransactionReportingCategory = "transfer"
                                                                                                                                                                                                                                                                              	BalanceTransactionReportingCategoryTransferReversal            BalanceTransactionReportingCategory = "transfer_reversal"
                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                List of values that BalanceTransactionReportingCategory can take.

                                                                                                                                                                                                                                                                                type BalanceTransactionSource

                                                                                                                                                                                                                                                                                type BalanceTransactionSource struct {
                                                                                                                                                                                                                                                                                	ApplicationFee       *ApplicationFee              `json:"-"`
                                                                                                                                                                                                                                                                                	Charge               *Charge                      `json:"-"`
                                                                                                                                                                                                                                                                                	Dispute              *Dispute                     `json:"-"`
                                                                                                                                                                                                                                                                                	ID                   string                       `json:"id"`
                                                                                                                                                                                                                                                                                	IssuingAuthorization *IssuingAuthorization        `json:"-"`
                                                                                                                                                                                                                                                                                	IssuingTransaction   *IssuingAuthorization        `json:"-"`
                                                                                                                                                                                                                                                                                	Payout               *Payout                      `json:"-"`
                                                                                                                                                                                                                                                                                	RecipientTransfer    *RecipientTransfer           `json:"-"`
                                                                                                                                                                                                                                                                                	Refund               *Refund                      `json:"-"`
                                                                                                                                                                                                                                                                                	Reversal             *Reversal                    `json:"-"`
                                                                                                                                                                                                                                                                                	Transfer             *Transfer                    `json:"-"`
                                                                                                                                                                                                                                                                                	Type                 BalanceTransactionSourceType `json:"object"`
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                  BalanceTransactionSource describes the source of a balance Transaction. The Type should indicate which object is fleshed out. For more details see https://stripe.com/docs/api#retrieve_balance_transaction

                                                                                                                                                                                                                                                                                  func (*BalanceTransactionSource) UnmarshalJSON

                                                                                                                                                                                                                                                                                  func (s *BalanceTransactionSource) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                                                                                                    UnmarshalJSON handles deserialization of a BalanceTransactionSource. This custom unmarshaling is needed because the specific type of transaction source it refers to is specified in the JSON

                                                                                                                                                                                                                                                                                    type BalanceTransactionSourceType

                                                                                                                                                                                                                                                                                    type BalanceTransactionSourceType string

                                                                                                                                                                                                                                                                                      BalanceTransactionSourceType consts represent valid balance transaction sources.

                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                      	BalanceTransactionSourceTypeApplicationFee       BalanceTransactionSourceType = "application_fee"
                                                                                                                                                                                                                                                                                      	BalanceTransactionSourceTypeCharge               BalanceTransactionSourceType = "charge"
                                                                                                                                                                                                                                                                                      	BalanceTransactionSourceTypeDispute              BalanceTransactionSourceType = "dispute"
                                                                                                                                                                                                                                                                                      	BalanceTransactionSourceTypeIssuingAuthorization BalanceTransactionSourceType = "issuing.authorization"
                                                                                                                                                                                                                                                                                      	BalanceTransactionSourceTypeIssuingTransaction   BalanceTransactionSourceType = "issuing.transaction"
                                                                                                                                                                                                                                                                                      	BalanceTransactionSourceTypePayout               BalanceTransactionSourceType = "payout"
                                                                                                                                                                                                                                                                                      	BalanceTransactionSourceTypeRecipientTransfer    BalanceTransactionSourceType = "recipient_transfer"
                                                                                                                                                                                                                                                                                      	BalanceTransactionSourceTypeRefund               BalanceTransactionSourceType = "refund"
                                                                                                                                                                                                                                                                                      	BalanceTransactionSourceTypeReversal             BalanceTransactionSourceType = "reversal"
                                                                                                                                                                                                                                                                                      	BalanceTransactionSourceTypeTransfer             BalanceTransactionSourceType = "transfer"
                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                        List of values that BalanceTransactionSourceType can take.

                                                                                                                                                                                                                                                                                        type BalanceTransactionStatus

                                                                                                                                                                                                                                                                                        type BalanceTransactionStatus string

                                                                                                                                                                                                                                                                                          BalanceTransactionStatus is the list of allowed values for the balance transaction's status.

                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                          	BalanceTransactionStatusAvailable BalanceTransactionStatus = "available"
                                                                                                                                                                                                                                                                                          	BalanceTransactionStatusPending   BalanceTransactionStatus = "pending"
                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                            List of values that BalanceTransactionStatus can take.

                                                                                                                                                                                                                                                                                            type BalanceTransactionType

                                                                                                                                                                                                                                                                                            type BalanceTransactionType string

                                                                                                                                                                                                                                                                                              BalanceTransactionType is the list of allowed values for the balance transaction's type.

                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypeAdjustment                      BalanceTransactionType = "adjustment"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypeApplicationFee                  BalanceTransactionType = "application_fee"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypeApplicationFeeRefund            BalanceTransactionType = "application_fee_refund"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypeCharge                          BalanceTransactionType = "charge"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypeIssuingAuthorizationHold        BalanceTransactionType = "issuing_authorization_hold"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypeIssuingAuthorizationRelease     BalanceTransactionType = "issuing_authorization_release"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypeIssuingAuthorizationTransaction BalanceTransactionType = "issuing_transaction"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypePayment                         BalanceTransactionType = "payment"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypePaymentFailureRefund            BalanceTransactionType = "payment_failure_refund"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypePaymentRefund                   BalanceTransactionType = "payment_refund"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypePayout                          BalanceTransactionType = "payout"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypePayoutCancel                    BalanceTransactionType = "payout_cancel"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypePayoutFailure                   BalanceTransactionType = "payout_failure"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypeRecipientTransfer               BalanceTransactionType = "recipient_transfer"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypeRecipientTransferCancel         BalanceTransactionType = "recipient_transfer_cancel"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypeRecipientTransferFailure        BalanceTransactionType = "recipient_transfer_failure"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypeRefund                          BalanceTransactionType = "refund"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypeStripeFee                       BalanceTransactionType = "stripe_fee"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypeTransfer                        BalanceTransactionType = "transfer"
                                                                                                                                                                                                                                                                                              	BalanceTransactionTypeTransferRefund                  BalanceTransactionType = "transfer_refund"
                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                List of values that BalanceTransactionType can take.

                                                                                                                                                                                                                                                                                                type BankAccount

                                                                                                                                                                                                                                                                                                type BankAccount struct {
                                                                                                                                                                                                                                                                                                	Account            *Account                     `json:"account"`
                                                                                                                                                                                                                                                                                                	AccountHolderName  string                       `json:"account_holder_name"`
                                                                                                                                                                                                                                                                                                	AccountHolderType  BankAccountAccountHolderType `json:"account_holder_type"`
                                                                                                                                                                                                                                                                                                	BankName           string                       `json:"bank_name"`
                                                                                                                                                                                                                                                                                                	Country            string                       `json:"country"`
                                                                                                                                                                                                                                                                                                	Currency           Currency                     `json:"currency"`
                                                                                                                                                                                                                                                                                                	Customer           *Customer                    `json:"customer"`
                                                                                                                                                                                                                                                                                                	DefaultForCurrency bool                         `json:"default_for_currency"`
                                                                                                                                                                                                                                                                                                	Deleted            bool                         `json:"deleted"`
                                                                                                                                                                                                                                                                                                	Fingerprint        string                       `json:"fingerprint"`
                                                                                                                                                                                                                                                                                                	ID                 string                       `json:"id"`
                                                                                                                                                                                                                                                                                                	Last4              string                       `json:"last4"`
                                                                                                                                                                                                                                                                                                	Metadata           map[string]string            `json:"metadata"`
                                                                                                                                                                                                                                                                                                	RoutingNumber      string                       `json:"routing_number"`
                                                                                                                                                                                                                                                                                                	Status             BankAccountStatus            `json:"status"`
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                  BankAccount represents a Stripe bank account.

                                                                                                                                                                                                                                                                                                  func (*BankAccount) UnmarshalJSON

                                                                                                                                                                                                                                                                                                  func (b *BankAccount) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                                                                                                                    UnmarshalJSON handles deserialization of a BankAccount. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

                                                                                                                                                                                                                                                                                                    type BankAccountAccountHolderType

                                                                                                                                                                                                                                                                                                    type BankAccountAccountHolderType string

                                                                                                                                                                                                                                                                                                      BankAccountAccountHolderType is the list of allowed values for the bank account holder type.

                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                      	BankAccountAccountHolderTypeCompany    BankAccountAccountHolderType = "company"
                                                                                                                                                                                                                                                                                                      	BankAccountAccountHolderTypeIndividual BankAccountAccountHolderType = "individual"
                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                        List of values that BankAccountAccountHolderType can take.

                                                                                                                                                                                                                                                                                                        type BankAccountList

                                                                                                                                                                                                                                                                                                        type BankAccountList struct {
                                                                                                                                                                                                                                                                                                        	ListMeta
                                                                                                                                                                                                                                                                                                        	Data []*BankAccount `json:"data"`
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          BankAccountList is a list object for bank accounts.

                                                                                                                                                                                                                                                                                                          type BankAccountListParams

                                                                                                                                                                                                                                                                                                          type BankAccountListParams struct {
                                                                                                                                                                                                                                                                                                          	ListParams `form:"*"`
                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                          	// The identifier of the parent account under which the bank accounts are
                                                                                                                                                                                                                                                                                                          	// nested. Either Account or Customer should be populated.
                                                                                                                                                                                                                                                                                                          	Account *string `form:"-"`
                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                          	// The identifier of the parent customer under which the bank accounts are
                                                                                                                                                                                                                                                                                                          	// nested. Either Account or Customer should be populated.
                                                                                                                                                                                                                                                                                                          	Customer *string `form:"-"`
                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                            BankAccountListParams is the set of parameters that can be used when listing bank accounts.

                                                                                                                                                                                                                                                                                                            func (*BankAccountListParams) AppendTo

                                                                                                                                                                                                                                                                                                            func (p *BankAccountListParams) AppendTo(body *form.Values, keyParts []string)

                                                                                                                                                                                                                                                                                                              AppendTo implements custom encoding logic for BankAccountListParams so that we can send the special required `object` field up along with the other specified parameters.

                                                                                                                                                                                                                                                                                                              type BankAccountParams

                                                                                                                                                                                                                                                                                                              type BankAccountParams struct {
                                                                                                                                                                                                                                                                                                              	Params `form:"*"`
                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                              	// Account is the identifier of the parent account under which bank
                                                                                                                                                                                                                                                                                                              	// accounts are nested.
                                                                                                                                                                                                                                                                                                              	Account *string `form:"-"`
                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                              	AccountHolderName  *string `form:"account_holder_name"`
                                                                                                                                                                                                                                                                                                              	AccountHolderType  *string `form:"account_holder_type"`
                                                                                                                                                                                                                                                                                                              	AccountNumber      *string `form:"account_number"`
                                                                                                                                                                                                                                                                                                              	Country            *string `form:"country"`
                                                                                                                                                                                                                                                                                                              	Currency           *string `form:"currency"`
                                                                                                                                                                                                                                                                                                              	Customer           *string `form:"-"`
                                                                                                                                                                                                                                                                                                              	DefaultForCurrency *bool   `form:"default_for_currency"`
                                                                                                                                                                                                                                                                                                              	RoutingNumber      *string `form:"routing_number"`
                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                              	// Token is a token referencing an external account like one returned from
                                                                                                                                                                                                                                                                                                              	// Stripe.js.
                                                                                                                                                                                                                                                                                                              	Token *string `form:"-"`
                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                              	// ID is used when tokenizing a bank account for shared customers
                                                                                                                                                                                                                                                                                                              	ID *string `form:"*"`
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                BankAccountParams is the set of parameters that can be used when updating a bank account.

                                                                                                                                                                                                                                                                                                                Note that while form annotations are used for updates, bank accounts have some unusual logic on creates that necessitates manual handling of all parameters. See AppendToAsSourceOrExternalAccount.

                                                                                                                                                                                                                                                                                                                func (*BankAccountParams) AppendToAsSourceOrExternalAccount

                                                                                                                                                                                                                                                                                                                func (a *BankAccountParams) AppendToAsSourceOrExternalAccount(body *form.Values)

                                                                                                                                                                                                                                                                                                                  AppendToAsSourceOrExternalAccount appends the given BankAccountParams as either a source or external account.

                                                                                                                                                                                                                                                                                                                  It may look like an AppendTo from the form package, but it's not, and is only used in the special case where we use `bankaccount.New`. It's needed because we have some weird encoding logic here that can't be handled by the form package (and it's special enough that it wouldn't be desirable to have it do so).

                                                                                                                                                                                                                                                                                                                  This is not a pattern that we want to push forward, and this largely exists because the bank accounts endpoint is a little unusual. There is one other resource like it, which is cards.

                                                                                                                                                                                                                                                                                                                  type BankAccountStatus

                                                                                                                                                                                                                                                                                                                  type BankAccountStatus string

                                                                                                                                                                                                                                                                                                                    BankAccountStatus is the list of allowed values for the bank account's status.

                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                    	BankAccountStatusErrored            BankAccountStatus = "errored"
                                                                                                                                                                                                                                                                                                                    	BankAccountStatusNew                BankAccountStatus = "new"
                                                                                                                                                                                                                                                                                                                    	BankAccountStatusValidated          BankAccountStatus = "validated"
                                                                                                                                                                                                                                                                                                                    	BankAccountStatusVerificationFailed BankAccountStatus = "verification_failed"
                                                                                                                                                                                                                                                                                                                    	BankAccountStatusVerified           BankAccountStatus = "verified"
                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                      List of values that BankAccountStatus can take.

                                                                                                                                                                                                                                                                                                                      type BillingDetails

                                                                                                                                                                                                                                                                                                                      type BillingDetails struct {
                                                                                                                                                                                                                                                                                                                      	Address *Address `json:"address"`
                                                                                                                                                                                                                                                                                                                      	Email   string   `json:"email"`
                                                                                                                                                                                                                                                                                                                      	Name    string   `json:"name"`
                                                                                                                                                                                                                                                                                                                      	Phone   string   `json:"phone"`
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                        BillingDetails represents the billing details associated with a PaymentMethod.

                                                                                                                                                                                                                                                                                                                        type BillingDetailsParams

                                                                                                                                                                                                                                                                                                                        type BillingDetailsParams struct {
                                                                                                                                                                                                                                                                                                                        	Address *AddressParams `form:"address"`
                                                                                                                                                                                                                                                                                                                        	Email   *string        `form:"email"`
                                                                                                                                                                                                                                                                                                                        	Name    *string        `form:"name"`
                                                                                                                                                                                                                                                                                                                        	Phone   *string        `form:"phone"`
                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                          BillingDetailsParams is the set of parameters that can be used as billing details when creating or updating a PaymentMethod

                                                                                                                                                                                                                                                                                                                          type BitcoinReceiver

                                                                                                                                                                                                                                                                                                                          type BitcoinReceiver struct {
                                                                                                                                                                                                                                                                                                                          	Active                bool                    `json:"active"`
                                                                                                                                                                                                                                                                                                                          	Amount                int64                   `json:"amount"`
                                                                                                                                                                                                                                                                                                                          	AmountReceived        int64                   `json:"amount_received"`
                                                                                                                                                                                                                                                                                                                          	BitcoinAmount         int64                   `json:"bitcoin_amount"`
                                                                                                                                                                                                                                                                                                                          	BitcoinAmountReceived int64                   `json:"bitcoin_amount_received"`
                                                                                                                                                                                                                                                                                                                          	BitcoinURI            string                  `json:"bitcoin_uri"`
                                                                                                                                                                                                                                                                                                                          	Created               int64                   `json:"created"`
                                                                                                                                                                                                                                                                                                                          	Currency              Currency                `json:"currency"`
                                                                                                                                                                                                                                                                                                                          	Customer              string                  `json:"customer"`
                                                                                                                                                                                                                                                                                                                          	Description           string                  `json:"description"`
                                                                                                                                                                                                                                                                                                                          	Email                 string                  `json:"email"`
                                                                                                                                                                                                                                                                                                                          	Filled                bool                    `json:"filled"`
                                                                                                                                                                                                                                                                                                                          	ID                    string                  `json:"id"`
                                                                                                                                                                                                                                                                                                                          	InboundAddress        string                  `json:"inbound_address"`
                                                                                                                                                                                                                                                                                                                          	Metadata              map[string]string       `json:"metadata"`
                                                                                                                                                                                                                                                                                                                          	Payment               string                  `json:"payment"`
                                                                                                                                                                                                                                                                                                                          	RefundAddress         string                  `json:"refund_address"`
                                                                                                                                                                                                                                                                                                                          	RejectTransactions    bool                    `json:"reject_transactions"`
                                                                                                                                                                                                                                                                                                                          	Transactions          *BitcoinTransactionList `json:"transactions"`
                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                            BitcoinReceiver is the resource representing a Stripe bitcoin receiver. For more details see https://stripe.com/docs/api/#bitcoin_receivers

                                                                                                                                                                                                                                                                                                                            func (*BitcoinReceiver) UnmarshalJSON

                                                                                                                                                                                                                                                                                                                            func (r *BitcoinReceiver) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                                                                                                                                              UnmarshalJSON handles deserialization of a BitcoinReceiver. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

                                                                                                                                                                                                                                                                                                                              type BitcoinReceiverList

                                                                                                                                                                                                                                                                                                                              type BitcoinReceiverList struct {
                                                                                                                                                                                                                                                                                                                              	ListMeta
                                                                                                                                                                                                                                                                                                                              	Data []*BitcoinReceiver `json:"data"`
                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                BitcoinReceiverList is a list of bitcoin receivers as retrieved from a list endpoint.

                                                                                                                                                                                                                                                                                                                                type BitcoinReceiverListParams

                                                                                                                                                                                                                                                                                                                                type BitcoinReceiverListParams struct {
                                                                                                                                                                                                                                                                                                                                	ListParams      `form:"*"`
                                                                                                                                                                                                                                                                                                                                	Active          *bool `form:"active"`
                                                                                                                                                                                                                                                                                                                                	Filled          *bool `form:"filled"`
                                                                                                                                                                                                                                                                                                                                	UncapturedFunds *bool `form:"uncaptured_funds"`
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                  BitcoinReceiverListParams is the set of parameters that can be used when listing BitcoinReceivers. For more details see https://stripe.com/docs/api/#list_bitcoin_receivers.

                                                                                                                                                                                                                                                                                                                                  type BitcoinTransaction

                                                                                                                                                                                                                                                                                                                                  type BitcoinTransaction struct {
                                                                                                                                                                                                                                                                                                                                  	Amount        int64    `json:"amount"`
                                                                                                                                                                                                                                                                                                                                  	BitcoinAmount int64    `json:"bitcoin_amount"`
                                                                                                                                                                                                                                                                                                                                  	Created       int64    `json:"created"`
                                                                                                                                                                                                                                                                                                                                  	Currency      Currency `json:"currency"`
                                                                                                                                                                                                                                                                                                                                  	Customer      string   `json:"customer"`
                                                                                                                                                                                                                                                                                                                                  	ID            string   `json:"id"`
                                                                                                                                                                                                                                                                                                                                  	Receiver      string   `json:"receiver"`
                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                    BitcoinTransaction is the resource representing a Stripe bitcoin transaction. For more details see https://stripe.com/docs/api/#bitcoin_receivers

                                                                                                                                                                                                                                                                                                                                    func (*BitcoinTransaction) UnmarshalJSON

                                                                                                                                                                                                                                                                                                                                    func (bt *BitcoinTransaction) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                                                                                                                                                      UnmarshalJSON handles deserialization of a BitcoinTransaction. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

                                                                                                                                                                                                                                                                                                                                      type BitcoinTransactionList

                                                                                                                                                                                                                                                                                                                                      type BitcoinTransactionList struct {
                                                                                                                                                                                                                                                                                                                                      	ListMeta
                                                                                                                                                                                                                                                                                                                                      	Data []*BitcoinTransaction `json:"data"`
                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                        BitcoinTransactionList is a list object for BitcoinTransactions. It is a child object of BitcoinReceivers For more details see https://stripe.com/docs/api/#retrieve_bitcoin_receiver

                                                                                                                                                                                                                                                                                                                                        type BitcoinTransactionListParams

                                                                                                                                                                                                                                                                                                                                        type BitcoinTransactionListParams struct {
                                                                                                                                                                                                                                                                                                                                        	ListParams `form:"*"`
                                                                                                                                                                                                                                                                                                                                        	Customer   *string `form:"customer"`
                                                                                                                                                                                                                                                                                                                                        	Receiver   *string `form:"-"` // Sent in with the URL
                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                          BitcoinTransactionListParams is the set of parameters that can be used when listing BitcoinTransactions.

                                                                                                                                                                                                                                                                                                                                          type Capability

                                                                                                                                                                                                                                                                                                                                          type Capability struct {
                                                                                                                                                                                                                                                                                                                                          	Account      *Account                `json:"account"`
                                                                                                                                                                                                                                                                                                                                          	ID           string                  `json:"id"`
                                                                                                                                                                                                                                                                                                                                          	Object       string                  `json:"object"`
                                                                                                                                                                                                                                                                                                                                          	Requested    bool                    `json:"requested"`
                                                                                                                                                                                                                                                                                                                                          	RequestedAt  int64                   `json:"requested_at"`
                                                                                                                                                                                                                                                                                                                                          	Requirements *CapabilityRequirements `json:"requirements"`
                                                                                                                                                                                                                                                                                                                                          	Status       CapabilityStatus        `json:"status"`
                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                            Capability is the resource representing a Stripe capability. For more details see https://stripe.com/docs/api/capabilities

                                                                                                                                                                                                                                                                                                                                            func (*Capability) UnmarshalJSON

                                                                                                                                                                                                                                                                                                                                            func (c *Capability) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                                                                                                                                                              UnmarshalJSON handles deserialization of a Capability. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

                                                                                                                                                                                                                                                                                                                                              type CapabilityDisabledReason

                                                                                                                                                                                                                                                                                                                                              type CapabilityDisabledReason string

                                                                                                                                                                                                                                                                                                                                                CapabilityDisabledReason describes why a capability is disabled.

                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                	CapabilityDisabledReasonPendingOnboarding        CapabilityDisabledReason = "pending.onboarding"
                                                                                                                                                                                                                                                                                                                                                	CapabilityDisabledReasonPendingReview            CapabilityDisabledReason = "pending.review"
                                                                                                                                                                                                                                                                                                                                                	CapabilityDisabledReasonRejectedFraud            CapabilityDisabledReason = "rejected_fraud"
                                                                                                                                                                                                                                                                                                                                                	CapabilityDisabledReasonRejectedListed           CapabilityDisabledReason = "rejected.listed"
                                                                                                                                                                                                                                                                                                                                                	CapabilityDisabledReasonRejectedOther            CapabilityDisabledReason = "rejected.other"
                                                                                                                                                                                                                                                                                                                                                	CapabilityDisabledReasonRequirementsFieldsNeeded CapabilityDisabledReason = "requirement.fields_needed"
                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                  List of values that CapabilityDisabledReason can take.

                                                                                                                                                                                                                                                                                                                                                  type CapabilityList

                                                                                                                                                                                                                                                                                                                                                  type CapabilityList struct {
                                                                                                                                                                                                                                                                                                                                                  	ListMeta
                                                                                                                                                                                                                                                                                                                                                  	Data []*Capability `json:"data"`
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                    CapabilityList is a list of capabilities as retrieved from a list endpoint.

                                                                                                                                                                                                                                                                                                                                                    type CapabilityListParams

                                                                                                                                                                                                                                                                                                                                                    type CapabilityListParams struct {
                                                                                                                                                                                                                                                                                                                                                    	ListParams `form:"*"`
                                                                                                                                                                                                                                                                                                                                                    	Account    *string `form:"-"` // Included in URL
                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                      CapabilityListParams is the set of parameters that can be used when listing capabilities. For more detail see https://stripe.com/docs/api/capabilities/list

                                                                                                                                                                                                                                                                                                                                                      type CapabilityParams

                                                                                                                                                                                                                                                                                                                                                      type CapabilityParams struct {
                                                                                                                                                                                                                                                                                                                                                      	Params    `form:"*"`
                                                                                                                                                                                                                                                                                                                                                      	Account   *string `form:"-"` // Included in URL
                                                                                                                                                                                                                                                                                                                                                      	Requested *bool   `form:"requested"`
                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                        CapabilityParams is the set of parameters that can be used when updating a capability. For more details see https://stripe.com/docs/api/capabilities/update

                                                                                                                                                                                                                                                                                                                                                        type CapabilityRequirements

                                                                                                                                                                                                                                                                                                                                                        type CapabilityRequirements struct {
                                                                                                                                                                                                                                                                                                                                                        	CurrentDeadline     int64                       `json:"current_deadline"`
                                                                                                                                                                                                                                                                                                                                                        	CurrentlyDue        []string                    `json:"currently_due"`
                                                                                                                                                                                                                                                                                                                                                        	DisabledReason      CapabilityDisabledReason    `json:"disabled_reason"`
                                                                                                                                                                                                                                                                                                                                                        	Errors              []*AccountRequirementsError `json:"errors"`
                                                                                                                                                                                                                                                                                                                                                        	EventuallyDue       []string                    `json:"eventually_due"`
                                                                                                                                                                                                                                                                                                                                                        	PastDue             []string                    `json:"past_due"`
                                                                                                                                                                                                                                                                                                                                                        	PendingVerification []string                    `json:"pending_verification"`
                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                          CapabilityRequirements represents information that needs to be collected for a capability.

                                                                                                                                                                                                                                                                                                                                                          type CapabilityStatus

                                                                                                                                                                                                                                                                                                                                                          type CapabilityStatus string

                                                                                                                                                                                                                                                                                                                                                            CapabilityStatus describes the different statuses for a capability's status.

                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                            	CapabilityStatusActive      CapabilityStatus = "active"
                                                                                                                                                                                                                                                                                                                                                            	CapabilityStatusInactive    CapabilityStatus = "inactive"
                                                                                                                                                                                                                                                                                                                                                            	CapabilityStatusPending     CapabilityStatus = "pending"
                                                                                                                                                                                                                                                                                                                                                            	CapabilityStatusUnrequested CapabilityStatus = "unrequested"
                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                              List of values that CapabilityStatus can take.

                                                                                                                                                                                                                                                                                                                                                              type CaptureParams

                                                                                                                                                                                                                                                                                                                                                              type CaptureParams struct {
                                                                                                                                                                                                                                                                                                                                                              	Params                    `form:"*"`
                                                                                                                                                                                                                                                                                                                                                              	Amount                    *int64                    `form:"amount"`
                                                                                                                                                                                                                                                                                                                                                              	ApplicationFeeAmount      *int64                    `form:"application_fee_amount"`
                                                                                                                                                                                                                                                                                                                                                              	ExchangeRate              *float64                  `form:"exchange_rate"`
                                                                                                                                                                                                                                                                                                                                                              	ReceiptEmail              *string                   `form:"receipt_email"`
                                                                                                                                                                                                                                                                                                                                                              	StatementDescriptor       *string                   `form:"statement_descriptor"`
                                                                                                                                                                                                                                                                                                                                                              	StatementDescriptorSuffix *string                   `form:"statement_descriptor_suffix"`
                                                                                                                                                                                                                                                                                                                                                              	TransferGroup             *string                   `form:"transfer_group"`
                                                                                                                                                                                                                                                                                                                                                              	TransferData              *ChargeTransferDataParams `form:"transfer_data"`
                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                CaptureParams is the set of parameters that can be used when capturing a charge.

                                                                                                                                                                                                                                                                                                                                                                type Card

                                                                                                                                                                                                                                                                                                                                                                type Card struct {
                                                                                                                                                                                                                                                                                                                                                                	AddressCity            string                      `json:"address_city"`
                                                                                                                                                                                                                                                                                                                                                                	AddressCountry         string                      `json:"address_country"`
                                                                                                                                                                                                                                                                                                                                                                	AddressLine1           string                      `json:"address_line1"`
                                                                                                                                                                                                                                                                                                                                                                	AddressLine1Check      CardVerification            `json:"address_line1_check"`
                                                                                                                                                                                                                                                                                                                                                                	AddressLine2           string                      `json:"address_line2"`
                                                                                                                                                                                                                                                                                                                                                                	AddressState           string                      `json:"address_state"`
                                                                                                                                                                                                                                                                                                                                                                	AddressZip             string                      `json:"address_zip"`
                                                                                                                                                                                                                                                                                                                                                                	AddressZipCheck        CardVerification            `json:"address_zip_check"`
                                                                                                                                                                                                                                                                                                                                                                	AvailablePayoutMethods []CardAvailablePayoutMethod `json:"available_payout_methods"`
                                                                                                                                                                                                                                                                                                                                                                	Brand                  CardBrand                   `json:"brand"`
                                                                                                                                                                                                                                                                                                                                                                	CVCCheck               CardVerification            `json:"cvc_check"`
                                                                                                                                                                                                                                                                                                                                                                	Country                string                      `json:"country"`
                                                                                                                                                                                                                                                                                                                                                                	Currency               Currency                    `json:"currency"`
                                                                                                                                                                                                                                                                                                                                                                	Customer               *Customer                   `json:"customer"`
                                                                                                                                                                                                                                                                                                                                                                	DefaultForCurrency     bool                        `json:"default_for_currency"`
                                                                                                                                                                                                                                                                                                                                                                	Deleted                bool                        `json:"deleted"`
                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                	// Description is a succinct summary of the card's information.
                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                	// Please note that this field is for internal use only and is not returned
                                                                                                                                                                                                                                                                                                                                                                	// as part of standard API requests.
                                                                                                                                                                                                                                                                                                                                                                	Description string `json:"description"`
                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                	DynamicLast4 string      `json:"dynamic_last4"`
                                                                                                                                                                                                                                                                                                                                                                	ExpMonth     uint8       `json:"exp_month"`
                                                                                                                                                                                                                                                                                                                                                                	ExpYear      uint16      `json:"exp_year"`
                                                                                                                                                                                                                                                                                                                                                                	Fingerprint  string      `json:"fingerprint"`
                                                                                                                                                                                                                                                                                                                                                                	Funding      CardFunding `json:"funding"`
                                                                                                                                                                                                                                                                                                                                                                	ID           string      `json:"id"`
                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                	// IIN is the card's "Issuer Identification Number".
                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                	// Please note that this field is for internal use only and is not returned
                                                                                                                                                                                                                                                                                                                                                                	// as part of standard API requests.
                                                                                                                                                                                                                                                                                                                                                                	IIN string `json:"iin"`
                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                	// Issuer is a bank or financial institution that provides the card.
                                                                                                                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                                                                                                                	// Please note that this field is for internal use only and is not returned
                                                                                                                                                                                                                                                                                                                                                                	// as part of standard API requests.
                                                                                                                                                                                                                                                                                                                                                                	Issuer string `json:"issuer"`
                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                	Last4              string                 `json:"last4"`
                                                                                                                                                                                                                                                                                                                                                                	Metadata           map[string]string      `json:"metadata"`
                                                                                                                                                                                                                                                                                                                                                                	Name               string                 `json:"name"`
                                                                                                                                                                                                                                                                                                                                                                	Recipient          *Recipient             `json:"recipient"`
                                                                                                                                                                                                                                                                                                                                                                	ThreeDSecure       *ThreeDSecure          `json:"three_d_secure"`
                                                                                                                                                                                                                                                                                                                                                                	TokenizationMethod CardTokenizationMethod `json:"tokenization_method"`
                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                  Card is the resource representing a Stripe credit/debit card. For more details see https://stripe.com/docs/api#cards.

                                                                                                                                                                                                                                                                                                                                                                  func (*Card) UnmarshalJSON

                                                                                                                                                                                                                                                                                                                                                                  func (c *Card) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                                                                                                                                                                                    UnmarshalJSON handles deserialization of a Card. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

                                                                                                                                                                                                                                                                                                                                                                    type CardAvailablePayoutMethod

                                                                                                                                                                                                                                                                                                                                                                    type CardAvailablePayoutMethod string

                                                                                                                                                                                                                                                                                                                                                                      CardAvailablePayoutMethod is a set of available payout methods for the card.

                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                      	CardAvailablePayoutMethodInstant  CardAvailablePayoutMethod = "Instant"
                                                                                                                                                                                                                                                                                                                                                                      	CardAvailablePayoutMethodStandard CardAvailablePayoutMethod = "Standard"
                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                        List of values that CardAvailablePayoutMethod can take.

                                                                                                                                                                                                                                                                                                                                                                        type CardBrand

                                                                                                                                                                                                                                                                                                                                                                        type CardBrand string

                                                                                                                                                                                                                                                                                                                                                                          CardBrand is the list of allowed values for the card's brand.

                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                          	CardBrandAmex       CardBrand = "American Express"
                                                                                                                                                                                                                                                                                                                                                                          	CardBrandDiscover   CardBrand = "Discover"
                                                                                                                                                                                                                                                                                                                                                                          	CardBrandDinersClub CardBrand = "Diners Club"
                                                                                                                                                                                                                                                                                                                                                                          	CardBrandJCB        CardBrand = "JCB"
                                                                                                                                                                                                                                                                                                                                                                          	CardBrandMasterCard CardBrand = "MasterCard"
                                                                                                                                                                                                                                                                                                                                                                          	CardBrandUnknown    CardBrand = "Unknown"
                                                                                                                                                                                                                                                                                                                                                                          	CardBrandUnionPay   CardBrand = "UnionPay"
                                                                                                                                                                                                                                                                                                                                                                          	CardBrandVisa       CardBrand = "Visa"
                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                            List of values that CardBrand can take.

                                                                                                                                                                                                                                                                                                                                                                            type CardError

                                                                                                                                                                                                                                                                                                                                                                            type CardError struct {
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            	// DeclineCode is a code indicating a card issuer's reason for declining a
                                                                                                                                                                                                                                                                                                                                                                            	// card (if they provided one).
                                                                                                                                                                                                                                                                                                                                                                            	DeclineCode DeclineCode `json:"decline_code,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                              CardError are the most common type of error you should expect to handle. They result when the user enters a card that can't be charged for some reason.

                                                                                                                                                                                                                                                                                                                                                                              func (*CardError) Error

                                                                                                                                                                                                                                                                                                                                                                              func (e *CardError) Error() string

                                                                                                                                                                                                                                                                                                                                                                                Error serializes the error object to JSON and returns it as a string.

                                                                                                                                                                                                                                                                                                                                                                                type CardFunding

                                                                                                                                                                                                                                                                                                                                                                                type CardFunding string

                                                                                                                                                                                                                                                                                                                                                                                  CardFunding is the list of allowed values for the card's funding.

                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                  	CardFundingCredit  CardFunding = "credit"
                                                                                                                                                                                                                                                                                                                                                                                  	CardFundingDebit   CardFunding = "debit"
                                                                                                                                                                                                                                                                                                                                                                                  	CardFundingPrepaid CardFunding = "prepaid"
                                                                                                                                                                                                                                                                                                                                                                                  	CardFundingUnknown CardFunding = "unknown"
                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                    List of values that CardFunding can take.

                                                                                                                                                                                                                                                                                                                                                                                    type CardList

                                                                                                                                                                                                                                                                                                                                                                                    type CardList struct {
                                                                                                                                                                                                                                                                                                                                                                                    	ListMeta
                                                                                                                                                                                                                                                                                                                                                                                    	Data []*Card `json:"data"`
                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                      CardList is a list object for cards.

                                                                                                                                                                                                                                                                                                                                                                                      type CardListParams

                                                                                                                                                                                                                                                                                                                                                                                      type CardListParams struct {
                                                                                                                                                                                                                                                                                                                                                                                      	ListParams `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                      	Account    *string `form:"-"`
                                                                                                                                                                                                                                                                                                                                                                                      	Customer   *string `form:"-"`
                                                                                                                                                                                                                                                                                                                                                                                      	Recipient  *string `form:"-"`
                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                        CardListParams is the set of parameters that can be used when listing cards. For more details see https://stripe.com/docs/api#list_cards.

                                                                                                                                                                                                                                                                                                                                                                                        func (*CardListParams) AppendTo

                                                                                                                                                                                                                                                                                                                                                                                        func (p *CardListParams) AppendTo(body *form.Values, keyParts []string)

                                                                                                                                                                                                                                                                                                                                                                                          AppendTo implements custom encoding logic for CardListParams so that we can send the special required `object` field up along with the other specified parameters.

                                                                                                                                                                                                                                                                                                                                                                                          type CardParams

                                                                                                                                                                                                                                                                                                                                                                                          type CardParams struct {
                                                                                                                                                                                                                                                                                                                                                                                          	Params             `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                          	Account            *string `form:"-"`
                                                                                                                                                                                                                                                                                                                                                                                          	AddressCity        *string `form:"address_city"`
                                                                                                                                                                                                                                                                                                                                                                                          	AddressCountry     *string `form:"address_country"`
                                                                                                                                                                                                                                                                                                                                                                                          	AddressLine1       *string `form:"address_line1"`
                                                                                                                                                                                                                                                                                                                                                                                          	AddressLine2       *string `form:"address_line2"`
                                                                                                                                                                                                                                                                                                                                                                                          	AddressState       *string `form:"address_state"`
                                                                                                                                                                                                                                                                                                                                                                                          	AddressZip         *string `form:"address_zip"`
                                                                                                                                                                                                                                                                                                                                                                                          	CVC                *string `form:"cvc"`
                                                                                                                                                                                                                                                                                                                                                                                          	Currency           *string `form:"currency"`
                                                                                                                                                                                                                                                                                                                                                                                          	Customer           *string `form:"-"`
                                                                                                                                                                                                                                                                                                                                                                                          	DefaultForCurrency *bool   `form:"default_for_currency"`
                                                                                                                                                                                                                                                                                                                                                                                          	ExpMonth           *string `form:"exp_month"`
                                                                                                                                                                                                                                                                                                                                                                                          	ExpYear            *string `form:"exp_year"`
                                                                                                                                                                                                                                                                                                                                                                                          	Name               *string `form:"name"`
                                                                                                                                                                                                                                                                                                                                                                                          	Number             *string `form:"number"`
                                                                                                                                                                                                                                                                                                                                                                                          	Recipient          *string `form:"-"`
                                                                                                                                                                                                                                                                                                                                                                                          	Token              *string `form:"-"`
                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          	// ID is used when tokenizing a card for shared customers
                                                                                                                                                                                                                                                                                                                                                                                          	ID string `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                            CardParams is the set of parameters that can be used when creating or updating a card. For more details see https://stripe.com/docs/api#create_card and https://stripe.com/docs/api#update_card.

                                                                                                                                                                                                                                                                                                                                                                                            Note that while form annotations are used for tokenization and updates, cards have some unusual logic on creates that necessitates manual handling of all parameters. See AppendToAsCardSourceOrExternalAccount.

                                                                                                                                                                                                                                                                                                                                                                                            func (*CardParams) AppendToAsCardSourceOrExternalAccount

                                                                                                                                                                                                                                                                                                                                                                                            func (c *CardParams) AppendToAsCardSourceOrExternalAccount(body *form.Values, keyParts []string)

                                                                                                                                                                                                                                                                                                                                                                                              AppendToAsCardSourceOrExternalAccount appends the given CardParams as either a card or external account.

                                                                                                                                                                                                                                                                                                                                                                                              It may look like an AppendTo from the form package, but it's not, and is only used in the special case where we use `card.New`. It's needed because we have some weird encoding logic here that can't be handled by the form package (and it's special enough that it wouldn't be desirable to have it do so).

                                                                                                                                                                                                                                                                                                                                                                                              This is not a pattern that we want to push forward, and this largely exists because the cards endpoint is a little unusual. There is one other resource like it, which is bank account.

                                                                                                                                                                                                                                                                                                                                                                                              type CardTokenizationMethod

                                                                                                                                                                                                                                                                                                                                                                                              type CardTokenizationMethod string

                                                                                                                                                                                                                                                                                                                                                                                                CardTokenizationMethod is the list of allowed values for the card's tokenization method.

                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                	TokenizationMethodAndroidPay CardTokenizationMethod = "android_pay"
                                                                                                                                                                                                                                                                                                                                                                                                	TokenizationMethodApplePay   CardTokenizationMethod = "apple_pay"
                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                  List of values that CardTokenizationMethod can take.

                                                                                                                                                                                                                                                                                                                                                                                                  type CardVerification

                                                                                                                                                                                                                                                                                                                                                                                                  type CardVerification string

                                                                                                                                                                                                                                                                                                                                                                                                    CardVerification is the list of allowed verification responses.

                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                    	CardVerificationFail        CardVerification = "fail"
                                                                                                                                                                                                                                                                                                                                                                                                    	CardVerificationPass        CardVerification = "pass"
                                                                                                                                                                                                                                                                                                                                                                                                    	CardVerificationUnavailable CardVerification = "unavailable"
                                                                                                                                                                                                                                                                                                                                                                                                    	CardVerificationUnchecked   CardVerification = "unchecked"
                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                      List of values that CardVerification can take.

                                                                                                                                                                                                                                                                                                                                                                                                      type Charge

                                                                                                                                                                                                                                                                                                                                                                                                      type Charge struct {
                                                                                                                                                                                                                                                                                                                                                                                                      	Amount                        int64                       `json:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                      	AmountRefunded                int64                       `json:"amount_refunded"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Application                   *Application                `json:"application"`
                                                                                                                                                                                                                                                                                                                                                                                                      	ApplicationFee                *ApplicationFee             `json:"application_fee"`
                                                                                                                                                                                                                                                                                                                                                                                                      	ApplicationFeeAmount          int64                       `json:"application_fee_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                      	AuthorizationCode             string                      `json:"authorization_code"`
                                                                                                                                                                                                                                                                                                                                                                                                      	BalanceTransaction            *BalanceTransaction         `json:"balance_transaction"`
                                                                                                                                                                                                                                                                                                                                                                                                      	BillingDetails                *BillingDetails             `json:"billing_details"`
                                                                                                                                                                                                                                                                                                                                                                                                      	CalculatedStatementDescriptor string                      `json:"calculated_statement_descriptor"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Captured                      bool                        `json:"captured"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Created                       int64                       `json:"created"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Currency                      Currency                    `json:"currency"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Customer                      *Customer                   `json:"customer"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Description                   string                      `json:"description"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Destination                   *Account                    `json:"destination"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Dispute                       *Dispute                    `json:"dispute"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Disputed                      bool                        `json:"disputed"`
                                                                                                                                                                                                                                                                                                                                                                                                      	FailureCode                   string                      `json:"failure_code"`
                                                                                                                                                                                                                                                                                                                                                                                                      	FailureMessage                string                      `json:"failure_message"`
                                                                                                                                                                                                                                                                                                                                                                                                      	FraudDetails                  *FraudDetails               `json:"fraud_details"`
                                                                                                                                                                                                                                                                                                                                                                                                      	ID                            string                      `json:"id"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Invoice                       *Invoice                    `json:"invoice"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Level3                        ChargeLevel3                `json:"level3"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Livemode                      bool                        `json:"livemode"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Metadata                      map[string]string           `json:"metadata"`
                                                                                                                                                                                                                                                                                                                                                                                                      	OnBehalfOf                    *Account                    `json:"on_behalf_of"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Outcome                       *ChargeOutcome              `json:"outcome"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Paid                          bool                        `json:"paid"`
                                                                                                                                                                                                                                                                                                                                                                                                      	PaymentIntent                 string                      `json:"payment_intent"`
                                                                                                                                                                                                                                                                                                                                                                                                      	PaymentMethod                 string                      `json:"payment_method"`
                                                                                                                                                                                                                                                                                                                                                                                                      	PaymentMethodDetails          *ChargePaymentMethodDetails `json:"payment_method_details"`
                                                                                                                                                                                                                                                                                                                                                                                                      	ReceiptEmail                  string                      `json:"receipt_email"`
                                                                                                                                                                                                                                                                                                                                                                                                      	ReceiptNumber                 string                      `json:"receipt_number"`
                                                                                                                                                                                                                                                                                                                                                                                                      	ReceiptURL                    string                      `json:"receipt_url"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Refunded                      bool                        `json:"refunded"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Refunds                       *RefundList                 `json:"refunds"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Review                        *Review                     `json:"review"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Shipping                      *ShippingDetails            `json:"shipping"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Source                        *PaymentSource              `json:"source"`
                                                                                                                                                                                                                                                                                                                                                                                                      	SourceTransfer                *Transfer                   `json:"source_transfer"`
                                                                                                                                                                                                                                                                                                                                                                                                      	StatementDescriptor           string                      `json:"statement_descriptor"`
                                                                                                                                                                                                                                                                                                                                                                                                      	StatementDescriptorSuffix     string                      `json:"statement_descriptor_suffix"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Status                        string                      `json:"status"`
                                                                                                                                                                                                                                                                                                                                                                                                      	Transfer                      *Transfer                   `json:"transfer"`
                                                                                                                                                                                                                                                                                                                                                                                                      	TransferData                  *ChargeTransferData         `json:"transfer_data"`
                                                                                                                                                                                                                                                                                                                                                                                                      	TransferGroup                 string                      `json:"transfer_group"`
                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                        Charge is the resource representing a Stripe charge. For more details see https://stripe.com/docs/api#charges.

                                                                                                                                                                                                                                                                                                                                                                                                        Example (Get)
                                                                                                                                                                                                                                                                                                                                                                                                        Output:
                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                        Example (New)
                                                                                                                                                                                                                                                                                                                                                                                                        Output:
                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                        func (*Charge) UnmarshalJSON

                                                                                                                                                                                                                                                                                                                                                                                                        func (c *Charge) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                                                                                                                                                                                                                          UnmarshalJSON handles deserialization of a charge. This custom unmarshaling is needed because the resulting property may be an ID or the full struct if it was expanded.

                                                                                                                                                                                                                                                                                                                                                                                                          type ChargeFraudStripeReport

                                                                                                                                                                                                                                                                                                                                                                                                          type ChargeFraudStripeReport string

                                                                                                                                                                                                                                                                                                                                                                                                            ChargeFraudStripeReport is the list of allowed values for reporting fraud.

                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                            	ChargeFraudStripeReportFraudulent ChargeFraudStripeReport = "fraudulent"
                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                              List of values that ChargeFraudStripeReport can take.

                                                                                                                                                                                                                                                                                                                                                                                                              type ChargeFraudUserReport

                                                                                                                                                                                                                                                                                                                                                                                                              type ChargeFraudUserReport string

                                                                                                                                                                                                                                                                                                                                                                                                                ChargeFraudUserReport is the list of allowed values for reporting fraud.

                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                	ChargeFraudUserReportFraudulent ChargeFraudUserReport = "fraudulent"
                                                                                                                                                                                                                                                                                                                                                                                                                	ChargeFraudUserReportSafe       ChargeFraudUserReport = "safe"
                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                  List of values that ChargeFraudUserReport can take.

                                                                                                                                                                                                                                                                                                                                                                                                                  type ChargeLevel3

                                                                                                                                                                                                                                                                                                                                                                                                                  type ChargeLevel3 struct {
                                                                                                                                                                                                                                                                                                                                                                                                                  	CustomerReference  string                  `json:"customer_reference"`
                                                                                                                                                                                                                                                                                                                                                                                                                  	LineItems          []*ChargeLevel3LineItem `json:"line_items"`
                                                                                                                                                                                                                                                                                                                                                                                                                  	MerchantReference  string                  `json:"merchant_reference"`
                                                                                                                                                                                                                                                                                                                                                                                                                  	ShippingAddressZip string                  `json:"shipping_address_zip"`
                                                                                                                                                                                                                                                                                                                                                                                                                  	ShippingFromZip    string                  `json:"shipping_from_zip"`
                                                                                                                                                                                                                                                                                                                                                                                                                  	ShippingAmount     int64                   `json:"shipping_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                    ChargeLevel3 represents the Level III data. This is in private beta and would be empty for most integrations

                                                                                                                                                                                                                                                                                                                                                                                                                    type ChargeLevel3LineItem

                                                                                                                                                                                                                                                                                                                                                                                                                    type ChargeLevel3LineItem struct {
                                                                                                                                                                                                                                                                                                                                                                                                                    	DiscountAmount     int64  `json:"discount_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                    	ProductCode        string `json:"product_code"`
                                                                                                                                                                                                                                                                                                                                                                                                                    	ProductDescription string `json:"product_description"`
                                                                                                                                                                                                                                                                                                                                                                                                                    	Quantity           int64  `json:"quantity"`
                                                                                                                                                                                                                                                                                                                                                                                                                    	TaxAmount          int64  `json:"tax_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                    	UnitCost           int64  `json:"unit_cost"`
                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                      ChargeLevel3LineItem represents a line item on level III data. This is in private beta and would be empty for most integrations

                                                                                                                                                                                                                                                                                                                                                                                                                      type ChargeLevel3LineItemsParams

                                                                                                                                                                                                                                                                                                                                                                                                                      type ChargeLevel3LineItemsParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                      	DiscountAmount     *int64  `form:"discount_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                      	ProductCode        *string `form:"product_code"`
                                                                                                                                                                                                                                                                                                                                                                                                                      	ProductDescription *string `form:"product_description"`
                                                                                                                                                                                                                                                                                                                                                                                                                      	Quantity           *int64  `form:"quantity"`
                                                                                                                                                                                                                                                                                                                                                                                                                      	TaxAmount          *int64  `form:"tax_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                      	UnitCost           *int64  `form:"unit_cost"`
                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                        ChargeLevel3LineItemsParams is the set of parameters that represent a line item on level III data.

                                                                                                                                                                                                                                                                                                                                                                                                                        type ChargeLevel3Params

                                                                                                                                                                                                                                                                                                                                                                                                                        type ChargeLevel3Params struct {
                                                                                                                                                                                                                                                                                                                                                                                                                        	CustomerReference  *string                        `form:"customer_reference"`
                                                                                                                                                                                                                                                                                                                                                                                                                        	LineItems          []*ChargeLevel3LineItemsParams `form:"line_items"`
                                                                                                                                                                                                                                                                                                                                                                                                                        	MerchantReference  *string                        `form:"merchant_reference"`
                                                                                                                                                                                                                                                                                                                                                                                                                        	ShippingAddressZip *string                        `form:"shipping_address_zip"`
                                                                                                                                                                                                                                                                                                                                                                                                                        	ShippingFromZip    *string                        `form:"shipping_from_zip"`
                                                                                                                                                                                                                                                                                                                                                                                                                        	ShippingAmount     *int64                         `form:"shipping_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                          ChargeLevel3Params is the set of parameters that can be used for the Level III data.

                                                                                                                                                                                                                                                                                                                                                                                                                          type ChargeList

                                                                                                                                                                                                                                                                                                                                                                                                                          type ChargeList struct {
                                                                                                                                                                                                                                                                                                                                                                                                                          	ListMeta
                                                                                                                                                                                                                                                                                                                                                                                                                          	Data []*Charge `json:"data"`
                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                            ChargeList is a list of charges as retrieved from a list endpoint.

                                                                                                                                                                                                                                                                                                                                                                                                                            type ChargeListParams

                                                                                                                                                                                                                                                                                                                                                                                                                            type ChargeListParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                            	ListParams    `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                            	Created       *int64            `form:"created"`
                                                                                                                                                                                                                                                                                                                                                                                                                            	CreatedRange  *RangeQueryParams `form:"created"`
                                                                                                                                                                                                                                                                                                                                                                                                                            	Customer      *string           `form:"customer"`
                                                                                                                                                                                                                                                                                                                                                                                                                            	PaymentIntent *string           `form:"payment_intent"`
                                                                                                                                                                                                                                                                                                                                                                                                                            	TransferGroup *string           `form:"transfer_group"`
                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                              ChargeListParams is the set of parameters that can be used when listing charges.

                                                                                                                                                                                                                                                                                                                                                                                                                              type ChargeOutcome

                                                                                                                                                                                                                                                                                                                                                                                                                              type ChargeOutcome struct {
                                                                                                                                                                                                                                                                                                                                                                                                                              	NetworkStatus string             `json:"network_status"`
                                                                                                                                                                                                                                                                                                                                                                                                                              	Reason        string             `json:"reason"`
                                                                                                                                                                                                                                                                                                                                                                                                                              	RiskLevel     string             `json:"risk_level"`
                                                                                                                                                                                                                                                                                                                                                                                                                              	RiskScore     int64              `json:"risk_score"`
                                                                                                                                                                                                                                                                                                                                                                                                                              	Rule          *ChargeOutcomeRule `json:"rule"`
                                                                                                                                                                                                                                                                                                                                                                                                                              	SellerMessage string             `json:"seller_message"`
                                                                                                                                                                                                                                                                                                                                                                                                                              	Type          string             `json:"type"`
                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                ChargeOutcome is the charge's outcome that details whether a payment was accepted and why.

                                                                                                                                                                                                                                                                                                                                                                                                                                type ChargeOutcomeRule

                                                                                                                                                                                                                                                                                                                                                                                                                                type ChargeOutcomeRule struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                	Action    string `json:"action"`
                                                                                                                                                                                                                                                                                                                                                                                                                                	ID        string `json:"id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                	Predicate string `json:"predicate"`
                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                  ChargeOutcomeRule tells you the Radar rule that blocked the charge, if any.

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*ChargeOutcomeRule) UnmarshalJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c *ChargeOutcomeRule) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                                                                                                                                                                                                                                                    UnmarshalJSON handles deserialization of a ChargeOutcomeRule. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

                                                                                                                                                                                                                                                                                                                                                                                                                                    type ChargeParams

                                                                                                                                                                                                                                                                                                                                                                                                                                    type ChargeParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Params                    `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Amount                    *int64                    `form:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	ApplicationFeeAmount      *int64                    `form:"application_fee_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Capture                   *bool                     `form:"capture"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Currency                  *string                   `form:"currency"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Customer                  *string                   `form:"customer"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Description               *string                   `form:"description"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Destination               *DestinationParams        `form:"destination"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	ExchangeRate              *float64                  `form:"exchange_rate"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	FraudDetails              *FraudDetailsParams       `form:"fraud_details"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Level3                    *ChargeLevel3Params       `form:"level3"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	OnBehalfOf                *string                   `form:"on_behalf_of"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	ReceiptEmail              *string                   `form:"receipt_email"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Shipping                  *ShippingDetailsParams    `form:"shipping"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	Source                    *SourceParams             `form:"*"` // SourceParams has custom encoding so brought to top level with "*"
                                                                                                                                                                                                                                                                                                                                                                                                                                    	StatementDescriptor       *string                   `form:"statement_descriptor"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	StatementDescriptorSuffix *string                   `form:"statement_descriptor_suffix"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	TransferData              *ChargeTransferDataParams `form:"transfer_data"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    	TransferGroup             *string                   `form:"transfer_group"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                      ChargeParams is the set of parameters that can be used when creating or updating a charge.

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ChargeParams) SetSource

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (p *ChargeParams) SetSource(sp interface{}) error

                                                                                                                                                                                                                                                                                                                                                                                                                                        SetSource adds valid sources to a ChargeParams object, returning an error for unsupported sources.

                                                                                                                                                                                                                                                                                                                                                                                                                                        type ChargePaymentMethodDetails

                                                                                                                                                                                                                                                                                                                                                                                                                                        type ChargePaymentMethodDetails struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                        	AchCreditTransfer *ChargePaymentMethodDetailsAchCreditTransfer `json:"ach_credit_transfer"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	AchDebit          *ChargePaymentMethodDetailsAchDebit          `json:"ach_debit"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Alipay            *ChargePaymentMethodDetailsAlipay            `json:"alipay"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Bancontact        *ChargePaymentMethodDetailsBancontact        `json:"bancontact"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	AUBECSDebit       *ChargePaymentMethodDetailsAUBECSDebit       `json:"au_becs_debit"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Bitcoin           *ChargePaymentMethodDetailsBitcoin           `json:"bitcoin"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Card              *ChargePaymentMethodDetailsCard              `json:"card"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	CardPresent       *ChargePaymentMethodDetailsCardPresent       `json:"card_present"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Eps               *ChargePaymentMethodDetailsEps               `json:"eps"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	FPX               *ChargePaymentMethodDetailsFPX               `json:"fpx"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Giropay           *ChargePaymentMethodDetailsGiropay           `json:"giropay"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Ideal             *ChargePaymentMethodDetailsIdeal             `json:"ideal"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Klarna            *ChargePaymentMethodDetailsKlarna            `json:"klarna"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Multibanco        *ChargePaymentMethodDetailsMultibanco        `json:"multibanco"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	P24               *ChargePaymentMethodDetailsP24               `json:"p24"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	SepaDebit         *ChargePaymentMethodDetailsSepaDebit         `json:"sepa_debit"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Sofort            *ChargePaymentMethodDetailsSofort            `json:"sofort"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	StripeAccount     *ChargePaymentMethodDetailsStripeAccount     `json:"stripe_account"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Type              ChargePaymentMethodDetailsType               `json:"type"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        	Wechat            *ChargePaymentMethodDetailsWechat            `json:"wechat"`
                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                          ChargePaymentMethodDetails represents the details about the PaymentMethod associated with the charge.

                                                                                                                                                                                                                                                                                                                                                                                                                                          type ChargePaymentMethodDetailsAUBECSDebit

                                                                                                                                                                                                                                                                                                                                                                                                                                          type ChargePaymentMethodDetailsAUBECSDebit struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                          	BSBNumber   string `json:"bsb_number"`
                                                                                                                                                                                                                                                                                                                                                                                                                                          	Fingerprint string `json:"fingerprint"`
                                                                                                                                                                                                                                                                                                                                                                                                                                          	Last4       string `json:"last4"`
                                                                                                                                                                                                                                                                                                                                                                                                                                          	Mandate     string `json:"mandate"`
                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                            ChargePaymentMethodDetailsAUBECSDebit represents details about the AU BECS DD PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChargePaymentMethodDetailsAchCreditTransfer

                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChargePaymentMethodDetailsAchCreditTransfer struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                            	AccountNumber string `json:"account_number"`
                                                                                                                                                                                                                                                                                                                                                                                                                                            	BankName      string `json:"bank_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                            	RoutingNumber string `json:"routing_number"`
                                                                                                                                                                                                                                                                                                                                                                                                                                            	SwiftCode     string `json:"swift_code"`
                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                              ChargePaymentMethodDetailsAchCreditTransfer represents details about the ACH Credit Transfer PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                              type ChargePaymentMethodDetailsAchDebit

                                                                                                                                                                                                                                                                                                                                                                                                                                              type ChargePaymentMethodDetailsAchDebit struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                              	AccountHolderType BankAccountAccountHolderType `json:"account_holder_type"`
                                                                                                                                                                                                                                                                                                                                                                                                                                              	BankName          string                       `json:"bank_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                              	Country           string                       `json:"country"`
                                                                                                                                                                                                                                                                                                                                                                                                                                              	Fingerprint       string                       `json:"fingerprint"`
                                                                                                                                                                                                                                                                                                                                                                                                                                              	Last4             string                       `json:"last4"`
                                                                                                                                                                                                                                                                                                                                                                                                                                              	RoutingNumber     string                       `json:"routing_number"`
                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                ChargePaymentMethodDetailsAchDebit represents details about the ACH Debit PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                type ChargePaymentMethodDetailsAcssDebit

                                                                                                                                                                                                                                                                                                                                                                                                                                                type ChargePaymentMethodDetailsAcssDebit struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                	Country       string `json:"country"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                	Fingerprint   string `json:"fingerprint"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                	Last4         string `json:"last4"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                	RoutingNumber string `json:"routing_number"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                  ChargePaymentMethodDetailsAcssDebit represents details about the ACSS Debit PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ChargePaymentMethodDetailsAlipay

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ChargePaymentMethodDetailsAlipay struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                    ChargePaymentMethodDetailsAlipay represents details about the Alipay PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ChargePaymentMethodDetailsBancontact

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ChargePaymentMethodDetailsBancontact struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	BankCode          string `json:"bank_code"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	BankName          string `json:"bank_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Bic               string `json:"bic"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	IbanLast4         string `json:"iban_last4"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	PreferredLanguage string `json:"preferred_language"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	VerifiedName      string `json:"verified_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                      ChargePaymentMethodDetailsBancontact represents details about the Bancontact PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ChargePaymentMethodDetailsBitcoin

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ChargePaymentMethodDetailsBitcoin struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Address        string `json:"address"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Amount         int64  `json:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	AmountCharged  int64  `json:"amount_charged"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	AmountReceived int64  `json:"amount_received"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	AmountReturned int64  `json:"amount_returned"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                      	RefundAddress  string `json:"refund_address"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                        ChargePaymentMethodDetailsBitcoin represents details about the Bitcoin PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ChargePaymentMethodDetailsCard

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ChargePaymentMethodDetailsCard struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Brand        PaymentMethodCardBrand                      `json:"brand"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Checks       *ChargePaymentMethodDetailsCardChecks       `json:"checks"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Country      string                                      `json:"country"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ExpMonth     uint64                                      `json:"exp_month"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ExpYear      uint64                                      `json:"exp_year"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Fingerprint  string                                      `json:"fingerprint"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Funding      CardFunding                                 `json:"funding"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Installments *ChargePaymentMethodDetailsCardInstallments `json:"installments"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Last4        string                                      `json:"last4"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Network      PaymentMethodCardNetwork                    `json:"network"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	MOTO         bool                                        `json:"moto"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ThreeDSecure *ChargePaymentMethodDetailsCardThreeDSecure `json:"three_d_secure"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Wallet       *ChargePaymentMethodDetailsCardWallet       `json:"wallet"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Please note that the fields below are for internal use only and are not returned
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// as part of standard API requests.
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Description string `json:"description"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	IIN         string `json:"iin"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Issuer      string `json:"issuer"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                          ChargePaymentMethodDetailsCard represents details about the Card PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ChargePaymentMethodDetailsCardChecks

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ChargePaymentMethodDetailsCardChecks struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	AddressLine1Check      CardVerification `json:"address_line1_check"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	AddressPostalCodeCheck CardVerification `json:"address_postal_code_check"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                          	CVCCheck               CardVerification `json:"cvc_check"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                            ChargePaymentMethodDetailsCardChecks represents the checks associated with the charge's Card PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChargePaymentMethodDetailsCardInstallments

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChargePaymentMethodDetailsCardInstallments struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Plan *PaymentIntentPaymentMethodOptionsCardInstallmentsPlan `json:"plan"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                              ChargePaymentMethodDetailsCardInstallments represents details about the installment plan chosen for this charge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ChargePaymentMethodDetailsCardPresent

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ChargePaymentMethodDetailsCardPresent struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Brand         PaymentMethodCardBrand                        `json:"brand"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Country       string                                        `json:"country"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	EmvAuthData   string                                        `json:"emv_auth_data"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ExpMonth      uint64                                        `json:"exp_month"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ExpYear       uint64                                        `json:"exp_year"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Fingerprint   string                                        `json:"fingerprint"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Funding       CardFunding                                   `json:"funding"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	GeneratedCard string                                        `json:"generated_card"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Last4         string                                        `json:"last4"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Network       PaymentMethodCardNetwork                      `json:"network"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ReadMethod    string                                        `json:"read_method"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Receipt       *ChargePaymentMethodDetailsCardPresentReceipt `json:"receipt"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                ChargePaymentMethodDetailsCardPresent represents details about the Card Present PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ChargePaymentMethodDetailsCardPresentReceipt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ChargePaymentMethodDetailsCardPresentReceipt struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ApplicationCryptogram        string `json:"application_cryptogram"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ApplicationPreferredName     string `json:"application_preferred_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	AuthorizationCode            string `json:"authorization_code"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	AuthorizationResponseCode    string `json:"authorization_response_code"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CardholderVerificationMethod string `json:"cardholder_verification_method"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DedicatedFileName            string `json:"dedicated_file_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	TerminalVerificationResults  string `json:"terminal_verification_results"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	TransactionStatusInformation string `json:"transaction_status_information"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ChargePaymentMethodDetailsCardPresentReceipt represents details about the receipt on a Card Present PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ChargePaymentMethodDetailsCardThreeDSecure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ChargePaymentMethodDetailsCardThreeDSecure struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Authenticated bool   `json:"authenticated"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Succeeded     bool   `json:"succeeded"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Version       string `json:"version"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ChargePaymentMethodDetailsCardThreeDSecure represents details about 3DS associated with the charge's PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ChargePaymentMethodDetailsCardWallet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ChargePaymentMethodDetailsCardWallet struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	AmexExpressCheckout *ChargePaymentMethodDetailsCardWalletAmexExpressCheckout `json:"amex_express_checkout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ApplePay            *ChargePaymentMethodDetailsCardWalletApplePay            `json:"apple_pay"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	DynamicLast4        string                                                   `json:"dynamic_last4"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	GooglePay           *ChargePaymentMethodDetailsCardWalletGooglePay           `json:"google_pay"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Masterpass          *ChargePaymentMethodDetailsCardWalletMasterpass          `json:"masterpass"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	SamsungPay          *ChargePaymentMethodDetailsCardWalletSamsungPay          `json:"samsung_pay"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Type                PaymentMethodCardWalletType                              `json:"type"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	VisaCheckout        *ChargePaymentMethodDetailsCardWalletVisaCheckout        `json:"visa_checkout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ChargePaymentMethodDetailsCardWallet represents the details of the card wallet if this Card PaymentMethod is part of a card wallet.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ChargePaymentMethodDetailsCardWalletAmexExpressCheckout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ChargePaymentMethodDetailsCardWalletAmexExpressCheckout struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ChargePaymentMethodDetailsCardWalletAmexExpressCheckout represents the details of the Amex Express Checkout wallet.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ChargePaymentMethodDetailsCardWalletApplePay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ChargePaymentMethodDetailsCardWalletApplePay struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ChargePaymentMethodDetailsCardWalletApplePay represents the details of the Apple Pay wallet.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ChargePaymentMethodDetailsCardWalletGooglePay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ChargePaymentMethodDetailsCardWalletGooglePay struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ChargePaymentMethodDetailsCardWalletGooglePay represents the details of the Google Pay wallet.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChargePaymentMethodDetailsCardWalletMasterpass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChargePaymentMethodDetailsCardWalletMasterpass struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	BillingAddress  *Address `json:"billing_address"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Email           string   `json:"email"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Name            string   `json:"name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ShippingAddress *Address `json:"shipping_address"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ChargePaymentMethodDetailsCardWalletMasterpass represents the details of the Masterpass wallet.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ChargePaymentMethodDetailsCardWalletSamsungPay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ChargePaymentMethodDetailsCardWalletSamsungPay struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ChargePaymentMethodDetailsCardWalletSamsungPay represents the details of the Samsung Pay wallet.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ChargePaymentMethodDetailsCardWalletVisaCheckout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ChargePaymentMethodDetailsCardWalletVisaCheckout struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	BillingAddress  *Address `json:"billing_address"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Email           string   `json:"email"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Name            string   `json:"name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ShippingAddress *Address `json:"shipping_address"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ChargePaymentMethodDetailsCardWalletVisaCheckout represents the details of the Visa Checkout wallet.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ChargePaymentMethodDetailsEps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ChargePaymentMethodDetailsEps struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	VerifiedName string `json:"verified_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ChargePaymentMethodDetailsEps represents details about the EPS PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ChargePaymentMethodDetailsFPX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ChargePaymentMethodDetailsFPX struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	AccountHolderType PaymentMethodFPXAccountHolderType `json:"account_holder_type"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Bank              string                            `json:"bank"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	TransactionID     string                            `json:"transaction_id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ChargePaymentMethodDetailsFPX represents details about the FPX PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ChargePaymentMethodDetailsGiropay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ChargePaymentMethodDetailsGiropay struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	BankCode     string `json:"bank_code"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	BankName     string `json:"bank_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Bic          string `json:"bic"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	VerifiedName string `json:"verified_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ChargePaymentMethodDetailsGiropay represents details about the Giropay PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ChargePaymentMethodDetailsIdeal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ChargePaymentMethodDetailsIdeal struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Bank         string `json:"bank"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Bic          string `json:"bic"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	IbanLast4    string `json:"iban_last4"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	VerifiedName string `json:"verified_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ChargePaymentMethodDetailsIdeal represents details about the Ideal PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ChargePaymentMethodDetailsKlarna

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ChargePaymentMethodDetailsKlarna struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ChargePaymentMethodDetailsKlarna represents details for the Klarna PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChargePaymentMethodDetailsMultibanco

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChargePaymentMethodDetailsMultibanco struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Entity    string `json:"entity"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Reference string `json:"reference"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ChargePaymentMethodDetailsMultibanco represents details about the Multibanco PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ChargePaymentMethodDetailsP24

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ChargePaymentMethodDetailsP24 struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Reference    string `json:"reference"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	VerifiedName string `json:"verified_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ChargePaymentMethodDetailsP24 represents details about the P24 PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ChargePaymentMethodDetailsSepaDebit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ChargePaymentMethodDetailsSepaDebit struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	BankCode    string `json:"bank_code"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	BranchCode  string `json:"branch_code"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Country     string `json:"country"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Fingerprint string `json:"fingerprint"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Last4       string `json:"last4"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ChargePaymentMethodDetailsSepaDebit represents details about the Sepa Debit PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ChargePaymentMethodDetailsSofort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ChargePaymentMethodDetailsSofort struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BankCode     string `json:"bank_code"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BankName     string `json:"bank_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Bic          string `json:"bic"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Country      string `json:"country"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	IbanLast4    string `json:"iban_last4"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	VerifiedName string `json:"verified_name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ChargePaymentMethodDetailsSofort represents details about the Sofort PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ChargePaymentMethodDetailsStripeAccount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ChargePaymentMethodDetailsStripeAccount struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ChargePaymentMethodDetailsStripeAccount represents details about the StripeAccount PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ChargePaymentMethodDetailsType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ChargePaymentMethodDetailsType string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ChargePaymentMethodDetailsType is the type of the PaymentMethod associated with the Charge's payment method details.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeAchCreditTransfer ChargePaymentMethodDetailsType = "ach_credit_transfer"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeAchDebit          ChargePaymentMethodDetailsType = "ach_debit"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeAcssDebit         ChargePaymentMethodDetailsType = "acss_debit"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeAlipay            ChargePaymentMethodDetailsType = "alipay"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeAUBECSDebit       ChargePaymentMethodDetailsType = "au_becs_debit"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeBancontact        ChargePaymentMethodDetailsType = "bancontact"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeBitcoin           ChargePaymentMethodDetailsType = "bitcoin" // This is unsupported today and is here for legacy charges.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeCard              ChargePaymentMethodDetailsType = "card"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeCardPresent       ChargePaymentMethodDetailsType = "card_present"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeEps               ChargePaymentMethodDetailsType = "eps"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeFPX               ChargePaymentMethodDetailsType = "fpx"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeGiropay           ChargePaymentMethodDetailsType = "giropay"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeIdeal             ChargePaymentMethodDetailsType = "ideal"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeKlarna            ChargePaymentMethodDetailsType = "klarna"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeMultibanco        ChargePaymentMethodDetailsType = "multibanco"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeP24               ChargePaymentMethodDetailsType = "p24"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeSepaDebit         ChargePaymentMethodDetailsType = "sepa_debit"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeSofort            ChargePaymentMethodDetailsType = "sofort"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeStripeAccount     ChargePaymentMethodDetailsType = "stripe_account"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ChargePaymentMethodDetailsTypeWechat            ChargePaymentMethodDetailsType = "wechat"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          List of values that ChargePaymentMethodDetailsType can take.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ChargePaymentMethodDetailsWechat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ChargePaymentMethodDetailsWechat struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ChargePaymentMethodDetailsWechat represents details about the Wechat PaymentMethod.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChargeTransferData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ChargeTransferData struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Amount      int64    `form:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Destination *Account `json:"destination"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ChargeTransferData represents the information for the transfer_data associated with a charge.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ChargeTransferDataParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ChargeTransferDataParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Amount *int64 `form:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// This parameter can only be used on Charge creation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Destination *string `form:"destination"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ChargeTransferDataParams is the set of parameters allowed for the transfer_data hash.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CheckoutSession

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CheckoutSession struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CancelURL                 string                                    `json:"cancel_url"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ClientReferenceID         string                                    `json:"client_reference_id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Customer                  *Customer                                 `json:"customer"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CustomerEmail             string                                    `json:"customer_email"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Deleted                   bool                                      `json:"deleted"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DisplayItems              []*CheckoutSessionDisplayItem             `json:"display_items"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ID                        string                                    `json:"id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Livemode                  bool                                      `json:"livemode"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Locale                    string                                    `json:"locale"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Metadata                  map[string]string                         `json:"metadata"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Mode                      CheckoutSessionMode                       `json:"mode"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Object                    string                                    `json:"object"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	PaymentIntent             *PaymentIntent                            `json:"payment_intent"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	PaymentMethodTypes        []string                                  `json:"payment_method_types"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SetupIntent               *SetupIntent                              `json:"setup_intent"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Shipping                  *ShippingDetails                          `json:"shipping"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ShippingAddressCollection *CheckoutSessionShippingAddressCollection `json:"shipping_address_collection"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Subscription              *Subscription                             `json:"subscription"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SubmitType                CheckoutSessionSubmitType                 `json:"submit_type"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	SuccessURL                string                                    `json:"success_url"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CheckoutSession is the resource representing a Stripe checkout session. For more details see https://stripe.com/docs/api/checkout/sessions/object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*CheckoutSession) UnmarshalJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (p *CheckoutSession) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    UnmarshalJSON handles deserialization of a checkout session. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CheckoutSessionDisplayItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CheckoutSessionDisplayItem struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Amount   int64                             `json:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Currency Currency                          `json:"currency"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Custom   *CheckoutSessionDisplayItemCustom `json:"custom"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Quantity int64                             `json:"quantity"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Plan     *Plan                             `json:"plan"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	SKU      *SKU                              `json:"sku"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Type     CheckoutSessionDisplayItemType    `json:"type"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CheckoutSessionDisplayItem represents one of the items in a checkout session.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CheckoutSessionDisplayItemCustom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CheckoutSessionDisplayItemCustom struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Description string   `json:"description"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Images      []string `json:"images"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Name        string   `json:"name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CheckoutSessionDisplayItemCustom represents an item of type custom in a checkout session

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CheckoutSessionDisplayItemType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CheckoutSessionDisplayItemType string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CheckoutSessionDisplayItemType is the list of allowed values for the display item type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	CheckoutSessionDisplayItemTypeCustom CheckoutSessionDisplayItemType = "custom"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	CheckoutSessionDisplayItemTypePlan   CheckoutSessionDisplayItemType = "plan"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	CheckoutSessionDisplayItemTypeSKU    CheckoutSessionDisplayItemType = "sku"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            List of values that CheckoutSessionDisplayItemType can take.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CheckoutSessionLineItemParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CheckoutSessionLineItemParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Amount      *int64    `form:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Currency    *string   `form:"currency"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Description *string   `form:"description"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Images      []*string `form:"images"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Name        *string   `form:"name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Quantity    *int64    `form:"quantity"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TaxRates    []*string `form:"tax_rates"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CheckoutSessionLineItemParams is the set of parameters allowed for a line item on a checkout session.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CheckoutSessionList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CheckoutSessionList struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ListMeta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Data []*CheckoutSession `json:"data"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CheckoutSessionList is a list of sessions as retrieved from a list endpoint.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CheckoutSessionListParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CheckoutSessionListParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ListParams    `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	PaymentIntent *string `form:"payment_intent"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Subscription  *string `form:"subscription"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CheckoutSessionListParams is the set of parameters that can be used when listing sessions. For more details see: https://stripe.com/docs/api/checkout/sessions/list

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CheckoutSessionMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CheckoutSessionMode string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CheckoutSessionMode is the list of allowed values for the mode on a Session.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CheckoutSessionModePayment      CheckoutSessionMode = "payment"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CheckoutSessionModeSetup        CheckoutSessionMode = "setup"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CheckoutSessionModeSubscription CheckoutSessionMode = "subscription"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      List of values that CheckoutSessionMode can take.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CheckoutSessionParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CheckoutSessionParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Params                    `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	BillingAddressCollection  *string                                         `form:"billing_address_collection"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	CancelURL                 *string                                         `form:"cancel_url"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ClientReferenceID         *string                                         `form:"client_reference_id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Customer                  *string                                         `form:"customer"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	CustomerEmail             *string                                         `form:"customer_email"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	LineItems                 []*CheckoutSessionLineItemParams                `form:"line_items"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Locale                    *string                                         `form:"locale"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Mode                      *string                                         `form:"mode"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	PaymentIntentData         *CheckoutSessionPaymentIntentDataParams         `form:"payment_intent_data"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	PaymentMethodTypes        []*string                                       `form:"payment_method_types"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	SetupIntentData           *CheckoutSessionSetupIntentDataParams           `form:"setup_intent_data"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ShippingAddressCollection *CheckoutSessionShippingAddressCollectionParams `form:"shipping_address_collection"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	SubscriptionData          *CheckoutSessionSubscriptionDataParams          `form:"subscription_data"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	SubmitType                *string                                         `form:"submit_type"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	SuccessURL                *string                                         `form:"success_url"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CheckoutSessionParams is the set of parameters that can be used when creating a checkout session. For more details see https://stripe.com/docs/api/checkout/sessions/create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CheckoutSessionPaymentIntentDataParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CheckoutSessionPaymentIntentDataParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Params                    `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ApplicationFeeAmount      *int64                                              `form:"application_fee_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CaptureMethod             *string                                             `form:"capture_method"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Description               *string                                             `form:"description"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	OnBehalfOf                *string                                             `form:"on_behalf_of"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ReceiptEmail              *string                                             `form:"receipt_email"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SetupFutureUsage          *string                                             `form:"setup_future_usage"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Shipping                  *ShippingDetailsParams                              `form:"shipping"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	StatementDescriptor       *string                                             `form:"statement_descriptor"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	StatementDescriptorSuffix *string                                             `form:"statement_descriptor_suffix"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TransferData              *CheckoutSessionPaymentIntentDataTransferDataParams `form:"transfer_data"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CheckoutSessionPaymentIntentDataParams is the set of parameters allowed for the payment intent creation on a checkout session.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CheckoutSessionPaymentIntentDataTransferDataParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CheckoutSessionPaymentIntentDataTransferDataParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Amount      *int64  `form:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Destination *string `form:"destination"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CheckoutSessionPaymentIntentDataTransferDataParams is the set of parameters allowed for the transfer_data hash.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CheckoutSessionSetupIntentDataParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CheckoutSessionSetupIntentDataParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Params      `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Description *string `form:"description"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	OnBehalfOf  *string `form:"on_behalf_of"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CheckoutSessionSetupIntentDataParams is the set of parameters allowed for the setup intent creation on a checkout session.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CheckoutSessionShippingAddressCollection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CheckoutSessionShippingAddressCollection struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	AllowedCountries []string `json:"allowed_countries"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CheckoutSessionShippingAddressCollection is the set of parameters allowed for the shipping address collection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CheckoutSessionShippingAddressCollectionParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CheckoutSessionShippingAddressCollectionParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	AllowedCountries []*string `form:"allowed_countries"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CheckoutSessionShippingAddressCollectionParams is the set of parameters allowed for the shipping address collection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CheckoutSessionSubmitType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CheckoutSessionSubmitType string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CheckoutSessionSubmitType is the list of allowed values for the `submit_type` of a Session.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CheckoutSessionSubmitTypeAuto   CheckoutSessionSubmitType = "auto"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CheckoutSessionSubmitTypeBook   CheckoutSessionSubmitType = "book"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CheckoutSessionSubmitTypeDonate CheckoutSessionSubmitType = "donate"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CheckoutSessionSubmitTypePay    CheckoutSessionSubmitType = "pay"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      List of values that CheckoutSessionSubmitType can take.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CheckoutSessionSubscriptionDataItemsParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CheckoutSessionSubscriptionDataItemsParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Plan     *string   `form:"plan"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Quantity *int64    `form:"quantity"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TaxRates []*string `form:"tax_rates"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CheckoutSessionSubscriptionDataItemsParams is the set of parameters allowed for one item on a checkout session associated with a subscription.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CheckoutSessionSubscriptionDataParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CheckoutSessionSubscriptionDataParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Params                `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ApplicationFeePercent *float64                                      `form:"application_fee_percent"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	DefaultTaxRates       []*string                                     `form:"default_tax_rates"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Items                 []*CheckoutSessionSubscriptionDataItemsParams `form:"items"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TrialEnd              *int64                                        `form:"trial_end"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TrialFromPlan         *bool                                         `form:"trial_from_plan"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TrialPeriodDays       *int64                                        `form:"trial_period_days"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CheckoutSessionSubscriptionDataParams is the set of parameters allowed for the subscription creation on a checkout session.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CodeVerificationFlow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CodeVerificationFlow struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	AttemptsRemaining int64                            `json:"attempts_remaining"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Status            SourceCodeVerificationFlowStatus `json:"status"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CodeVerificationFlow informs of the state of a verification authentication flow.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Country

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Country string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Country is the list of supported countries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CountrySpec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CountrySpec struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	DefaultCurrency                Currency                                        `json:"default_currency"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ID                             string                                          `json:"id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	SupportedBankAccountCurrencies map[Currency][]Country                          `json:"supported_bank_account_currencies"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	SupportedPaymentCurrencies     []Currency                                      `json:"supported_payment_currencies"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	SupportedPaymentMethods        []string                                        `json:"supported_payment_methods"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	SupportedTransferCountries     []string                                        `json:"supported_transfer_countries"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	VerificationFields             map[AccountBusinessType]*VerificationFieldsList `json:"verification_fields"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CountrySpec is the resource representing the rules required for a Stripe account. For more details see https://stripe.com/docs/api/#country_specs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CountrySpecList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CountrySpecList struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ListMeta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Data []*CountrySpec `json:"data"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CountrySpecList is a list of country specs as retrieved from a list endpoint.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CountrySpecListParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CountrySpecListParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ListParams `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CountrySpecListParams are the parameters allowed during CountrySpec listing.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CountrySpecParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CountrySpecParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Params `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CountrySpecParams are the parameters allowed during CountrySpec retrieval.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Coupon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Coupon struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	AmountOff        int64             `json:"amount_off"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Created          int64             `json:"created"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Currency         Currency          `json:"currency"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Deleted          bool              `json:"deleted"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Duration         CouponDuration    `json:"duration"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DurationInMonths int64             `json:"duration_in_months"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ID               string            `json:"id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Livemode         bool              `json:"livemode"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	MaxRedemptions   int64             `json:"max_redemptions"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Metadata         map[string]string `json:"metadata"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Name             string            `json:"name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	PercentOff       float64           `json:"percent_off"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	RedeemBy         int64             `json:"redeem_by"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TimesRedeemed    int64             `json:"times_redeemed"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Valid            bool              `json:"valid"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Coupon is the resource representing a Stripe coupon. For more details see https://stripe.com/docs/api#coupons.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Coupon) UnmarshalJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c *Coupon) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          UnmarshalJSON handles deserialization of a Coupon. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CouponDuration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CouponDuration string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CouponDuration is the list of allowed values for the coupon's duration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CouponDurationForever   CouponDuration = "forever"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CouponDurationOnce      CouponDuration = "once"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CouponDurationRepeating CouponDuration = "repeating"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              List of values that CouponDuration can take.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CouponList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CouponList struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ListMeta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Data []*Coupon `json:"data"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CouponList is a list of coupons as retrieved from a list endpoint.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CouponListParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CouponListParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ListParams   `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Created      *int64            `form:"created"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CreatedRange *RangeQueryParams `form:"created"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CouponListParams is the set of parameters that can be used when listing coupons. For more detail see https://stripe.com/docs/api#list_coupons.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CouponParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CouponParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Params           `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	AmountOff        *int64   `form:"amount_off"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Currency         *string  `form:"currency"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Duration         *string  `form:"duration"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	DurationInMonths *int64   `form:"duration_in_months"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	ID               *string  `form:"id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MaxRedemptions   *int64   `form:"max_redemptions"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Name             *string  `form:"name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	PercentOff       *float64 `form:"percent_off"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RedeemBy         *int64   `form:"redeem_by"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CouponParams is the set of parameters that can be used when creating a coupon. For more details see https://stripe.com/docs/api#create_coupon.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreditNote

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreditNote struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Amount                     int64                       `json:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Created                    int64                       `json:"created"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Currency                   Currency                    `json:"currency"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Customer                   *Customer                   `json:"customer"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CustomerBalanceTransaction *CustomerBalanceTransaction `json:"customer_balance_transaction"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	DiscountAmount             int64                       `json:"discount_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Invoice                    *Invoice                    `json:"invoice"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ID                         string                      `json:"id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Lines                      *CreditNoteLineItemList     `json:"lines"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Livemode                   bool                        `json:"livemode"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Memo                       string                      `json:"memo"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Metadata                   map[string]string           `json:"metadata"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Number                     string                      `json:"number"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Object                     string                      `json:"object"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	OutOfBandAmount            int64                       `json:"out_of_band_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	PDF                        string                      `json:"pdf"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Reason                     CreditNoteReason            `json:"reason"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Refund                     *Refund                     `json:"refund"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Status                     CreditNoteStatus            `json:"status"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Subtotal                   int64                       `json:"subtotal"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	TaxAmounts                 []*CreditNoteTaxAmount      `json:"tax_amounts"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Total                      int64                       `json:"total"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Type                       CreditNoteType              `json:"type"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	VoidedAt                   int64                       `json:"voided_at"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CreditNote is the resource representing a Stripe credit note. For more details see https://stripe.com/docs/api/credit_notes/object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*CreditNote) UnmarshalJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (i *CreditNote) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        UnmarshalJSON handles deserialization of a CreditNote. This custom unmarshaling is needed because the resulting property may be an id or the full struct if it was expanded.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreditNoteLineItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreditNoteLineItem struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Amount            int64                  `json:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Description       string                 `json:"description"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	DiscountAmount    int64                  `json:"discount_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ID                string                 `json:"id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	InvoiceLineItem   string                 `json:"invoice_line_item"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Livemode          bool                   `json:"livemode"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Object            string                 `json:"object"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Quantity          int64                  `json:"quantity"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TaxAmounts        []*CreditNoteTaxAmount `json:"tax_amounts"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TaxRates          []*TaxRate             `json:"tax_rates"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Type              CreditNoteLineItemType `json:"type"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	UnitAmount        int64                  `json:"unit_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	UnitAmountDecimal float64                `json:"unit_amount_decimal,string"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CreditNoteLineItem is the resource representing a Stripe credit note line item. For more details see https://stripe.com/docs/api/credit_notes/line_item

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreditNoteLineItemList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreditNoteLineItemList struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ListMeta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Data []*CreditNoteLineItem `json:"data"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CreditNoteLineItemList is a list of credit note line items as retrieved from a list endpoint.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreditNoteLineItemListParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreditNoteLineItemListParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ListParams `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// ID is the credit note ID to list line items for.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ID *string `form:"-"` // Goes in the URL
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CreditNoteLineItemListParams is the set of parameters that can be used when listing credit note line items.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreditNoteLineItemListPreviewParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreditNoteLineItemListPreviewParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ListParams      `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Amount          *int64                  `form:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	CreditAmount    *int64                  `form:"credit_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Invoice         *string                 `form:"invoice"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Lines           []*CreditNoteLineParams `form:"lines"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Memo            *string                 `form:"memo"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	OutOfBandAmount *int64                  `form:"out_of_band_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Reason          *string                 `form:"reason"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Refund          *string                 `form:"refund"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	RefundAmount    *int64                  `form:"refund_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CreditNoteLineItemListPreviewParams is the set of parameters that can be used when previewing a credit note's line items

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CreditNoteLineItemType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CreditNoteLineItemType string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CreditNoteLineItemType is the list of allowed values for the credit note line item's type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	CreditNoteLineItemTypeCustomLineItem  CreditNoteLineItemType = "custom_line_item"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	CreditNoteLineItemTypeInvoiceLineItem CreditNoteLineItemType = "invoice_line_item"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    List of values that CreditNoteType can take.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreditNoteLineParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CreditNoteLineParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Amount            *int64    `form:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Description       *string   `form:"description"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	InvoiceLineItem   *string   `form:"invoice_line_item"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Quantity          *int64    `form:"quantity"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	TaxRates          []*string `form:"tax_rates"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	UnitAmount        *int64    `form:"unit_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	UnitAmountDecimal *float64  `form:"unit_amount_decimal,high_precision"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Type              *string   `form:"type"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CreditNoteLineParams is the set of parameters that can be used for a line item when creating or previewing a credit note.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreditNoteList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreditNoteList struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ListMeta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Data []*CreditNote `json:"data"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CreditNoteList is a list of credit notes as retrieved from a list endpoint.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreditNoteListParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreditNoteListParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ListParams `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Customer   *string `form:"customer"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Invoice    *string `form:"invoice"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CreditNoteListParams is the set of parameters that can be used when listing credit notes. For more details see https://stripe.com/docs/api/credit_notes/list.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreditNoteParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CreditNoteParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Params          `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Amount          *int64                  `form:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	CreditAmount    *int64                  `form:"credit_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Invoice         *string                 `form:"invoice"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Lines           []*CreditNoteLineParams `form:"lines"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Memo            *string                 `form:"memo"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	OutOfBandAmount *int64                  `form:"out_of_band_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Reason          *string                 `form:"reason"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Refund          *string                 `form:"refund"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	RefundAmount    *int64                  `form:"refund_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CreditNoteParams is the set of parameters that can be used when creating or updating a credit note. For more details see https://stripe.com/docs/api/credit_notes/create, https://stripe.com/docs/api/credit_notes/update.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreditNotePreviewParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreditNotePreviewParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Params          `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Amount          *int64                  `form:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CreditAmount    *int64                  `form:"credit_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Invoice         *string                 `form:"invoice"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Lines           []*CreditNoteLineParams `form:"lines"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Memo            *string                 `form:"memo"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	OutOfBandAmount *int64                  `form:"out_of_band_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Reason          *string                 `form:"reason"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Refund          *string                 `form:"refund"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	RefundAmount    *int64                  `form:"refund_amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CreditNotePreviewParams is the set of parameters that can be used when previewing a credit note. For more details see https://stripe.com/docs/api/credit_notes/preview.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreditNoteReason

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CreditNoteReason string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CreditNoteReason is the reason why a given credit note was created.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CreditNoteReasonDuplicate             CreditNoteReason = "duplicate"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CreditNoteReasonFraudulent            CreditNoteReason = "fraudulent"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CreditNoteReasonOrderChange           CreditNoteReason = "order_change"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CreditNoteReasonProductUnsatisfactory CreditNoteReason = "product_unsatisfactory"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  List of values that CreditNoteReason can take.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreditNoteStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CreditNoteStatus string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CreditNoteStatus is the list of allowed values for the credit note's status.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CreditNoteStatusIssued CreditNoteStatus = "issued"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CreditNoteStatusVoid   CreditNoteStatus = "void"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      List of values that CreditNoteStatus can take.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreditNoteTaxAmount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CreditNoteTaxAmount struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Amount    int64    `json:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Inclusive bool     `json:"inclusive"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	TaxRate   *TaxRate `json:"tax_rate"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CreditNoteTaxAmount represent the tax amount applied to a credit note.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreditNoteType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreditNoteType string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CreditNoteType is the list of allowed values for the credit note's type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	CreditNoteTypePostPayment CreditNoteType = "post_payment"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	CreditNoteTypePrePayment  CreditNoteType = "pre_payment"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            List of values that CreditNoteType can take.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreditNoteVoidParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CreditNoteVoidParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Params `form:"*"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CreditNoteVoidParams is the set of parameters that can be used when voiding invoices.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Currency

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Currency string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Currency is the list of supported currencies. For more details see https://support.stripe.com/questions/which-currencies-does-stripe-support.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyAED Currency = "aed" // United Arab Emirates Dirham
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyAFN Currency = "afn" // Afghan Afghani
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyALL Currency = "all" // Albanian Lek
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyAMD Currency = "amd" // Armenian Dram
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyANG Currency = "ang" // Netherlands Antillean Gulden
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyAOA Currency = "aoa" // Angolan Kwanza
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyARS Currency = "ars" // Argentine Peso
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyAUD Currency = "aud" // Australian Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyAWG Currency = "awg" // Aruban Florin
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyAZN Currency = "azn" // Azerbaijani Manat
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyBAM Currency = "bam" // Bosnia & Herzegovina Convertible Mark
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyBBD Currency = "bbd" // Barbadian Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyBDT Currency = "bdt" // Bangladeshi Taka
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyBGN Currency = "bgn" // Bulgarian Lev
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyBIF Currency = "bif" // Burundian Franc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyBMD Currency = "bmd" // Bermudian Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyBND Currency = "bnd" // Brunei Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyBOB Currency = "bob" // Bolivian Boliviano
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyBRL Currency = "brl" // Brazilian Real
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyBSD Currency = "bsd" // Bahamian Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyBWP Currency = "bwp" // Botswana Pula
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyBZD Currency = "bzd" // Belize Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyCAD Currency = "cad" // Canadian Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyCDF Currency = "cdf" // Congolese Franc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyCHF Currency = "chf" // Swiss Franc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyCLP Currency = "clp" // Chilean Peso
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyCNY Currency = "cny" // Chinese Renminbi Yuan
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyCOP Currency = "cop" // Colombian Peso
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyCRC Currency = "crc" // Costa Rican Colón
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyCVE Currency = "cve" // Cape Verdean Escudo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyCZK Currency = "czk" // Czech Koruna
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyDJF Currency = "djf" // Djiboutian Franc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyDKK Currency = "dkk" // Danish Krone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyDOP Currency = "dop" // Dominican Peso
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyDZD Currency = "dzd" // Algerian Dinar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyEEK Currency = "eek" // Estonian Kroon
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyEGP Currency = "egp" // Egyptian Pound
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyETB Currency = "etb" // Ethiopian Birr
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyEUR Currency = "eur" // Euro
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyFJD Currency = "fjd" // Fijian Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyFKP Currency = "fkp" // Falkland Islands Pound
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyGBP Currency = "gbp" // British Pound
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyGEL Currency = "gel" // Georgian Lari
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyGIP Currency = "gip" // Gibraltar Pound
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyGMD Currency = "gmd" // Gambian Dalasi
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyGNF Currency = "gnf" // Guinean Franc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyGTQ Currency = "gtq" // Guatemalan Quetzal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyGYD Currency = "gyd" // Guyanese Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyHKD Currency = "hkd" // Hong Kong Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyHNL Currency = "hnl" // Honduran Lempira
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyHRK Currency = "hrk" // Croatian Kuna
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyHTG Currency = "htg" // Haitian Gourde
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyHUF Currency = "huf" // Hungarian Forint
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyIDR Currency = "idr" // Indonesian Rupiah
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyILS Currency = "ils" // Israeli New Sheqel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyINR Currency = "inr" // Indian Rupee
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyISK Currency = "isk" // Icelandic Króna
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyJMD Currency = "jmd" // Jamaican Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyJPY Currency = "jpy" // Japanese Yen
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyKES Currency = "kes" // Kenyan Shilling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyKGS Currency = "kgs" // Kyrgyzstani Som
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyKHR Currency = "khr" // Cambodian Riel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyKMF Currency = "kmf" // Comorian Franc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyKRW Currency = "krw" // South Korean Won
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyKYD Currency = "kyd" // Cayman Islands Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyKZT Currency = "kzt" // Kazakhstani Tenge
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyLAK Currency = "lak" // Lao Kip
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyLBP Currency = "lbp" // Lebanese Pound
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyLKR Currency = "lkr" // Sri Lankan Rupee
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyLRD Currency = "lrd" // Liberian Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyLSL Currency = "lsl" // Lesotho Loti
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyLTL Currency = "ltl" // Lithuanian Litas
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyLVL Currency = "lvl" // Latvian Lats
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyMAD Currency = "mad" // Moroccan Dirham
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyMDL Currency = "mdl" // Moldovan Leu
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyMGA Currency = "mga" // Malagasy Ariary
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyMKD Currency = "mkd" // Macedonian Denar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyMNT Currency = "mnt" // Mongolian Tögrög
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyMOP Currency = "mop" // Macanese Pataca
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyMRO Currency = "mro" // Mauritanian Ouguiya
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyMUR Currency = "mur" // Mauritian Rupee
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyMVR Currency = "mvr" // Maldivian Rufiyaa
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyMWK Currency = "mwk" // Malawian Kwacha
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyMXN Currency = "mxn" // Mexican Peso
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyMYR Currency = "myr" // Malaysian Ringgit
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyMZN Currency = "mzn" // Mozambican Metical
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyNAD Currency = "nad" // Namibian Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyNGN Currency = "ngn" // Nigerian Naira
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyNIO Currency = "nio" // Nicaraguan Córdoba
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyNOK Currency = "nok" // Norwegian Krone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyNPR Currency = "npr" // Nepalese Rupee
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyNZD Currency = "nzd" // New Zealand Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyPAB Currency = "pab" // Panamanian Balboa
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyPEN Currency = "pen" // Peruvian Nuevo Sol
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyPGK Currency = "pgk" // Papua New Guinean Kina
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyPHP Currency = "php" // Philippine Peso
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyPKR Currency = "pkr" // Pakistani Rupee
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyPLN Currency = "pln" // Polish Złoty
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyPYG Currency = "pyg" // Paraguayan Guaraní
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyQAR Currency = "qar" // Qatari Riyal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyRON Currency = "ron" // Romanian Leu
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyRSD Currency = "rsd" // Serbian Dinar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyRUB Currency = "rub" // Russian Ruble
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyRWF Currency = "rwf" // Rwandan Franc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencySAR Currency = "sar" // Saudi Riyal
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencySBD Currency = "sbd" // Solomon Islands Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencySCR Currency = "scr" // Seychellois Rupee
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencySEK Currency = "sek" // Swedish Krona
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencySGD Currency = "sgd" // Singapore Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencySHP Currency = "shp" // Saint Helenian Pound
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencySLL Currency = "sll" // Sierra Leonean Leone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencySOS Currency = "sos" // Somali Shilling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencySRD Currency = "srd" // Surinamese Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencySTD Currency = "std" // São Tomé and Príncipe Dobra
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencySVC Currency = "svc" // Salvadoran Colón
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencySZL Currency = "szl" // Swazi Lilangeni
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyTHB Currency = "thb" // Thai Baht
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyTJS Currency = "tjs" // Tajikistani Somoni
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyTOP Currency = "top" // Tongan Paʻanga
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyTRY Currency = "try" // Turkish Lira
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyTTD Currency = "ttd" // Trinidad and Tobago Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyTWD Currency = "twd" // New Taiwan Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyTZS Currency = "tzs" // Tanzanian Shilling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyUAH Currency = "uah" // Ukrainian Hryvnia
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyUGX Currency = "ugx" // Ugandan Shilling
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyUSD Currency = "usd" // United States Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyUYU Currency = "uyu" // Uruguayan Peso
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyUZS Currency = "uzs" // Uzbekistani Som
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyVEF Currency = "vef" // Venezuelan Bolívar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyVND Currency = "vnd" // Vietnamese Đồng
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyVUV Currency = "vuv" // Vanuatu Vatu
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyWST Currency = "wst" // Samoan Tala
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyXAF Currency = "xaf" // Central African Cfa Franc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyXCD Currency = "xcd" // East Caribbean Dollar
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyXOF Currency = "xof" // West African Cfa Franc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyXPF Currency = "xpf" // Cfp Franc
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyYER Currency = "yer" // Yemeni Rial
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyZAR Currency = "zar" // South African Rand
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CurrencyZMW Currency = "zmw" // Zambian Kwacha
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  List of values that Currency can take.