README

Go Stripe

GoDoc Build Status Coverage Status

The official Stripe Go client library.

Installation

Make sure your project is using Go Modules (it will have a go.mod file in its root if it already is):

go mod init

Then, reference stripe-go in a Go program with import:

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

Run any of the normal go commands (build/install/test). The Go toolchain will resolve and fetch the stripe-go module automatically.

Alternatively, you can also explicitly go get the package into a project:

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

Documentation

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

See video demonstrations covering how to use the library.

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/v72"
	"github.com/stripe/stripe-go/v72/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/v72"
	"github.com/stripe/stripe-go/v72/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/v72"
	"github.com/stripe/stripe-go/v72/$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/v72"
	"github.com/stripe/stripe-go/v72/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
}
Accessing the Last Response

Use LastResponse on any APIResource to look at the API response that generated the current object:

coupon, err := coupon.New(...)
requestID := coupon.LastResponse.RequestID

Similarly, for List operations, the last response is available on the list object attached to the iterator:

it := coupon.List(...)
for it.Next() {
    // Last response *NOT* on the individual iterator object
    it.Coupon().LastResponse // wrong

    // But rather on the list object, also accessible through the iterator
    requestID := it.CouponList().LastResponse.RequestID
}

See the definition of APIResponse for available fields.

Note that where API resources are nested in other API resources, only LastResponse on the top-level resource is set.

Automatic Retries

The library automatically retries requests on intermittent failures like on a connection error, timeout, or on certain API responses like a status 409 Conflict. Idempotency keys are always added to requests to make any such subsequent retries safe.

By default, it will perform up to two retries. That number can be configured with MaxNetworkRetries:

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

config := &stripe.BackendConfig{
    MaxNetworkRetries: stripe.Int64(0), // Zero retries
}

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(...)
Configuring Logging

By default, the library logs error messages only (which are sent to stderr). Configure default 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.

Expanding Objects

All expandable objects in stripe-go take the form of a full resource struct, but unless expansion is requested, only the ID field of that struct is populated. Expansion is requested by calling AddExpand on parameter structs. For example:

//
// *Without* expansion
//
c, _ := charge.Retrieve("ch_123", nil)

c.Customer.ID    // Only ID is populated
c.Customer.Name  // All other fields are always empty

//
// With expansion
//
p := &CustomerParams{}
p.AddExpand("customer")
c, _ := charge.Retrieve("ch_123", p)

c.Customer.ID    // ID is still available
c.Customer.Name  // Name is now also available (if it had a value)
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: stripe.Bool(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-08-27"

	// 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"

	// DefaultMaxNetworkRetries is the default maximum number of retries made
	// by a Stripe client.
	DefaultMaxNetworkRetries int64 = 2

	// 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`.

          View Source 
          var Key string

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

            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 APIResource 

                                                        type APIResource struct {
	LastResponse *APIResponse `json:"-"`
}

                                                          APIResource is a type assigned to structs that may come from Stripe API endpoints and contains facilities common to all of them.

                                                          func (*APIResource) SetLastResponse 

                                                          func (r *APIResource) SetLastResponse(response *APIResponse)

                                                            SetLastResponse sets the HTTP response that returned the API resource.

                                                            type APIResponse 

                                                            type APIResponse struct {
	// Header contain a map of all HTTP header keys to values. Its behavior and
	// caveats are identical to that of http.Header.
	Header http.Header

	// IdempotencyKey contains the idempotency key used with this request.
	// Idempotency keys are a Stripe-specific concept that helps guarantee that
	// requests that fail and need to be retried are not duplicated.
	IdempotencyKey string

	// RawJSON contains the response body as raw bytes.
	RawJSON []byte

	// RequestID contains a string that uniquely identifies the Stripe request.
	// Used for debugging or support purposes.
	RequestID string

	// Status is a status code and message. e.g. "200 OK"
	Status string

	// StatusCode is a status code as integer. e.g. 200
	StatusCode int
}

                                                              APIResponse encapsulates some common features of a response from the Stripe API.

                                                              type Account 

                                                              type Account struct {
	APIResource
	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"`
	SupportAddress     *AddressParams `form:"support_address"`
	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 {
	ACSSDebitPayments       AccountCapabilityStatus `json:"acss_debit_payments"`
	AUBECSDebitPayments     AccountCapabilityStatus `json:"au_becs_debit_payments"`
	BACSDebitPayments       AccountCapabilityStatus `json:"bacs_debit_payments"`
	BancontactPayments      AccountCapabilityStatus `json:"bancontact_payments"`
	CardIssuing             AccountCapabilityStatus `json:"card_issuing"`
	CardPayments            AccountCapabilityStatus `json:"card_payments"`
	CartesBancairesPayments AccountCapabilityStatus `json:"cartes_bancaires_payments"`
	EPSPayments             AccountCapabilityStatus `json:"eps_payments"`
	FPXPayments             AccountCapabilityStatus `json:"fpx_payments"`
	GiropayPayments         AccountCapabilityStatus `json:"giropay_payments"`
	GrabpayPayments         AccountCapabilityStatus `json:"grabpay_payments"`
	IdealPayments           AccountCapabilityStatus `json:"ideal_payments"`
	JCBPayments             AccountCapabilityStatus `json:"jcb_payments"`
	LegacyPayments          AccountCapabilityStatus `json:"legacy_payments"`
	OXXOPayments            AccountCapabilityStatus `json:"oxxo_payments"`
	P24Payments             AccountCapabilityStatus `json:"p24_payments"`
	SEPADebitPayments       AccountCapabilityStatus `json:"sepa_debit_payments"`
	SofortPayments          AccountCapabilityStatus `json:"sofort_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 AccountCapabilitiesACSSDebitPaymentsParams 

                                                                                type AccountCapabilitiesACSSDebitPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                  AccountCapabilitiesACSSDebitPaymentsParams represent allowed parameters to configure the ACSS Debit capability on an account.

                                                                                  type AccountCapabilitiesAUBECSDebitPaymentsParams 

                                                                                  type AccountCapabilitiesAUBECSDebitPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                    AccountCapabilitiesAUBECSDebitPaymentsParams represent allowed parameters to configure the AU BECS Debit capability on an account.

                                                                                    type AccountCapabilitiesBACSDebitPaymentsParams 

                                                                                    type AccountCapabilitiesBACSDebitPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                      AccountCapabilitiesBACSDebitPaymentsParams represent allowed parameters to configure the BACS Debit capability on an account.

                                                                                      type AccountCapabilitiesBancontactPaymentsParams 

                                                                                      type AccountCapabilitiesBancontactPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                        AccountCapabilitiesBancontactPaymentsParams represent allowed parameters to configure the bancontact payments capability on an account.

                                                                                        type AccountCapabilitiesCardIssuingParams 

                                                                                        type AccountCapabilitiesCardIssuingParams struct {
	Requested *bool `form:"requested"`
}

                                                                                          AccountCapabilitiesCardIssuingParams represent allowed parameters to configure the Issuing capability on an account.

                                                                                          type AccountCapabilitiesCardPaymentsParams 

                                                                                          type AccountCapabilitiesCardPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                            AccountCapabilitiesCardPaymentsParams represent allowed parameters to configure the card payments capability on an account.

                                                                                            type AccountCapabilitiesCartesBancairesPaymentsParams 

                                                                                            type AccountCapabilitiesCartesBancairesPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                              AccountCapabilitiesCartesBancairesPaymentsParams represent allowed parameters to configure the Cartes Bancaires payments capability on an account.

                                                                                              type AccountCapabilitiesEPSPaymentsParams 

                                                                                              type AccountCapabilitiesEPSPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                                AccountCapabilitiesEPSPaymentsParams represent allowed parameters to configure the EPS payments capability on an account.

                                                                                                type AccountCapabilitiesFPXPaymentsParams 

                                                                                                type AccountCapabilitiesFPXPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                                  AccountCapabilitiesFPXPaymentsParams represent allowed parameters to configure the FPX payments capability on an account.

                                                                                                  type AccountCapabilitiesGiropayPaymentsParams 

                                                                                                  type AccountCapabilitiesGiropayPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                                    AccountCapabilitiesGiropayPaymentsParams represent allowed parameters to configure the giropay payments capability on an account.

                                                                                                    type AccountCapabilitiesGrabpayPaymentsParams 

                                                                                                    type AccountCapabilitiesGrabpayPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                                      AccountCapabilitiesGrabpayPaymentsParams represent allowed parameters to configure the grabpay payments capability on an account.

                                                                                                      type AccountCapabilitiesIdealPaymentsParams 

                                                                                                      type AccountCapabilitiesIdealPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                                        AccountCapabilitiesIdealPaymentsParams represent allowed parameters to configure the ideal payments capability on an account.

                                                                                                        type AccountCapabilitiesJCBPaymentsParams 

                                                                                                        type AccountCapabilitiesJCBPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                                          AccountCapabilitiesJCBPaymentsParams represent allowed parameters to configure the JCB payments capability on an account.

                                                                                                          type AccountCapabilitiesLegacyPaymentsParams 

                                                                                                          type AccountCapabilitiesLegacyPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                                            AccountCapabilitiesLegacyPaymentsParams represent allowed parameters to configure the legacy payments capability on an account.

                                                                                                            type AccountCapabilitiesOXXOPaymentsParams 

                                                                                                            type AccountCapabilitiesOXXOPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                                              AccountCapabilitiesOXXOPaymentsParams represent allowed parameters to configure the OXXO capability on an account.

                                                                                                              type AccountCapabilitiesP24PaymentsParams 

                                                                                                              type AccountCapabilitiesP24PaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                                                AccountCapabilitiesP24PaymentsParams represent allowed parameters to configure the P24 payments capability on an account.

                                                                                                                type AccountCapabilitiesParams 

                                                                                                                type AccountCapabilitiesParams struct {
	ACSSDebitPayments       *AccountCapabilitiesACSSDebitPaymentsParams       `form:"acss_debit_payments"`
	AUBECSDebitPayments     *AccountCapabilitiesAUBECSDebitPaymentsParams     `form:"au_becs_debit_payments"`
	BACSDebitPayments       *AccountCapabilitiesBACSDebitPaymentsParams       `form:"bacs_debit_payments"`
	BancontactPayments      *AccountCapabilitiesBancontactPaymentsParams      `form:"bancontact_payments"`
	CardIssuing             *AccountCapabilitiesCardIssuingParams             `form:"card_issuing"`
	CardPayments            *AccountCapabilitiesCardPaymentsParams            `form:"card_payments"`
	CartesBancairesPayments *AccountCapabilitiesCartesBancairesPaymentsParams `form:"cartes_bancaires_payments"`
	EPSPayments             *AccountCapabilitiesEPSPaymentsParams             `form:"eps_payments"`
	FPXPayments             *AccountCapabilitiesFPXPaymentsParams             `form:"fpx_payments"`
	GiropayPayments         *AccountCapabilitiesGiropayPaymentsParams         `form:"giropay_payments"`
	GrabpayPayments         *AccountCapabilitiesGrabpayPaymentsParams         `form:"grabpay_payments"`
	IdealPayments           *AccountCapabilitiesIdealPaymentsParams           `form:"ideal_payments"`
	JCBPayments             *AccountCapabilitiesJCBPaymentsParams             `form:"jcb_payments"`
	LegacyPayments          *AccountCapabilitiesLegacyPaymentsParams          `form:"legacy_payments"`
	OXXOPayments            *AccountCapabilitiesOXXOPaymentsParams            `form:"oxxo_payments"`
	P24Payments             *AccountCapabilitiesP24PaymentsParams             `form:"p24_payments"`
	SEPADebitPayments       *AccountCapabilitiesSEPADebitPaymentsParams       `form:"sepa_debit_payments"`
	SofortPayments          *AccountCapabilitiesSofortPaymentsParams          `form:"sofort_payments"`
	TaxReportingUS1099K     *AccountCapabilitiesTaxReportingUS1099KParams     `form:"tax_reporting_us_1099_k"`
	TaxReportingUS1099MISC  *AccountCapabilitiesTaxReportingUS1099MISCParams  `form:"tax_reporting_us_1099_misc"`
	Transfers               *AccountCapabilitiesTransfersParams               `form:"transfers"`
}

                                                                                                                  AccountCapabilitiesParams represent allowed parameters to configure capabilities on an account.

                                                                                                                  type AccountCapabilitiesSEPADebitPaymentsParams 

                                                                                                                  type AccountCapabilitiesSEPADebitPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                                                    AccountCapabilitiesSEPADebitPaymentsParams represent allowed parameters to configure the SEPA Debit payments capability on an account.

                                                                                                                    type AccountCapabilitiesSofortPaymentsParams 

                                                                                                                    type AccountCapabilitiesSofortPaymentsParams struct {
	Requested *bool `form:"requested"`
}

                                                                                                                      AccountCapabilitiesSofortPaymentsParams represent allowed parameters to configure the sofort payments capability on an account.

                                                                                                                      type AccountCapabilitiesTaxReportingUS1099KParams 

                                                                                                                      type AccountCapabilitiesTaxReportingUS1099KParams struct {
	Requested *bool `form:"requested"`
}

                                                                                                                        AccountCapabilitiesTaxReportingUS1099KParams represent allowed parameters to configure the 1099-K capability on an account.

                                                                                                                        type AccountCapabilitiesTaxReportingUS1099MISCParams 

                                                                                                                        type AccountCapabilitiesTaxReportingUS1099MISCParams struct {
	Requested *bool `form:"requested"`
}

                                                                                                                          AccountCapabilitiesTaxReportingUS1099MISCParams represent allowed parameters to configure the 1099-Misc capability on an account.

                                                                                                                          type AccountCapabilitiesTransfersParams 

                                                                                                                          type AccountCapabilitiesTransfersParams struct {
	Requested *bool `form:"requested"`
}

                                                                                                                            AccountCapabilitiesTransfersParams represent allowed parameters to configure the transfers capability on an account.

                                                                                                                            type AccountCapability 

                                                                                                                            type AccountCapability string

                                                                                                                              AccountCapability maps to a given capability for an account. 

                                                                                                                              const (
	AccountCapabilityAUBECSDebitPayments     AccountCapability = "au_becs_debit_payments"
	AccountCapabilityBACSDebitPayments       AccountCapability = "bacs_debit_payments"
	AccountCapabilityBancontactPayments      AccountCapability = "bancontact_payments"
	AccountCapabilityCardIssuing             AccountCapability = "card_issuing"
	AccountCapabilityCardPayments            AccountCapability = "card_payments"
	AccountCapabilityCartesBancairesPayments AccountCapability = "cartes_bancaires_payments"
	AccountCapabilityEPSPayments             AccountCapability = "eps_payments"
	AccountCapabilityFPXPayments             AccountCapability = "fpx_payments"
	AccountCapabilityGiropayPayments         AccountCapability = "giropay_payments"
	AccountCapabilityGrabpayPayments         AccountCapability = "grabpay_payments"
	AccountCapabilityIdealPayments           AccountCapability = "ideal_payments"
	AccountCapabilityJCBPayments             AccountCapability = "jcb_payments"
	AccountCapabilityLegacyPayments          AccountCapability = "legacy_payments"
	AccountCapabilityOXXOPayments            AccountCapability = "oxxo_payments"
	AccountCapabilityP24Payments             AccountCapability = "p24_payments"
	AccountCapabilitySEPADebitPayments       AccountCapability = "sepa_debit_payments"
	AccountCapabilitySofortPayments          AccountCapability = "sofort_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"`
	RegistrationNumber string                      `json:"registration_number"`
	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"`
	RegistrationNumber *string                           `form:"registration_number"`
	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"
	AccountCompanyStructureLimitedLiabilityPartnership        AccountCompanyStructure = "limited_liability_partnership"
	AccountCompanyStructureMultiMemberLLC                     AccountCompanyStructure = "multi_member_llc"
	AccountCompanyStructurePrivateCompany                     AccountCompanyStructure = "private_company"
	AccountCompanyStructurePrivateCorporation                 AccountCompanyStructure = "private_corporation"
	AccountCompanyStructurePrivatePartnership                 AccountCompanyStructure = "private_partnership"
	AccountCompanyStructurePublicCompany                      AccountCompanyStructure = "public_company"
	AccountCompanyStructurePublicCorporation                  AccountCompanyStructure = "public_corporation"
	AccountCompanyStructurePublicPartnership                  AccountCompanyStructure = "public_partnership"
	AccountCompanyStructureSingleMemberLLC                    AccountCompanyStructure = "single_member_llc"
	AccountCompanyStructureSoleProprietorship                 AccountCompanyStructure = "sole_proprietorship"
	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 AccountDocumentsBankAccountOwnershipVerificationParams 

                                                                                                                                                            type AccountDocumentsBankAccountOwnershipVerificationParams struct {
	Files []*string `form:"files"`
}

                                                                                                                                                              AccountDocumentsBankAccountOwnershipVerificationParams represents the parameters allowed for passing bank account ownership verification documents on an account.

                                                                                                                                                              type AccountDocumentsCompanyLicenseParams 

                                                                                                                                                              type AccountDocumentsCompanyLicenseParams struct {
	Files []*string `form:"files"`
}

                                                                                                                                                                AccountDocumentsCompanyLicenseParams represents the parameters allowed for passing company license verification documents on an account.

                                                                                                                                                                type AccountDocumentsCompanyMemorandumOfAssociationParams 

                                                                                                                                                                type AccountDocumentsCompanyMemorandumOfAssociationParams struct {
	Files []*string `form:"files"`
}

                                                                                                                                                                  AccountDocumentsCompanyMemorandumOfAssociationParams represents the parameters allowed for passing company memorandum of association documents on an account.

                                                                                                                                                                  type AccountDocumentsCompanyMinisterialDecreeParams 

                                                                                                                                                                  type AccountDocumentsCompanyMinisterialDecreeParams struct {
	Files []*string `form:"files"`
}

                                                                                                                                                                    AccountDocumentsCompanyMinisterialDecreeParams represents the parameters allowed for passing company ministerial decree documents on an account.

                                                                                                                                                                    type AccountDocumentsCompanyRegistrationVerificationParams 

                                                                                                                                                                    type AccountDocumentsCompanyRegistrationVerificationParams struct {
	Files []*string `form:"files"`
}

                                                                                                                                                                      AccountDocumentsCompanyRegistrationVerificationParams represents the parameters allowed for passing company registration verification documents.

                                                                                                                                                                      type AccountDocumentsCompanyTaxIDVerificationParams 

                                                                                                                                                                      type AccountDocumentsCompanyTaxIDVerificationParams struct {
	Files []*string `form:"files"`
}

                                                                                                                                                                        AccountDocumentsCompanyTaxIDVerificationParams represents the parameters allowed for passing company tax id verification documents on an account.

                                                                                                                                                                        type AccountDocumentsParams 

                                                                                                                                                                        type AccountDocumentsParams struct {
	BankAccountOwnershipVerification *AccountDocumentsBankAccountOwnershipVerificationParams `form:"bank_account_ownership_verification"`
	CompanyLicense                   *AccountDocumentsCompanyLicenseParams                   `form:"company_license"`
	CompanyMemorandumOfAssocation    *AccountDocumentsCompanyMemorandumOfAssociationParams   `form:"company_memorandum_of_association"`
	CompanyMinisterialDecree         *AccountDocumentsCompanyMinisterialDecreeParams         `form:"company_ministerial_decree"`
	CompanyRegistrationVerification  *AccountDocumentsCompanyRegistrationVerificationParams  `form:"company_registration_verification"`
	CompanyTaxIDVerification         *AccountDocumentsCompanyTaxIDVerificationParams         `form:"company_tax_id_verification"`
}

                                                                                                                                                                          AccountDocumentsParams represents the parameters allowed for passing additional documents on an account.

                                                                                                                                                                          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 {
	APIResource
	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"`
	RefreshURL *string `form:"refresh_url"`
	ReturnURL  *string `form:"return_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 (
	AccountLinkTypeAccountOnboarding AccountLinkType = "account_onboarding"
	AccountLinkTypeAccountUpdate     AccountLinkType = "account_update"
)

                                                                                                                                                                                          List of values that AccountLinkType can take.

                                                                                                                                                                                          type AccountList 

                                                                                                                                                                                          type AccountList struct {
	APIResource
	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"`
	Capabilities    *AccountCapabilitiesParams    `form:"capabilities"`
	Company         *AccountCompanyParams         `form:"company"`
	Country         *string                       `form:"country"`
	DefaultCurrency *string                       `form:"default_currency"`
	Documents       *AccountDocumentsParams       `form:"documents"`
	Email           *string                       `form:"email"`
	ExternalAccount *AccountExternalAccountParams `form:"external_account"`
	Individual      *PersonParams                 `form:"individual"`
	Settings        *AccountSettingsParams        `form:"settings"`
	TOSAcceptance   *AccountTOSAcceptanceParams   `form:"tos_acceptance"`
	Type            *string                       `form:"type"`

	// This parameter is deprecated. Prefer using Capabilities instead.
	RequestedCapabilities []*string `form:"requested_capabilities"`
}

                                                                                                                                                                                                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 {
	BACSDebitPayments *AccountSettingsBACSDebitPayments `json:"bacs_debit_payments"`
	Branding          *AccountSettingsBranding          `json:"branding"`
	CardPayments      *AccountSettingsCardPayments      `json:"card_payments"`
	CardIssuing       *AccountSettingsCardIssuing       `json:"card_issuing"`
	Dashboard         *AccountSettingsDashboard         `json:"dashboard"`
	Payments          *AccountSettingsPayments          `json:"payments"`
	Payouts           *AccountSettingsPayouts           `json:"payouts"`
	SEPADebitPayments *AccountSettingsSEPADebitPayments `json:"sepa_debit_payments"`
}

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

                                                                                                                                                                                                                  type AccountSettingsBACSDebitPayments 

                                                                                                                                                                                                                  type AccountSettingsBACSDebitPayments struct {
	DisplayName string `json:"display_name"`
}

                                                                                                                                                                                                                    AccountSettingsBACSDebitPayments represents settings specific to the account’s charging via BACS Debit.

                                                                                                                                                                                                                    type AccountSettingsBACSDebitPaymentsParams 

                                                                                                                                                                                                                    type AccountSettingsBACSDebitPaymentsParams struct {
	DisplayName *string `form:"display_name"`
}

                                                                                                                                                                                                                      AccountSettingsBACSDebitPaymentsParams represent allowed parameters to configure settings specific to BACS Debit charging on the account.

                                                                                                                                                                                                                      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 AccountSettingsCardIssuing 

                                                                                                                                                                                                                          type AccountSettingsCardIssuing struct {
	TOSAcceptance *AccountTOSAcceptance `json:"tos_acceptance"`
}

                                                                                                                                                                                                                            AccountSettingsCardIssuing represents settings specific to card issuing on the account.

                                                                                                                                                                                                                            type AccountSettingsCardIssuingParams 

                                                                                                                                                                                                                            type AccountSettingsCardIssuingParams struct {
	TOSAcceptance *AccountTOSAcceptanceParams `form:"tos_acceptance"`
}

                                                                                                                                                                                                                              AccountSettingsCardIssuingParams represent allowed parameters relating to the acceptance of the terms of service agreement.

                                                                                                                                                                                                                              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 {
	BACSDebitPayments *AccountSettingsBACSDebitPaymentsParams `form:"bacs_debit_payments"`
	Branding          *AccountSettingsBrandingParams          `form:"branding"`
	CardIssuing       *AccountSettingsCardIssuingParams       `form:"card_issuing"`
	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 AccountSettingsSEPADebitPayments 

                                                                                                                                                                                                                                                type AccountSettingsSEPADebitPayments struct {
	CreditorID string `json:"creditor_id"`
}

                                                                                                                                                                                                                                                  AccountSettingsSEPADebitPayments represents settings specific to the account’s charging via SEPA Debit.

                                                                                                                                                                                                                                                  type AccountTOSAcceptance 

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

                                                                                                                                                                                                                                                    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"`
	ServiceAgreement *string `form:"service_agreement"`
}

                                                                                                                                                                                                                                                      AccountTOSAcceptanceParams represents tos_acceptance during account creation/updates.

                                                                                                                                                                                                                                                      type AccountTOSAcceptanceServiceAgreement 

                                                                                                                                                                                                                                                      type AccountTOSAcceptanceServiceAgreement string

                                                                                                                                                                                                                                                        AccountTOSAcceptanceServiceAgreement describes the TOS Service agreement of an account 

                                                                                                                                                                                                                                                        const (
	AccountTOSAcceptanceServiceAgreementFull      AccountTOSAcceptanceServiceAgreement = "full"
	AccountTOSAcceptanceServiceAgreementRecipient AccountTOSAcceptanceServiceAgreement = "recipient"
)

                                                                                                                                                                                                                                                          List of values that AccountTOSAcceptanceServiceAgreement can take.

                                                                                                                                                                                                                                                          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 {
	APIResource
	Created    int64  `json:"created"`
	Deleted    bool   `json:"deleted"`
	DomainName string `json:"domain_name"`
	ID         string `json:"id"`
	Livemode   bool   `json:"livemode"`
	Object     string `json:"object"`
}

                                                                                                                                                                                                                                                                        ApplePayDomain is the resource representing a Stripe ApplePayDomain object

                                                                                                                                                                                                                                                                        type ApplePayDomainList 

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

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

                                                                                                                                                                                                                                                                          type ApplePayDomainListParams 

                                                                                                                                                                                                                                                                          type ApplePayDomainListParams struct {
	ListParams `form:"*"`
	DomainName *string `form:"domain_name"`
}

                                                                                                                                                                                                                                                                            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"`
	Object string `json:"object"`
}

                                                                                                                                                                                                                                                                                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 {
	APIResource
	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 {
	APIResource
	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 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 LastResponseSetter) error
	CallRaw(method, path, key string, body *form.Values, params *Params, v LastResponseSetter) error
	CallMultipart(method, path, key, boundary string, body *bytes.Buffer, params *Params, v LastResponseSetter) error
	SetMaxNetworkRetries(maxNetworkRetries int64)
}

                                                                                                                                                                                                                                                                                                    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.
	//
	// This value is a pointer to allow us to differentiate an unset versus
	// empty value. Use stripe.Bool for an easy way to set this value.
	//
	// 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.
	//
	// Defaults to DefaultLeveledLogger.
	//
	// To set a logger that logs nothing, set this to a stripe.LeveledLogger
	// with a Level of LevelNull (simply setting this field to nil will not
	// work).
	LeveledLogger LeveledLoggerInterface

	// MaxNetworkRetries sets maximum number of times that the library will
	// retry requests that appear to have failed due to an intermittent
	// problem.
	//
	// This value is a pointer to allow us to differentiate an unset versus
	// empty value. Use stripe.Int64 for an easy way to set this value.
	//
	// Defaults to DefaultMaxNetworkRetries (2).
	MaxNetworkRetries *int64

	// URL is the base URL to use for API paths.
	//
	// This value is a pointer to allow us to differentiate an unset versus
	// empty value. Use stripe.String for an easy way to set this value.
	//
	// 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 int64
	// 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 LastResponseSetter) 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 LastResponseSetter) 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 LastResponseSetter) 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 LastResponseSetter) 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 int64)

                                                                                                                                                                                                                                                                                                                          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 {
	APIResource
	Available        []*Amount       `json:"available"`
	ConnectReserved  []*Amount       `json:"connect_reserved"`
	InstantAvailable []*Amount       `json:"instant_available"`
	Issuing          *BalanceDetails `json:"issuing"`
	Livemode         bool            `json:"livemode"`
	Object           string          `json:"object"`
	Pending          []*Amount       `json:"pending"`
}

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

                                                                                                                                                                                                                                                                                                                                    type BalanceDetails 

                                                                                                                                                                                                                                                                                                                                    type BalanceDetails struct {
	Available []*Amount `json:"available"`
}

                                                                                                                                                                                                                                                                                                                                      BalanceDetails is the resource representing details about a specific product's 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 (
	BalanceSourceTypeBankAccount BalanceSourceType = "bank_account"
	BalanceSourceTypeCard        BalanceSourceType = "card"
	BalanceSourceTypeFPX         BalanceSourceType = "fpx"
)

                                                                                                                                                                                                                                                                                                                                            List of values that BalanceSourceType can take.

                                                                                                                                                                                                                                                                                                                                            type BalanceTransaction 

                                                                                                                                                                                                                                                                                                                                            type BalanceTransaction struct {
	APIResource
	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"`
	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 {
	APIResource
	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:"-"`
	IssuingDispute       *IssuingDispute              `json:"-"`
	IssuingTransaction   *IssuingAuthorization        `json:"-"`
	Payout               *Payout                      `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"
	BalanceTransactionSourceTypeIssuingDispute       BalanceTransactionSourceType = "issuing.dispute"
	BalanceTransactionSourceTypeIssuingTransaction   BalanceTransactionSourceType = "issuing.transaction"
	BalanceTransactionSourceTypePayout               BalanceTransactionSourceType = "payout"
	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"
	BalanceTransactionTypeAnticipationRepayment           BalanceTransactionType = "anticipation_repayment"
	BalanceTransactionTypeApplicationFee                  BalanceTransactionType = "application_fee"
	BalanceTransactionTypeApplicationFeeRefund            BalanceTransactionType = "application_fee_refund"
	BalanceTransactionTypeCharge                          BalanceTransactionType = "charge"
	BalanceTransactionTypeContribution                    BalanceTransactionType = "contribution"
	BalanceTransactionTypeIssuingAuthorizationHold        BalanceTransactionType = "issuing_authorization_hold"
	BalanceTransactionTypeIssuingAuthorizationRelease     BalanceTransactionType = "issuing_authorization_release"
	BalanceTransactionTypeIssuingAuthorizationDispute     BalanceTransactionType = "issuing_dispute"
	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"
	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 {
	APIResource
	Account                *Account                           `json:"account"`
	AccountHolderName      string                             `json:"account_holder_name"`
	AccountHolderType      BankAccountAccountHolderType       `json:"account_holder_type"`
	AvailablePayoutMethods []BankAccountAvailablePayoutMethod `json:"available_payout_methods"`
	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"`
	Object                 string                             `json:"object"`
	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 BankAccountAvailablePayoutMethod 

                                                                                                                                                                                                                                                                                                                                                                                    type BankAccountAvailablePayoutMethod string

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

                                                                                                                                                                                                                                                                                                                                                                                      const (
	BankAccountAvailablePayoutMethodInstant  BankAccountAvailablePayoutMethod = "instant"
	BankAccountAvailablePayoutMethodStandard BankAccountAvailablePayoutMethod = "standard"
)

                                                                                                                                                                                                                                                                                                                                                                                        List of values that CardAvailablePayoutMethod can take.

                                                                                                                                                                                                                                                                                                                                                                                        type BankAccountList 

                                                                                                                                                                                                                                                                                                                                                                                        type BankAccountList struct {
	APIResource
	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 BillingPortalConfiguration 

                                                                                                                                                                                                                                                                                                                                                                                                          type BillingPortalConfiguration struct {
	APIResource
	Active           bool                                       `json:"active"`
	Application      string                                     `json:"application"`
	BusinessProfile  *BillingPortalConfigurationBusinessProfile `json:"business_profile"`
	Created          int64                                      `json:"created"`
	DefaultReturnURL string                                     `json:"default_return_url"`
	Features         *BillingPortalConfigurationFeatures        `json:"features"`
	ID               string                                     `json:"id"`
	IsDefault        bool                                       `json:"is_default"`
	Livemode         bool                                       `json:"livemode"`
	Object           string                                     `json:"object"`
	Updated          int64                                      `json:"updated"`
}

                                                                                                                                                                                                                                                                                                                                                                                                            BillingPortalConfiguration is a configuration that describes the functionality and behavior of a PortalSession. For more details see https://stripe.com/docs/api/customer_portal.

                                                                                                                                                                                                                                                                                                                                                                                                            func (*BillingPortalConfiguration) UnmarshalJSON 

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

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

                                                                                                                                                                                                                                                                                                                                                                                                              type BillingPortalConfigurationBusinessProfile 

                                                                                                                                                                                                                                                                                                                                                                                                              type BillingPortalConfigurationBusinessProfile struct {
	Headline          string `json:"headline"`
	PrivacyPolicyURL  string `json:"privacy_policy_url"`
	TermsOfServiceURL string `json:"terms_of_service_url"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                BillingPortalConfigurationBusinessProfile represents the business profile details on a portal configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                type BillingPortalConfigurationBusinessProfileParams 

                                                                                                                                                                                                                                                                                                                                                                                                                type BillingPortalConfigurationBusinessProfileParams struct {
	Headline          *string `form:"headline"`
	PrivacyPolicyURL  *string `form:"privacy_policy_url"`
	TermsOfServiceURL *string `form:"terms_of_service_url"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                  BillingPortalConfigurationBusinessProfileParams lets you pass the business profile details associated with a portal configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                  type BillingPortalConfigurationFeatures 

                                                                                                                                                                                                                                                                                                                                                                                                                  type BillingPortalConfigurationFeatures struct {
	CustomerUpdate      *BillingPortalConfigurationFeaturesCustomerUpdate      `json:"customer_update"`
	InvoiceHistory      *BillingPortalConfigurationFeaturesInvoiceHistory      `json:"invoice_history"`
	PaymentMethodUpdate *BillingPortalConfigurationFeaturesPaymentMethodUpdate `json:"payment_method_update"`
	SubscriptionCancel  *BillingPortalConfigurationFeaturesSubscriptionCancel  `json:"subscription_cancel"`
	SubscriptionPause   *BillingPortalConfigurationFeaturesSubscriptionPause   `json:"subscription_pause"`
	SubscriptionUpdate  *BillingPortalConfigurationFeaturesSubscriptionUpdate  `json:"subscription_update"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                    BillingPortalConfigurationFeatures represents details about the features enabled in the portal configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                    type BillingPortalConfigurationFeaturesCustomerUpdate 

                                                                                                                                                                                                                                                                                                                                                                                                                    type BillingPortalConfigurationFeaturesCustomerUpdate struct {
	AllowedUpdates []BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdate `json:"allowed_updates"`
	Enabled        bool                                                            `json:"enabled"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                      BillingPortalConfigurationFeaturesCustomerUpdate represents the customer update details on a portal configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                      type BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdate 

                                                                                                                                                                                                                                                                                                                                                                                                                      type BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdate string

                                                                                                                                                                                                                                                                                                                                                                                                                        BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdate describes a type of customer updates that may be supported on a portal configuration 

                                                                                                                                                                                                                                                                                                                                                                                                                        const (
	BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdateAddress  BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdate = "address"
	BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdateEmail    BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdate = "email"
	BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdatePhone    BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdate = "phone"
	BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdateShipping BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdate = "shipping"
	BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdateTaxID    BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdate = "tax_id"
)

                                                                                                                                                                                                                                                                                                                                                                                                                          List of values that BillingPortalConfigurationFeaturesCustomerUpdateAllowedUpdate can take.

                                                                                                                                                                                                                                                                                                                                                                                                                          type BillingPortalConfigurationFeaturesCustomerUpdateParams 

                                                                                                                                                                                                                                                                                                                                                                                                                          type BillingPortalConfigurationFeaturesCustomerUpdateParams struct {
	AllowedUpdates []*string `form:"allowed_updates"`
	Enabled        *bool     `form:"enabled"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                            BillingPortalConfigurationFeaturesCustomerUpdateParams lets you pass the customer update details on a portal configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                            type BillingPortalConfigurationFeaturesInvoiceHistory 

                                                                                                                                                                                                                                                                                                                                                                                                                            type BillingPortalConfigurationFeaturesInvoiceHistory struct {
	Enabled bool `json:"enabled"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                              BillingPortalConfigurationFeaturesInvoiceHistory represents the invoice history details on a portal configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                              type BillingPortalConfigurationFeaturesInvoiceHistoryParams 

                                                                                                                                                                                                                                                                                                                                                                                                                              type BillingPortalConfigurationFeaturesInvoiceHistoryParams struct {
	Enabled *bool `form:"enabled"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                                BillingPortalConfigurationFeaturesInvoiceHistoryParams lets you pass the invoice history details on a portal configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                type BillingPortalConfigurationFeaturesParams 

                                                                                                                                                                                                                                                                                                                                                                                                                                type BillingPortalConfigurationFeaturesParams struct {
	CustomerUpdate      *BillingPortalConfigurationFeaturesCustomerUpdateParams      `form:"customer_update"`
	InvoiceHistory      *BillingPortalConfigurationFeaturesInvoiceHistoryParams      `form:"invoice_history"`
	PaymentMethodUpdate *BillingPortalConfigurationFeaturesPaymentMethodUpdateParams `form:"payment_method_update"`
	SubscriptionCancel  *BillingPortalConfigurationFeaturesSubscriptionCancelParams  `form:"subscription_cancel"`
	SubscriptionPause   *BillingPortalConfigurationFeaturesSubscriptionPauseParams   `form:"subscription_pause"`
	SubscriptionUpdate  *BillingPortalConfigurationFeaturesSubscriptionUpdateParams  `form:"subscription_update"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                                  BillingPortalConfigurationFeaturesParams lets you pass details about the features available in the portal.

                                                                                                                                                                                                                                                                                                                                                                                                                                  type BillingPortalConfigurationFeaturesPaymentMethodUpdate 

                                                                                                                                                                                                                                                                                                                                                                                                                                  type BillingPortalConfigurationFeaturesPaymentMethodUpdate struct {
	Enabled bool `json:"enabled"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                                    BillingPortalConfigurationFeaturesPaymentMethodUpdate represents the payment method update details on a portal configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                    type BillingPortalConfigurationFeaturesPaymentMethodUpdateParams 

                                                                                                                                                                                                                                                                                                                                                                                                                                    type BillingPortalConfigurationFeaturesPaymentMethodUpdateParams struct {
	Enabled *bool `form:"enabled"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                                      BillingPortalConfigurationFeaturesPaymentMethodUpdateParams lets you pass the payment method update details on a portal configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                      type BillingPortalConfigurationFeaturesSubscriptionCancel 

                                                                                                                                                                                                                                                                                                                                                                                                                                      type BillingPortalConfigurationFeaturesSubscriptionCancel struct {
	Enabled           bool                                                                  `json:"enabled"`
	Mode              BillingPortalConfigurationFeaturesSubscriptionCancelMode              `json:"mode"`
	ProrationBehavior BillingPortalConfigurationFeaturesSubscriptionCancelProrationBehavior `json:"proration_behavior"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                                        BillingPortalConfigurationFeaturesSubscriptionCancel represents the subscription cancel details on a portal configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                        type BillingPortalConfigurationFeaturesSubscriptionCancelMode 

                                                                                                                                                                                                                                                                                                                                                                                                                                        type BillingPortalConfigurationFeaturesSubscriptionCancelMode string

                                                                                                                                                                                                                                                                                                                                                                                                                                          BillingPortalConfigurationFeaturesSubscriptionCancelMode describes whether to cancel subscriptions immediately or at the end of the billing period. 

                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
	BillingPortalConfigurationFeaturesSubscriptionCancelModeAtPeriodEnd BillingPortalConfigurationFeaturesSubscriptionCancelMode = "at_period_end"
	BillingPortalConfigurationFeaturesSubscriptionCancelModeImmediately BillingPortalConfigurationFeaturesSubscriptionCancelMode = "immediately"
)

                                                                                                                                                                                                                                                                                                                                                                                                                                            List of values that BillingPortalConfigurationFeaturesSubscriptionCancelMode can take.

                                                                                                                                                                                                                                                                                                                                                                                                                                            type BillingPortalConfigurationFeaturesSubscriptionCancelParams 

                                                                                                                                                                                                                                                                                                                                                                                                                                            type BillingPortalConfigurationFeaturesSubscriptionCancelParams struct {
	Enabled           *bool   `form:"enabled"`
	Mode              *string `form:"mode"`
	ProrationBehavior *string `form:"proration_behavior"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                                              BillingPortalConfigurationFeaturesSubscriptionCancelParams lets you pass the subscription cancel deetails on a portal configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                              type BillingPortalConfigurationFeaturesSubscriptionCancelProrationBehavior 

                                                                                                                                                                                                                                                                                                                                                                                                                                              type BillingPortalConfigurationFeaturesSubscriptionCancelProrationBehavior string

                                                                                                                                                                                                                                                                                                                                                                                                                                                BillingPortalConfigurationFeaturesSubscriptionCancelProrationBehavior describes whether to create prorations when canceling subscriptions. 

                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
	BillingPortalConfigurationFeaturesSubscriptionCancelProrationBehaviorAlwaysInvoice    BillingPortalConfigurationFeaturesSubscriptionCancelProrationBehavior = "always_invoice"
	BillingPortalConfigurationFeaturesSubscriptionCancelProrationBehaviorCreateProrations BillingPortalConfigurationFeaturesSubscriptionCancelProrationBehavior = "create_prorations"
	BillingPortalConfigurationFeaturesSubscriptionCancelProrationBehaviorNone             BillingPortalConfigurationFeaturesSubscriptionCancelProrationBehavior = "none"
)

                                                                                                                                                                                                                                                                                                                                                                                                                                                  List of values that BillingPortalConfigurationFeaturesSubscriptionCancelProrationBehavior can take.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type BillingPortalConfigurationFeaturesSubscriptionPause 

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type BillingPortalConfigurationFeaturesSubscriptionPause struct {
	Enabled bool `json:"enabled"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                                                    BillingPortalConfigurationFeaturesSubscriptionPause lets you pass pause details on the subscription update on a portal configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type BillingPortalConfigurationFeaturesSubscriptionPauseParams 

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type BillingPortalConfigurationFeaturesSubscriptionPauseParams struct {
	Enabled *bool `form:"enabled"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      BillingPortalConfigurationFeaturesSubscriptionPauseParams lets you pass details on the subscription pause on a portal configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type BillingPortalConfigurationFeaturesSubscriptionUpdate 

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type BillingPortalConfigurationFeaturesSubscriptionUpdate struct {
	DefaultAllowedUpdates []BillingPortalConfigurationFeaturesSubscriptionUpdateDefaultAllowedUpdate `json:"default_allowed_updates"`
	Enabled               bool                                                                       `json:"enabled"`
	Products              []*BillingPortalConfigurationFeaturesSubscriptionUpdateProduct             `json:"products"`
	ProrationBehavior     BillingPortalConfigurationFeaturesSubscriptionUpdateProrationBehavior      `json:"proration_behavior"`
}

                                                                                                                                                                                                                                                                                                                                                                                                                                                        BillingPortalConfigurationFeaturesSubscriptionUpdate represents the subscription update details on a portal configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type BillingPortalConfigurationFeaturesSubscriptionUpdateDefaultAllowedUpdate 

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type BillingPortalConfigurationFeaturesSubscriptionUpdateDefaultAllowedUpdate string

                                                                                                                                                                                                                                                                                                                                                                                                                                                          BillingPortalConfigurationFeaturesSubscriptionUpdateDefaultAllowedUpdate describes a type of subscription update that may be supported on a portal configuration. 

                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
	BillingPortalConfigurationFeaturesSubscriptionUpdateDefaultAllowedUpdatePrice         BillingPortalConfigurationFeaturesSubscriptionUpdateDefaultAllowedUpdate = "price"
	BillingPortalConfigurationFeaturesSubscriptionUpdateDefaultAllowedUpdatePromotionCode BillingPortalConfigurationFeaturesSubscriptionUpdateDefaultAllowedUpdate = "promotion_code"
	BillingPortalConfigurationFeaturesSubscriptionUpdateDefaultAllowedUpdateQuantity      BillingPortalConfigurationFeaturesSubscriptionUpdateDefaultAllowedUpd