stripe

package module
v35.5.0+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 22, 2018 License: MIT Imports: 24 Imported by: 0

README

Go Stripe

GoDoc Build Status Coverage Status

Summary

The official Stripe Go client library.

Versioning

Each revision of the binding is tagged and the version is updated accordingly.

Given Go's lack of built-in versioning, it is highly recommended you use a package management tool in order to ensure a newer version of the binding does not affect backwards compatibility.

To see the list of past versions, run git tag. To manually get an older version of the client, clone this repo, checkout the specific tag and build the library:

git clone https://github.com/stripe/stripe-go.git
cd stripe-go
git checkout api_version_tag
make build

For more details on changes between versions, see the binding changelog and API changelog.

Installation

go get github.com/stripe/stripe-go

Documentation

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

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

Below are a few simple examples:

Customers
params := &stripe.CustomerParams{
	Balance:     stripe.Int64(-123),
	Description: stripe.String("Stripe Developer"),
	Email:       stripe.String("gostripe@stripe.com"),
}
params.SetSource("tok_1234")

customer, err := customer.New(params)
Charges
params := &stripe.ChargeListParams{Customer: stripe.String(customer.ID)}
params.Filters.AddFilter("include[]", "", "total_count")

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

i := charge.List(params)
for i.Next() {
	charge := i.Charge()
}

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 even.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.ChargeListParams{}
listParams.SetStripeAccount("acct_123")

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

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


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

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

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

import (
	"fmt"
	"net/http"

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

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

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

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

        chargeParams := &stripe.ChargeParams{
            Amount:      stripe.Int64(2000),
            Currency:    stripe.String(string(stripe.CurrencyUSD)),
            Description: stripe.String("Charge from Google App Engine"),
        }
        chargeParams.SetSource("tok_amex") // obtained with Stripe.js
        charge, err := sc.Charges.New(chargeParams)
        if err != nil {
            fmt.Fprintf(w, "Could not process payment: %v", err)
        }
        fmt.Fprintf(w, "Completed payment: %v", charge.ID)
}

Usage

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

Without a Client

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

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

// Setup
stripe.Key = "sk_key"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

if err := i.Err(); err != nil {
	// handle
}
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.

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

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

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

Run all tests:

go 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"
)
View Source 
const (
	// 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/v1"

	// 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://uploads.stripe.com/v1"
)
View Source 
const (
	UsageRecordActionIncrement string = "increment"
	UsageRecordActionSet       string = "set"
)

Variables

View Source 
var Key string

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

View Source 
var LogLevel = 2

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

Functions

func Bool 

func Bool(v bool) *bool

Bool returns a pointer to the bool value passed in.

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 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 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 StringValue 

func StringValue(v *string) string

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

Types

type APIConnectionError 

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

APIConnectionError is a failure to connect to the Stripe API.

func (*APIConnectionError) Error 

func (e *APIConnectionError) Error() string

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

type APIError 

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

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

func (*APIError) Error 

func (e *APIError) Error() string

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

type Account 

type Account struct {
	BusinessName          string               `json:"business_name"`
	BusinessPrimaryColor  string               `json:"business_primary_color"`
	BusinessURL           string               `json:"business_url"`
	ChargesEnabled        bool                 `json:"charges_enabled"`
	Country               string               `json:"country"`
	DebitNegativeBalances bool                 `json:"debit_negative_balances"`
	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"`

	Keys *struct {
		Publishable string `json:"publishable"`
		Secret      string `json:"secret"`
	} `json:"keys"`

	LegalEntity               *LegalEntity      `json:"legal_entity"`
	Metadata                  map[string]string `json:"metadata"`
	DisplayName               string            `json:"display_name"`
	PayoutSchedule            *PayoutSchedule   `json:"payout_schedule"`
	PayoutStatementDescriptor string            `json:"payout_statement_descriptor"`
	PayoutsEnabled            bool              `json:"payouts_enabled"`
	ProductDescription        string            `json:"product_description"`
	StatementDescriptor       string            `json:"statement_descriptor"`
	SupportAddress            *Address          `json:"support_address"`
	SupportEmail              string            `json:"support_email"`
	SupportPhone              string            `json:"support_phone"`
	SupportURL                string            `json:"support_url"`
	Timezone                  string            `json:"timezone"`

	TOSAcceptance *struct {
		Date      int64  `json:"date"`
		IP        string `json:"ip"`
		UserAgent string `json:"user_agent"`
	} `json:"tos_acceptance"`

	Type AccountType `json:"type"`

	Verification *struct {
		DisabledReason IdentityVerificationDisabledReason `json:"disabled_reason"`
		DueBy          int64                              `json:"due_by"`
		FieldsNeeded   []string                           `json:"fields_needed"`
	} `json:"verification"`
}

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"`
}

Address 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 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 AccountList 

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

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

type AccountListParams 

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

AccountListParams are the parameters allowed during account listing.

type AccountParams 

type AccountParams struct {
	Params                    `form:"*"`
	AccountToken              *string                       `form:"account_token"`
	BusinessName              *string                       `form:"business_name"`
	BusinessPrimaryColor      *string                       `form:"business_primary_color"`
	BusinessURL               *string                       `form:"business_url"`
	Country                   *string                       `form:"country"`
	DebitNegativeBalances     *bool                         `form:"debit_negative_balances"`
	DefaultCurrency           *string                       `form:"default_currency"`
	Email                     *string                       `form:"email"`
	ExternalAccount           *AccountExternalAccountParams `form:"external_account"`
	FromRecipient             *string                       `form:"from_recipient"`
	LegalEntity               *LegalEntityParams            `form:"legal_entity"`
	PayoutSchedule            *PayoutScheduleParams         `form:"payout_schedule"`
	PayoutStatementDescriptor *string                       `form:"payout_statement_descriptor"`
	ProductDescription        *string                       `form:"product_description"`
	StatementDescriptor       *string                       `form:"statement_descriptor"`
	SupportEmail              *string                       `form:"support_email"`
	SupportPhone              *string                       `form:"support_phone"`
	SupportURL                *string                       `form:"support_url"`
	TOSAcceptance             *TOSAcceptanceParams          `form:"tos_acceptance"`
	Type                      *string                       `form:"type"`
}

AccountParams are the parameters allowed during account creation/updates.

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

type AccountType 

type AccountType string

AccountType is the type of an account. 

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

type AdditionalOwner 

type AdditionalOwner struct {
	Address                  *AccountAddress      `json:"address"`
	DOB                      DOB                  `json:"dob"`
	FirstName                string               `json:"first_name"`
	LastName                 string               `json:"last_name"`
	MaidenName               string               `json:"maiden_name"`
	PersonalIDNumberProvided bool                 `json:"personal_id_number_provided"`
	Verification             IdentityVerification `json:"verification"`
}

AdditionalOwner is the structure for an account owner.

type AdditionalOwnerParams 

type AdditionalOwnerParams struct {
	Address          *AccountAddressParams       `form:"address"`
	DOB              *DOBParams                  `form:"dob"`
	FirstName        *string                     `form:"first_name"`
	LastName         *string                     `form:"last_name"`
	MaidenName       *string                     `form:"maiden_name"`
	PersonalIDNumber *string                     `form:"personal_id_number"`
	Verification     *IdentityVerificationParams `form:"verification"`
}

AdditionalOwnerParams represents an additional owner during account creation/updates.

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"`
}

Standard address resource.

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"`
}

Standard address parameters.

type Amount 

type Amount struct {
	Value    int64    `json:"amount"`
	Currency Currency `json:"currency"`
}

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

type AppInfo 

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

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

type ApplePayDomain 

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

ApplePayDomain is the resource representing a Stripe ApplePayDomain object

type ApplePayDomainList 

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

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

type ApplePayDomainListParams 

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

ApplePayDomainListParams are the parameters allowed during ApplePayDomain listing.

type ApplePayDomainParams 

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

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

type Application 

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

func (*Application) UnmarshalJSON 

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

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

type ApplicationFee 

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

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

func (*ApplicationFee) UnmarshalJSON 

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

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

type ApplicationFeeList 

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

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

type ApplicationFeeListParams 

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

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

type ApplicationFeeParams 

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

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

type AuthenticationError 

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

AuthenticationError is a failure to properly authenticate during a request.

func (*AuthenticationError) Error 

func (e *AuthenticationError) Error() string

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

type Backend 

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

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

func GetBackend 

func GetBackend(backend SupportedBackend) Backend

GetBackend returns the currently used backend in the binding.

type BackendConfiguration 

type BackendConfiguration struct {
	Type              SupportedBackend
	URL               string
	HTTPClient        *http.Client
	MaxNetworkRetries int
}

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

func (*BackendConfiguration) Call 

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

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

func (*BackendConfiguration) CallMultipart 

func (s *BackendConfiguration) CallMultipart(method, path, key, boundary string, body io.Reader, params *Params, v interface{}) error

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

func (*BackendConfiguration) CallRaw 

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

func (*BackendConfiguration) Do 

func (s *BackendConfiguration) Do(req *http.Request, v interface{}) error

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

func (*BackendConfiguration) NewRequest 

func (s *BackendConfiguration) NewRequest(method, path, key, contentType string, body io.Reader, 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 (*BackendConfiguration) ResponseToError 

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

func (*BackendConfiguration) SetMaxNetworkRetries 

func (s *BackendConfiguration) SetMaxNetworkRetries(maxNetworkRetries int)

SetMaxNetworkRetries sets max number of retries on failed requests

type Backends 

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

Backends are the currently supported endpoints.

func NewBackends 

func NewBackends(httpClient *http.Client) *Backends

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

type Balance 

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

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

type BalanceParams 

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

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

type BalanceTransaction 

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

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

func (*BalanceTransaction) UnmarshalJSON 

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

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

type BalanceTransactionFee 

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

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

type BalanceTransactionList 

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

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

type BalanceTransactionListParams 

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

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

type BalanceTransactionParams 

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

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

type BalanceTransactionSource 

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

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

func (*BalanceTransactionSource) MarshalJSON 

func (s *BalanceTransactionSource) MarshalJSON() ([]byte, error)

MarshalJSON handles serialization of a BalanceTransactionSource.

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"
	BalanceTransactionSourceTypePayout            BalanceTransactionSourceType = "payout"
	BalanceTransactionSourceTypeRecipientTransfer BalanceTransactionSourceType = "recipient_transfer"
	BalanceTransactionSourceTypeRefund            BalanceTransactionSourceType = "refund"
	BalanceTransactionSourceTypeReversal          BalanceTransactionSourceType = "reversal"
	BalanceTransactionSourceTypeTransfer          BalanceTransactionSourceType = "transfer"
)

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

type BalanceTransactionType 

type BalanceTransactionType string

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

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

type BankAccount 

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

BankAccount represents a Stripe bank account.

func (*BankAccount) UnmarshalJSON 

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

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

type BankAccountAccountHolderType 

type BankAccountAccountHolderType string

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

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

type BankAccountList 

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

BankAccountList is a list object for bank accounts.

type BankAccountListParams 

type BankAccountListParams struct {
	ListParams `form:"*"`

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

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

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

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

type BitcoinReceiver 

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

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

func (*BitcoinReceiver) UnmarshalJSON 

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

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

type BitcoinReceiverList 

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

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

type BitcoinReceiverListParams 

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

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

type BitcoinReceiverParams 

type BitcoinReceiverParams struct {
	Params      `form:"*"`
	Amount      *int64  `form:"amount"`
	Currency    *string `form:"currency"`
	Description *string `form:"description"`
	Email       *string `form:"email"`
}

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

type BitcoinReceiverUpdateParams 

type BitcoinReceiverUpdateParams struct {
	Params        `form:"*"`
	Description   *string `form:"description"`
	Email         *string `form:"email"`
	RefundAddress *string `form:"refund_address"`
}

BitcoinReceiverUpdateParams is the set of parameters that can be used when updating a BitcoinReceiver. For more details see https://stripe.com/docs/api/#update_bitcoin_receiver.

type BitcoinTransaction 

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

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

func (*BitcoinTransaction) UnmarshalJSON 

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

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

type BitcoinTransactionList 

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

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

type BitcoinTransactionListParams 

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

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

type CaptureParams 

type CaptureParams struct {
	Params              `form:"*"`
	Amount              *int64   `form:"amount"`
	ApplicationFee      *int64   `form:"application_fee"`
	ExchangeRate        *float64 `form:"exchange_rate"`
	ReceiptEmail        *string  `form:"receipt_email"`
	StatementDescriptor *string  `form:"statement_descriptor"`
}

CaptureParams is the set of parameters that can be used when capturing a charge. For more details see https://stripe.com/docs/api#charge_capture.

type Card 

type Card struct {
	AddressCity        string           `json:"address_city"`
	AddressCountry     string           `json:"address_country"`
	AddressLine1       string           `json:"address_line1"`
	AddressLine1Check  CardVerification `json:"address_line1_check"`
	AddressLine2       string           `json:"address_line2"`
	AddressState       string           `json:"address_state"`
	AddressZip         string           `json:"address_zip"`
	AddressZipCheck    CardVerification `json:"address_zip_check"`
	Brand              CardBrand        `json:"brand"`
	CVCCheck           CardVerification `json:"cvc_check"`
	Country            string           `json:"country"`
	Currency           Currency         `json:"currency"`
	Customer           *Customer        `json:"customer"`
	DefaultForCurrency bool             `json:"default_for_currency"`
	Deleted            bool             `json:"deleted"`

	// Description is a succinct summary of the card's information.
	//
	// Please note that this field is for internal use only and is not returned
	// as part of standard API requests.
	Description string `json:"description"`

	DynamicLast4 string      `json:"dynamic_last4"`
	ExpMonth     uint8       `json:"exp_month"`
	ExpYear      uint16      `json:"exp_year"`
	Fingerprint  string      `json:"fingerprint"`
	Funding      CardFunding `json:"funding"`
	ID           string      `json:"id"`

	// IIN is the card's "Issuer Identification Number".
	//
	// Please note that this field is for internal use only and is not returned
	// as part of standard API requests.
	IIN string `json:"iin"`

	// Issuer is a bank or financial institution that provides the card.
	//
	// Please note that this field is for internal use only and is not returned
	// as part of standard API requests.
	Issuer string `json:"issuer"`

	Last4              string                 `json:"last4"`
	Metadata           map[string]string      `json:"metadata"`
	Name               string                 `json:"name"`
	Recipient          *Recipient             `json:"recipient"`
	ThreeDSecure       *ThreeDSecure          `json:"three_d_secure"`
	TokenizationMethod CardTokenizationMethod `json:"tokenization_method"`
}

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

func (*Card) UnmarshalJSON 

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

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

type CardBrand 

type CardBrand string

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

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

type CardError 

type CardError struct {
	DeclineCode string `json:"decline_code,omitempty"`
	// contains filtered or unexported fields
}

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

func (*CardError) Error 

func (e *CardError) Error() string

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

type CardFunding 

type CardFunding string

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

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

type CardList 

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

CardList is a list object for cards.

type CardListParams 

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

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

type CardParams 

type CardParams struct {
	Params             `form:"*"`
	Account            *string `form:"-"`
	AddressCity        *string `form:"address_city"`
	AddressCountry     *string `form:"address_country"`
	AddressLine1       *string `form:"address_line1"`
	AddressLine2       *string `form:"address_line2"`
	AddressState       *string `form:"address_state"`
	AddressZip         *string `form:"address_zip"`
	CVC                *string `form:"cvc"`
	Currency           *string `form:"currency"`
	Customer           *string `form:"-"`
	DefaultForCurrency *bool   `form:"default_for_currency"`
	ExpMonth           *string `form:"exp_month"`
	ExpYear            *string `form:"exp_year"`
	Name               *string `form:"name"`
	Number             *string `form:"number"`
	Recipient          *string `form:"-"`
	Token              *string `form:"-"`

	// ID is used when tokenizing a card for shared customers
	ID string `form:"*"`
}

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

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

func (*CardParams) AppendToAsCardSourceOrExternalAccount 

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

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

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

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

type CardTokenizationMethod 

type CardTokenizationMethod string

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

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

type CardVerification 

type CardVerification string

CardVerification is the list of allowed verification responses. 

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

type Charge 

type Charge struct {
	Amount              int64               `json:"amount"`
	AmountRefunded      int64               `json:"amount_refunded"`
	Application         *Application        `json:"application"`
	ApplicationFee      *ApplicationFee     `json:"application_fee"`
	BalanceTransaction  *BalanceTransaction `json:"balance_transaction"`
	Captured            bool                `json:"captured"`
	Created             int64               `json:"created"`
	Currency            Currency            `json:"currency"`
	Customer            *Customer           `json:"customer"`
	Description         string              `json:"description"`
	Destination         *Account            `json:"destination"`
	Dispute             *Dispute            `json:"dispute"`
	FailureCode         string              `json:"failure_code"`
	FailureMessage      string              `json:"failure_message"`
	FraudDetails        *FraudDetails       `json:"fraud_details"`
	ID                  string              `json:"id"`
	Invoice             *Invoice            `json:"invoice"`
	Livemode            bool                `json:"livemode"`
	Metadata            map[string]string   `json:"metadata"`
	Outcome             *ChargeOutcome      `json:"outcome"`
	Paid                bool                `json:"paid"`
	ReceiptEmail        string              `json:"receipt_email"`
	ReceiptNumber       string              `json:"receipt_number"`
	Refunded            bool                `json:"refunded"`
	Refunds             *RefundList         `json:"refunds"`
	Review              *Review             `json:"review"`
	Shipping            *ShippingDetails    `json:"shipping"`
	Source              *PaymentSource      `json:"source"`
	SourceTransfer      *Transfer           `json:"source_transfer"`
	StatementDescriptor string              `json:"statement_descriptor"`
	Status              string              `json:"status"`
	Transfer            *Transfer           `json:"transfer"`
	TransferGroup       string              `json:"transfer_group"`
}

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

Example (Get) 
package main

import (
	"log"

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

func main() {
	stripe.Key = "sk_key"

	params := &stripe.ChargeParams{}
	params.AddExpand("customer")
	params.AddExpand("application")
	params.AddExpand("balance_transaction")

	ch, err := charge.Get("ch_example_id", params)

	if err != nil {
		log.Fatal(err)
	}

	if ch.Application != nil {
		log.Fatal(err)
	}

	log.Printf("%v\n", ch.ID)
}

Output:
Example (New) 
package main

import (
	"log"

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

func main() {
	stripe.Key = "sk_key"

	params := &stripe.ChargeParams{
		Amount:   stripe.Int64(1000),
		Currency: stripe.String(string(stripe.CurrencyUSD)),
	}
	params.SetSource("tok_visa")
	params.AddMetadata("key", "value")

	ch, err := charge.New(params)

	if err != nil {
		log.Fatal(err)
	}

	log.Printf("%v\n", ch.ID)
}

Output:

func (*Charge) UnmarshalJSON 

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

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

type ChargeFraudStripeReport 

type ChargeFraudStripeReport string

ChargeFraudStripeReport is the list of allowed values for reporting fraud. 

const (
	ChargeFraudStripeReportFraudulent ChargeFraudStripeReport = "fraudulent"
)

type ChargeFraudUserReport 

type ChargeFraudUserReport string

ChargeFraudUserReport is the list of allowed values for reporting fraud. 

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

type ChargeList 

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

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

type ChargeListParams 

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

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

type ChargeOutcome 

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

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

type ChargeOutcomeRule 

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

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

func (*ChargeOutcomeRule) UnmarshalJSON 

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

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

type ChargeParams 

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

ChargeParams is the set of parameters that can be used when creating or updating a charge. For more details see https://stripe.com/docs/api#create_charge and https://stripe.com/docs/api#update_charge.

func (*ChargeParams) SetSource 

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

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

type CodeVerificationFlow 

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

CodeVerificationFlow informs of the state of a verification authentication flow.

type Country 

type Country string

Country is the list of supported countries

type CountrySpec 

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

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

type CountrySpecList 

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

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

type CountrySpecListParams 

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

CountrySpecListParams are the parameters allowed during CountrySpec listing.

type CountrySpecParams 

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

CountrySpecParams are the parameters allowed during CountrySpec retrieval.

type Coupon 

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

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

func (*Coupon) UnmarshalJSON 

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

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

type CouponDuration 

type CouponDuration string

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

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

type CouponList 

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

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

type CouponListParams 

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

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

type CouponParams 

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

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

type Currency 

type Currency string

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

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

type Customer 

type Customer struct {
	AccountBalance int64                    `json:"account_balance"`
	BusinessVATID  string                   `json:"business_vat_id"`
	Created        int64                    `json:"created"`
	Currency       Currency                 `json:"currency"`
	DefaultSource  *PaymentSource           `json:"default_source"`
	Deleted        bool                     `json:"deleted"`
	Delinquent     bool                     `json:"delinquent"`
	Description    string                   `json:"description"`
	Discount       *Discount                `json:"discount"`
	Email          string                   `json:"email"`
	ID             string                   `json:"id"`
	Livemode       bool                     `json:"livemode"`
	Metadata       map[string]string        `json:"metadata"`
	Shipping       *CustomerShippingDetails `json:"shipping"`
	Sources        *SourceList              `json:"sources"`
	Subscriptions  *SubscriptionList        `json:"subscriptions"`
}

Customer is the resource representing a Stripe customer. For more details see https://stripe.com/docs/api#customers.

Example (Delete) 
package main

import (
	"log"

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

func main() {
	stripe.Key = "sk_key"

	customerDel, err := customer.Del("cus_example_id", nil)

	if err != nil {
		log.Fatal(err)
	}

	if !customerDel.Deleted {
		log.Fatal("Customer doesn't appear deleted while it should be")
	}
}

Output:

func (*Customer) UnmarshalJSON 

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

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

type CustomerList 

type CustomerList struct {
	ListMeta
	Data []*Customer `json:"data"`
}

CustomerList is a list of customers as retrieved from a list endpoint.

type CustomerListParams 

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

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

type CustomerParams 

type CustomerParams struct {
	Params         `form:"*"`
	AccountBalance *int64                         `form:"account_balance"`
	BusinessVATID  *string                        `form:"business_vat_id"`
	Coupon         *string                        `form:"coupon"`
	DefaultSource  *string                        `form:"default_source"`
	Description    *string                        `form:"description"`
	Email          *string                        `form:"email"`
	Plan           *string                        `form:"plan"`
	Quantity       *int64                         `form:"quantity"`
	Shipping       *CustomerShippingDetailsParams `form:"shipping"`
	Source         *SourceParams                  `form:"*"` // SourceParams has custom encoding so brought to top level with "*"
	TaxPercent     *float64                       `form:"tax_percent"`
	Token          *string                        `form:"-"` // This doesn't seem to be used?
	TrialEnd       *int64                         `form:"trial_end"`
}

CustomerParams is the set of parameters that can be used when creating or updating a customer. For more details see https://stripe.com/docs/api#create_customer and https://stripe.com/docs/api#update_customer.

func (*CustomerParams) SetSource 

func (cp *CustomerParams) SetSource(sp interface{}) error

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

type CustomerShippingDetails 

type CustomerShippingDetails struct {
	Address Address `json:"address"`
	Name    string  `json:"name"`
	Phone   string  `json:"phone"`
}

CustomerShippingDetails is the structure containing shipping information.

type CustomerShippingDetailsParams 

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

CustomerShippingDetailsParams is the structure containing shipping information.

type CustomerSourceParams 

type CustomerSourceParams struct {
	Params   `form:"*"`
	Customer *string       `form:"-"` // Goes in the URL
	Source   *SourceParams `form:"*"` // SourceParams has custom encoding so brought to top level with "*"
}

CustomerSourceParams are used to manipulate a given Stripe Customer object's payment sources. For more details see https://stripe.com/docs/api#sources

func (*CustomerSourceParams) SetSource 

func (cp *CustomerSourceParams) SetSource(sp interface{}) error

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

type DOB 

type DOB struct {
	Day   int64 `json:"day"`
	Month int64 `json:"month"`
	Year  int64 `json:"year"`
}

DOB is a structure for an account owner's date of birth.

type DOBParams 

type DOBParams struct {
	Day   *int64 `form:"day"`
	Month *int64 `form:"month"`
	Year  *int64 `form:"year"`
}

DOBParams represents a DOB during account creation/updates.

type DeliveryEstimate 

type DeliveryEstimate struct {
	// If Type == Exact
	Date string `json:"date"`
	// If Type == Range
	Earliest string                    `json:"earliest"`
	Latest   string                    `json:"latest"`
	Type     OrderDeliveryEstimateType `json:"type"`
}

type DestinationParams 

type DestinationParams struct {
	Account *string `form:"account"`
	Amount  *int64  `form:"amount"`
}

type Discount 

type Discount struct {
	Coupon       *Coupon `json:"coupon"`
	Customer     string  `json:"customer"`
	Deleted      bool    `json:"deleted"`
	End          int64   `json:"end"`
	Start        int64   `json:"start"`
	Subscription string  `json:"subscription"`
}

Discount is the resource representing a Stripe discount. For more details see https://stripe.com/docs/api#discounts.

type DiscountParams 

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

DiscountParams is the set of parameters that can be used when deleting a discount.

type Dispute 

type Dispute struct {
	Amount              int64                 `json:"amount"`
	BalanceTransactions []*BalanceTransaction `json:"balance_transactions"`
	Charge              *Charge               `json:"charge"`
	Created             int64                 `json:"created"`
	Currency            Currency              `json:"currency"`
	Evidence            *DisputeEvidence      `json:"evidence"`
	EvidenceDetails     *EvidenceDetails      `json:"evidence_details"`
	ID                  string                `json:"id"`
	IsChargeRefundable  bool                  `json:"is_charge_refundable"`
	Livemode            bool                  `json:"livemode"`
	Metadata            map[string]string     `json:"metadata"`
	Reason              DisputeReason         `json:"reason"`
	Status              DisputeStatus         `json:"status"`
}

Dispute is the resource representing a Stripe dispute. For more details see https://stripe.com/docs/api#disputes.

func (*Dispute) UnmarshalJSON 

func (d *Dispute) UnmarshalJSON(data []byte) error

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

type DisputeEvidence 

type DisputeEvidence struct {
	AccessActivityLog            string      `json:"access_activity_log"`
	BillingAddress               string      `json:"billing_address"`
	CancellationPolicy           *FileUpload `json:"cancellation_policy"`
	CancellationPolicyDisclosure string      `json:"cancellation_policy_disclosure"`
	CancellationRebuttal         string      `json:"cancellation_rebuttal"`
	CustomerCommunication        *FileUpload `json:"customer_communication"`
	CustomerEmailAddress         string      `json:"customer_email_address"`
	CustomerName                 string      `json:"customer_name"`
	CustomerPurchaseIP           string      `json:"customer_purchase_ip"`
	CustomerSignature            *FileUpload `json:"customer_signature"`
	DuplicateChargeDocumentation *FileUpload `json:"duplicate_charge_documentation"`
	DuplicateChargeExplanation   string      `json:"duplicate_charge_explanation"`
	DuplicateChargeID            string      `json:"duplicate_charge_id"`
	ProductDescription           string      `json:"product_description"`
	Receipt                      *FileUpload `json:"receipt"`
	RefundPolicy                 *FileUpload `json:"refund_policy"`
	RefundPolicyDisclosure       string      `json:"refund_policy_disclosure"`
	RefundRefusalExplanation     string      `json:"refund_refusal_explanation"`
	ServiceDate                  string      `json:"service_date"`
	ServiceDocumentation         *FileUpload `json:"service_documentation"`
	ShippingAddress              string      `json:"shipping_address"`
	ShippingCarrier              string      `json:"shipping_carrier"`
	ShippingDate                 string      `json:"shipping_date"`
	ShippingDocumentation        *FileUpload `json:"shipping_documentation"`
	ShippingTrackingNumber       string      `json:"shipping_tracking_number"`
	UncategorizedFile            *FileUpload `json:"uncategorized_file"`
	UncategorizedText            string      `json:"uncategorized_text"`
}

DisputeEvidence is the structure that contains various details about the evidence submitted for the dispute. Almost all fields are strings since there structures (i.e. address) do not typically get parsed by anyone and are thus presented as-received.

type DisputeEvidenceParams 

type DisputeEvidenceParams struct {
	AccessActivityLog            *string `form:"access_activity_log"`
	BillingAddress               *string `form:"billing_address"`
	CancellationPolicy           *string `form:"cancellation_policy"`
	CancellationPolicyDisclosure *string `form:"cancellation_policy_disclosure"`
	CancellationRebuttal         *string `form:"cancellation_rebuttal"`
	CustomerCommunication        *string `form:"customer_communication"`
	CustomerEmailAddress         *string `form:"customer_email_address"`
	CustomerName                 *string `form:"customer_name"`
	CustomerPurchaseIP           *string `form:"customer_purchase_ip"`
	CustomerSignature            *string `form:"customer_signature"`
	DuplicateChargeDocumentation *string `form:"duplicate_charge_documentation"`
	DuplicateChargeExplanation   *string `form:"duplicate_charge_explanation"`
	DuplicateChargeID            *string `form:"duplicate_charge_id"`
	ProductDescription           *string `form:"product_description"`
	Receipt                      *string `form:"receipt"`
	RefundPolicy                 *string `form:"refund_policy"`
	RefundPolicyDisclosure       *string `form:"refund_policy_disclosure"`
	RefundRefusalExplanation     *string `form:"refund_refusal_explanation"`
	ServiceDate                  *string `form:"service_date"`
	ServiceDocumentation         *string `form:"service_documentation"`
	ShippingAddress              *string `form:"shipping_address"`
	ShippingCarrier              *string `form:"shipping_carrier"`
	ShippingDate                 *string `form:"shipping_date"`
	ShippingDocumentation        *string `form:"shipping_documentation"`
	ShippingTrackingNumber       *string `form:"shipping_tracking_number"`
	UncategorizedFile            *string `form:"uncategorized_file"`
	UncategorizedText            *string `form:"uncategorized_text"`
}

DisputeEvidenceParams is the set of parameters that can be used when submitting evidence for disputes.

type DisputeList 

type DisputeList struct {
	ListMeta
	Data []*Dispute `json:"data"`
}

DisputeList is a list of disputes as retrieved from a list endpoint.

type DisputeListParams 

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

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

type DisputeParams 

type DisputeParams struct {
	Params   `form:"*"`
	Evidence *DisputeEvidenceParams `form:"evidence"`
	Submit   *bool                  `form:"submit"`
}

DisputeParams is the set of parameters that can be used when updating a dispute. For more details see https://stripe.com/docs/api#update_dispute.

type DisputeReason 

type DisputeReason string

DisputeReason is the list of allowed values for a discount's reason. 

const (
	DisputeReasonCreditNotProcessed   DisputeReason = "credit_not_processed"
	DisputeReasonDuplicate            DisputeReason = "duplicate"
	DisputeReasonFraudulent           DisputeReason = "fraudulent"
	DisputeReasonGeneral              DisputeReason = "general"
	DisputeReasonProductNotReceived   DisputeReason = "product_not_received"
	DisputeReasonProductUnacceptable  DisputeReason = "product_unacceptable"
	DisputeReasonSubscriptionCanceled DisputeReason = "subscription_canceled"
	DisputeReasonUnrecognized         DisputeReason = "unrecognized"
)

type DisputeStatus 

type DisputeStatus string

DisputeStatus is the list of allowed values for a discount's status. 

const (
	DisputeStatusChargeRefunded       DisputeStatus = "charge_refunded"
	DisputeStatusLost                 DisputeStatus = "lost"
	DisputeStatusNeedsResponse        DisputeStatus = "needs_response"
	DisputeStatusUnderReview          DisputeStatus = "under_review"
	DisputeStatusWarningClosed        DisputeStatus = "warning_closed"
	DisputeStatusWarningNeedsResponse DisputeStatus = "warning_needs_response"
	DisputeStatusWarningUnderReview   DisputeStatus = "warning_under_review"
	DisputeStatusWon                  DisputeStatus = "won"
)

type EphemeralKey 

type EphemeralKey struct {
	AssociatedObjects []struct {
		ID   string `json:"id"`
		Type string `json:"type"`
	} `json:"associated_objects"`

	Created  int64  `json:"created"`
	Expires  int64  `json:"expires"`
	ID       string `json:"id"`
	Livemode bool   `json:"livemode"`

	// RawJSON is provided so that it may be passed back to the frontend
	// unchanged.  Ephemeral keys are issued on behalf of another client which
	// may be running a different version of the bindings and thus expect a
	// different JSON structure.  This ensures that if the structure differs
	// from the version of these bindings, we can still pass back a compatible
	// key.
	RawJSON []byte `json:"-"`
}

EphemeralKey is the resource representing a Stripe ephemeral key. For more details see https://stripe.com/docs/api#ephemeral_keys.

func (*EphemeralKey) UnmarshalJSON 

func (e *EphemeralKey) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of an EphemeralKey. This custom unmarshaling is needed because we need to store the raw JSON on the object so it may be passed back to the frontend.

type EphemeralKeyParams 

type EphemeralKeyParams struct {
	Params        `form:"*"`
	Customer      *string `form:"customer"`
	StripeVersion *string `form:"-"` // This goes in the `Stripe-Version` header
}

EphemeralKeyParams is the set of parameters that can be used when creating an ephemeral key. For more details see https://stripe.com/docs/api#ephemeral_keys.

type Error 

type Error struct {
	ChargeID string    `json:"charge,omitempty"`
	Code     ErrorCode `json:"code,omitempty"`

	// Err contains an internal error with an additional level of granularity
	// that can be used in some cases to get more detailed information about
	// what went wrong. For example, Err may hold a ChargeError that indicates
	// exactly what went wrong during a charge.
	Err error `json:"-"`

	HTTPStatusCode int       `json:"status,omitempty"`
	Msg            string    `json:"message"`
	Param          string    `json:"param,omitempty"`
	RequestID      string    `json:"request_id,omitempty"`
	Type           ErrorType `json:"type"`
}

Error is the response returned when a call is unsuccessful. For more details see https://stripe.com/docs/api#errors.

func (*Error) Error 

func (e *Error) Error() string

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

type ErrorCode 

type ErrorCode string

ErrorCode is the list of allowed values for the error's code. 

const (
	ErrorCodeCardDeclined       ErrorCode = "card_declined"
	ErrorCodeExpiredCard        ErrorCode = "expired_card"
	ErrorCodeIncorrectCVC       ErrorCode = "incorrect_cvc"
	ErrorCodeIncorrectZip       ErrorCode = "incorrect_zip"
	ErrorCodeIncorrectNumber    ErrorCode = "incorrect_number"
	ErrorCodeInvalidCVC         ErrorCode = "invalid_cvc"
	ErrorCodeInvalidExpiryMonth ErrorCode = "invalid_expiry_month"
	ErrorCodeInvalidExpiryYear  ErrorCode = "invalid_expiry_year"
	ErrorCodeInvalidNumber      ErrorCode = "invalid_number"
	ErrorCodeInvalidSwipeData   ErrorCode = "invalid_swipe_data"
	ErrorCodeMissing            ErrorCode = "missing"
	ErrorCodeProcessingError    ErrorCode = "processing_error"
	ErrorCodeRateLimit          ErrorCode = "rate_limit"
)

type ErrorType 

type ErrorType string

ErrorType is the list of allowed values for the error's type. 

const (
	ErrorTypeAPI            ErrorType = "api_error"
	ErrorTypeAPIConnection  ErrorType = "api_connection_error"
	ErrorTypeAuthentication ErrorType = "authentication_error"
	ErrorTypeCard           ErrorType = "card_error"
	ErrorTypeInvalidRequest ErrorType = "invalid_request_error"
	ErrorTypePermission     ErrorType = "more_permissions_required"
	ErrorTypeRateLimit      ErrorType = "rate_limit_error"
)

type Event 

type Event struct {
	Account         string        `json:"account"`
	Created         int64         `json:"created"`
	Data            *EventData    `json:"data"`
	ID              string        `json:"id"`
	Livemode        bool          `json:"livemode"`
	PendingWebhooks int64         `json:"pending_webhooks"`
	Request         *EventRequest `json:"request"`
	Type            string        `json:"type"`
}

Event is the resource representing a Stripe event. For more details see https://stripe.com/docs/api#events.

func (*Event) GetObjectValue 

func (e *Event) GetObjectValue(keys ...string) string

GetObjectValue returns the value from the e.Data.Object bag based on the keys hierarchy.

func (*Event) GetPreviousValue 

func (e *Event) GetPreviousValue(keys ...string) string

GetPreviousValue returns the value from the e.Data.Prev bag based on the keys hierarchy.

type EventData 

type EventData struct {
	Object             map[string]interface{}
	PreviousAttributes map[string]interface{} `json:"previous_attributes"`
	Raw                json.RawMessage        `json:"object"`
}

EventData is the unmarshalled object as a map.

func (*EventData) UnmarshalJSON 

func (e *EventData) UnmarshalJSON(data []byte) error

UnmarshalJSON handles deserialization of the EventData. This custom unmarshaling exists so that we can keep both the map and raw data.

type EventList 

type EventList struct {
	ListMeta
	Data []*Event `json:"data"`
}

EventList is a list of events as retrieved from a list endpoint.

type EventListParams 

type EventListParams struct {
	ListParams   `form:"*"`
	Created      *int64            `form:"created"`
	CreatedRange *RangeQueryParams `form:"created"`
	Type         *string           `form:"type"`
	Types        []*string         `form:"types"`
}

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

type EventParams 

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

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

type EventRequest 

type EventRequest struct {
	// ID is the request ID of the request that created an event, if the event
	// was created by a request.
	ID string `json:"id"`

	// IdempotencyKey is the idempotency key of the request that created an
	// event, if the event was created by a request and if an idempotency key
	// was specified for that request.
	IdempotencyKey string `json:"idempotency_key"`
}

EventRequest contains information on a request that created an event.

type EvidenceDetails 

type EvidenceDetails struct {
	DueBy           int64 `json:"due_by"`
	HasEvidence     bool  `json:"has_evidence"`
	PastDue         bool  `json:"past_due"`
	SubmissionCount int64 `json:"submission_count"`
}

EvidenceDetails is the structure representing more details about the dispute.

type ExchangeRate 

type ExchangeRate struct {
	ID    string               `json:"id"`
	Rates map[Currency]float64 `json:"rates"`
}

ExchangeRate is the resource representing the currency exchange rates at a given time.

type ExchangeRateList 

type ExchangeRateList struct {
	ListMeta
	Data []*ExchangeRate `json:"data"`
}

ExchangeRateList is a list of exchange rates as retrieved from a list endpoint.

type ExchangeRateListParams 

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

ExchangeRateListParams are the parameters allowed during ExchangeRate listing.

type ExchangeRateParams 

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

ExchangeRateParams is the set of parameters that can be used when retrieving exchange rates.

type ExternalAccount 

type ExternalAccount struct {
	// BankAccount is a bank account attached to an account. Populated only if
	// the external account is a bank account.
	BankAccount *BankAccount

	// Card is a card attached to an account. Populated only if the external
	// account is a card.
	Card *Card

	ID   string              `json:"id"`
	Type ExternalAccountType `json:"object"`
}

ExternalAccount is an external account (a bank account or card) that's attached to an account. It contains fields that will be conditionally populated depending on its type.

func (*ExternalAccount) UnmarshalJSON 

func (ea *ExternalAccount) UnmarshalJSON(data []byte) error

UnmarshalJSON implements Unmarshaler.UnmarshalJSON.

type ExternalAccountList 

type ExternalAccountList struct {
	ListMeta

	// Values contains any external accounts (bank accounts and/or cards)
	// currently attached to this account.
	Data []*ExternalAccount `json:"data"`
}

ExternalAccountList is a list of external accounts that may be either bank accounts or cards.

type ExternalAccountType 

type ExternalAccountType string

ExternalAccountType is the type of an external account. 

const (
	ExternalAccountTypeBankAccount ExternalAccountType = "bank_account"
	ExternalAccountTypeCard        ExternalAccountType = "card"
)

type ExtraValues 

type ExtraValues struct {
	url.Values `form:"-"` // See custom AppendTo implementation
}

ExtraValues are extra parameters that are attached to an API request. They're implemented as a custom type so that they can have their own AppendTo implementation.

func (ExtraValues) AppendTo 

func (v ExtraValues) AppendTo(body *form.Values, keyParts []string)

AppendTo implements custom form encoding for extra parameter values.

type FeeRefund 

type FeeRefund struct {
	Amount             int64               `json:"amount"`
	BalanceTransaction *BalanceTransaction `json:"balance_transaction"`
	Created            int64               `json:"created"`
	Currency           Currency            `json:"currency"`
	Fee                string              `json:"fee"`
	ID                 string              `json:"id"`
	Metadata           map[string]string   `json:"metadata"`
}

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

func (*FeeRefund) UnmarshalJSON 

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

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

type FeeRefundList 

type FeeRefundList struct {
	ListMeta
	Data []*FeeRefund `json:"data"`
}

FeeRefundList is a list object for application fee refunds.

type FeeRefundListParams 

type FeeRefundListParams struct {
	ListParams     `form:"*"`
	ApplicationFee *string `form:"-"` // Included in the URL
}

FeeRefundListParams is the set of parameters that can be used when listing application fee refunds. For more details see https://stripe.com/docs/api#list_fee_refunds.

type FeeRefundParams 

type FeeRefundParams struct {
	Params         `form:"*"`
	Amount         *int64  `form:"amount"`
	ApplicationFee *string `form:"-"` // Included in the URL
}

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

type FileUpload 

type FileUpload struct {
	Created int64             `json:"created"`
	ID      string            `json:"id"`
	Purpose FileUploadPurpose `json:"purpose"`
	Size    int64             `json:"size"`
	Type    string            `json:"type"`
	URL     string            `json:"url"`
}

FileUpload is the resource representing a Stripe file upload. For more details see https://stripe.com/docs/api#file_uploads.

func (*FileUpload) UnmarshalJSON 

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

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

type FileUploadList 

type FileUploadList struct {
	ListMeta
	Data []*FileUpload `json:"data"`
}

FileUploadList is a list of file uploads as retrieved from a list endpoint.

type FileUploadListParams 

type FileUploadListParams struct {
	ListParams   `form:"*"`
	Created      *int64            `form:"created"`
	CreatedRange *RangeQueryParams `form:"created"`
	Purpose      *string           `form:"purpose"`
}

FileUploadListParams is the set of parameters that can be used when listing file uploads. For more details see https://stripe.com/docs/api#list_file_uploads.

type FileUploadParams 

type FileUploadParams struct {
	Params `form:"*"`

	// FileReader is a reader with the contents of the file that should be uploaded.
	FileReader io.Reader

	// Filename is just the name of the file without path information.
	Filename *string

	Purpose *string
}

FileUploadParams is the set of parameters that can be used when creating a file upload. For more details see https://stripe.com/docs/api#create_file_upload.

func (*FileUploadParams) AppendDetails 

func (f *FileUploadParams) AppendDetails(body io.ReadWriter) (string, error)

AppendDetails adds the file upload details to an io.ReadWriter. It returns the boundary string for a multipart/form-data request and an error (if one exists).

type FileUploadPurpose 

type FileUploadPurpose string

FileUploadPurpose is the purpose of a particular file upload. 

const (
	FileUploadPurposeDisputeEvidence  FileUploadPurpose = "dispute_evidence"
	FileUploadPurposeIdentityDocument FileUploadPurpose = "identity_document"
)

type Filters 

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

Filters is a structure that contains a collection of filters for list-related APIs.

func (*Filters) AddFilter 

func (f *Filters) AddFilter(key, op, value string)

AddFilter adds a new filter with a given key, op and value.

func (Filters) AppendTo 

func (f Filters) AppendTo(body *form.Values, keyParts []string)

AppendTo implements custom form encoding for filters.

type FraudDetails 

type FraudDetails struct {
	UserReport   ChargeFraudUserReport   `json:"user_report"`
	StripeReport ChargeFraudStripeReport `json:"stripe_report"`
}

FraudDetails is the structure detailing fraud status.

type FraudDetailsParams 

type FraudDetailsParams struct {
	UserReport *string `form:"user_report"`
}

FraudDetailsParams provides information on the fraud details for a charge.

type IdentityVerification 

type IdentityVerification struct {
	Details      string                          `json:"details"`
	DetailsCode  IdentityVerificationDetailsCode `json:"details_code"`
	Document     *FileUpload                     `json:"document"`
	DocumentBack *FileUpload                     `json:"document_back"`
	Status       IdentityVerificationStatus      `json:"status"`
}

IdentityVerification is the structure for an account's verification.

type IdentityVerificationDetailsCode 

type IdentityVerificationDetailsCode string

IdentityVerificationDetailsCode is a machine-readable code specifying the verification state of a legal entity 

const (
	IdentityVerificationDetailsCodeFailedKeyedIdentity       IdentityVerificationDetailsCode = "failed_keyed_identity"
	IdentityVerificationDetailsCodeFailedOther               IdentityVerificationDetailsCode = "failed_other"
	IdentityVerificationDetailsCodeScanCorrupt               IdentityVerificationDetailsCode = "scan_corrupt"
	IdentityVerificationDetailsCodeScanFailedGreyscale       IdentityVerificationDetailsCode = "scan_failed_greyscale"
	IdentityVerificationDetailsCodeScanFailedOther           IdentityVerificationDetailsCode = "scan_failed_other"
	IdentityVerificationDetailsCodeScanIdCountryNotSupported IdentityVerificationDetailsCode = "scan_id_country_not_supported"
	IdentityVerificationDetailsCodeScanIdTypeNotSupported    IdentityVerificationDetailsCode = "scan_id_type_not_supported"
	IdentityVerificationDetailsCodeScanNameMismatch          IdentityVerificationDetailsCode = "scan_name_mismatch"
	IdentityVerificationDetailsCodeScanNotReadable           IdentityVerificationDetailsCode = "scan_not_readable"
	IdentityVerificationDetailsCodeScanNotUploaded           IdentityVerificationDetailsCode = "scan_not_uploaded"
)

type IdentityVerificationDisabledReason 

type IdentityVerificationDisabledReason string

IdentityVerificationDisabledReason describes the valid reason to disable account 

const (
	IdentityVerificationDisabledReasonFieldsNeeded           IdentityVerificationDisabledReason = "fields_needed"
	IdentityVerificationDisabledReasonListed                 IdentityVerificationDisabledReason = "listed"
	IdentityVerificationDisabledReasonOther                  IdentityVerificationDisabledReason = "other"
	IdentityVerificationDisabledReasonRejectedFraud          IdentityVerificationDisabledReason = "rejected.fraud"
	IdentityVerificationDisabledReasonRejectedListed         IdentityVerificationDisabledReason = "rejected.listed"
	IdentityVerificationDisabledReasonRejectedOther          IdentityVerificationDisabledReason = "rejected.other"
	IdentityVerificationDisabledReasonRejectedTermsOfService IdentityVerificationDisabledReason = "rejected.terms_of_service"
	IdentityVerificationDisabledReasonUnderReview            IdentityVerificationDisabledReason = "under_review"
)

type IdentityVerificationParams 

type IdentityVerificationParams struct {
	Document     *string `form:"document"`
	DocumentBack *string `form:"document_back"`
}

IdentityVerification represents a verification during account creation/updates.

type IdentityVerificationStatus 

type IdentityVerificationStatus string

IdentityVerificationStatus describes the different statuses for identity verification. 

const (
	IdentityVerificationStatusPending    IdentityVerificationStatus = "pending"
	IdentityVerificationStatusUnverified IdentityVerificationStatus = "unverified"
	IdentityVerificationStatusVerified   IdentityVerificationStatus = "verified"
)

type InvalidRequestError 

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

InvalidRequestError is an error that occurs when a request contains invalid parameters.

func (*InvalidRequestError) Error 

func (e *InvalidRequestError) Error() string

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

type Inventory 

type Inventory struct {
	Quantity int64             `json:"quantity"`
	Type     SKUInventoryType  `json:"type"`
	Value    SKUInventoryValue `json:"value"`
}

type InventoryParams 

type InventoryParams struct {
	Quantity *int64  `form:"quantity"`
	Type     *string `form:"type"`
	Value    *string `form:"value"`
}

type Invoice 

type Invoice struct {
	AmountDue                 int64                `json:"amount_due"`
	AmountPaid                int64                `json:"amount_paid"`
	AmountRemaining           int64                `json:"amount_remaining"`
	ApplicationFee            int64                `json:"application_fee"`
	AttemptCount              int64                `json:"attempt_count"`
	Attempted                 bool                 `json:"attempted"`
	Billing                   InvoiceBilling       `json:"billing"`
	BillingReason             InvoiceBillingReason `json:"billing_reason"`
	Charge                    *Charge              `json:"charge"`
	Closed                    bool                 `json:"closed"`
	Currency                  Currency             `json:"currency"`
	Customer                  *Customer            `json:"customer"`
	Date                      int64                `json:"date"`
	Description               string               `json:"description"`
	Discount                  *Discount            `json:"discount"`
	DueDate                   int64                `json:"due_date"`
	EndingBalance             int64                `json:"ending_balance"`
	Forgiven                  bool                 `json:"forgiven"`
	HostedInvoiceURL          string               `json:"hosted_invoice_url"`
	ID                        string               `json:"id"`
	InvoicePDF                string               `json:"invoice_pdf"`
	Lines                     *InvoiceLineList     `json:"lines"`
	Livemode                  bool                 `json:"livemode"`
	Metadata                  map[string]string    `json:"metadata"`
	NextPaymentAttempt        int64                `json:"next_payment_attempt"`
	Number                    string               `json:"number"`
	Paid                      bool                 `json:"paid"`
	PeriodEnd                 int64                `json:"period_end"`
	PeriodStart               int64                `json:"period_start"`
	ReceiptNumber             string               `json:"receipt_number"`
	StartingBalance           int64                `json:"starting_balance"`
	StatementDescriptor       string               `json:"statement_descriptor"`
	Subscription              string               `json:"subscription"`
	SubscriptionProrationDate int64                `json:"subscription_proration_date"`
	Subtotal                  int64                `json:"subtotal"`
	Tax                       int64                `json:"tax"`
	TaxPercent                float64              `json:"tax_percent"`
	Total                     int64                `json:"total"`
	WebhooksDeliveredAt       int64                `json:"webhooks_delivered_at"`
}

Invoice is the resource representing a Stripe invoice. For more details see https://stripe.com/docs/api#invoice_object.

Example (Update) 
package main

import (
	"log"

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

func main() {
	stripe.Key = "sk_key"

	params := &stripe.InvoiceParams{
		Description: stripe.String("updated description"),
	}

	inv, err := invoice.Update("sub_example_id", params)

	if err != nil {
		log.Fatal(err)
	}

	log.Printf("%v\n", inv.Description)
}

Output:

func (*Invoice) UnmarshalJSON 

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

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

type InvoiceBilling 

type InvoiceBilling string

InvoiceBilling is the type of billing method for this invoice. 

const (
	InvoiceBillingChargeAutomatically InvoiceBilling = "charge_automatically"
	InvoiceBillingSendInvoice         InvoiceBilling = "send_invoice"
)

type InvoiceBillingReason 

type InvoiceBillingReason string

InvoiceBillingReason is the reason why a given invoice was created 

const (
	InvoiceBillingReasonManual             InvoiceBillingReason = "manual"
	InvoiceBillingReasonSubscription       InvoiceBillingReason = "subscription"
	InvoiceBillingReasonSubscriptionCycle  InvoiceBillingReason = "subscription_cycle"
	InvoiceBillingReasonSubscriptionUpdate InvoiceBillingReason = "subscription_update"
	InvoiceBillingReasonUpcoming           InvoiceBillingReason = "upcoming"
)

type InvoiceItem 

type InvoiceItem struct {
	Amount       int64             `json:"amount"`
	Currency     Currency          `json:"currency"`
	Customer     *Customer         `json:"customer"`
	Date         int64             `json:"date"`
	Deleted      bool              `json:"deleted"`
	Description  string            `json:"description"`
	Discountable bool              `json:"discountable"`
	ID           string            `json:"id"`
	Invoice      *Invoice          `json:"invoice"`
	Livemode     bool              `json:"livemode"`
	Metadata     map[string]string `json:"metadata"`
	Period       *Period           `json:"period"`
	Plan         *Plan             `json:"plan"`
	Proration    bool              `json:"proration"`
	Quantity     int64             `json:"quantity"`
	Subscription *Subscription     `json:"subscription"`
}

InvoiceItem is the resource represneting a Stripe invoice item. For more details see https://stripe.com/docs/api#invoiceitems.

func (*InvoiceItem) UnmarshalJSON 

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

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

type InvoiceItemList 

type InvoiceItemList struct {
	ListMeta
	Data []*InvoiceItem `json:"data"`
}

InvoiceItemList is a list of invoice items as retrieved from a list endpoint.

type InvoiceItemListParams 

type InvoiceItemListParams struct {
	ListParams   `form:"*"`
	Created      *int64            `form:"created"`
	CreatedRange *RangeQueryParams `form:"created"`
	Customer     *string           `form:"customer"`
}

InvoiceItemListParams is the set of parameters that can be used when listing invoice items. For more details see https://stripe.com/docs/api#list_invoiceitems.

type InvoiceItemParams 

type InvoiceItemParams struct {
	Params       `form:"*"`
	Amount       *int64  `form:"amount"`
	Currency     *string `form:"currency"`
	Customer     *string `form:"customer"`
	Description  *string `form:"description"`
	Discountable *bool   `form:"discountable"`
	Invoice      *string `form:"invoice"`
	Subscription *string `form:"subscription"`
}

InvoiceItemParams is the set of parameters that can be used when creating or updating an invoice item. For more details see https://stripe.com/docs/api#create_invoiceitem and https://stripe.com/docs/api#update_invoiceitem.

type InvoiceLine 

type InvoiceLine struct {
	Amount           int64             `json:"amount"`
	Currency         Currency          `json:"currency"`
	Description      string            `json:"description"`
	Discountable     bool              `json:"discountable"`
	ID               string            `json:"id"`
	Livemode         bool              `json:"live_mode"`
	Metadata         map[string]string `json:"metadata"`
	Period           *Period           `json:"period"`
	Plan             *Plan             `json:"plan"`
	Proration        bool              `json:"proration"`
	Quantity         int64             `json:"quantity"`
	Subscription     string            `json:"subscription"`
	SubscriptionItem string            `json:"subscription_item"`
	Type             InvoiceLineType   `json:"type"`
}

InvoiceLine is the resource representing a Stripe invoice line item. For more details see https://stripe.com/docs/api#invoice_line_item_object.

type InvoiceLineList 

type InvoiceLineList struct {
	ListMeta
	Data []*InvoiceLine `json:"data"`
}

InvoiceLineList is a list object for invoice line items.

type InvoiceLineListParams 

type InvoiceLineListParams struct {
	ListParams `form:"*"`

	Customer *string `form:"customer"`

	// ID is the invoice ID to list invoice lines for.
	ID *string `form:"-"` // Goes in the URL

	Subscription *string `form:"subscription"`
}

InvoiceLineListParams is the set of parameters that can be used when listing invoice line items. For more details see https://stripe.com/docs/api#invoice_lines.

type InvoiceLineType 

type InvoiceLineType string

InvoiceLineType is the list of allowed values for the invoice line's type. 

const (
	InvoiceLineTypeInvoiceItem  InvoiceLineType = "invoiceitem"
	InvoiceLineTypeSubscription InvoiceLineType = "subscription"
)

type InvoiceList 

type InvoiceList struct {
	ListMeta
	Data []*Invoice `json:"data"`
}

InvoiceList is a list of invoices as retrieved from a list endpoint.

type InvoiceListParams 

type InvoiceListParams struct {
	ListParams   `form:"*"`
	Billing      *string           `form:"billing"`
	Customer     *string           `form:"customer"`
	Date         *int64            `form:"date"`
	DateRange    *RangeQueryParams `form:"date"`
	DueDate      *int64            `form:"due_date"`
	Subscription *string           `form:"subscription"`
}

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

type InvoiceParams 

type InvoiceParams struct {
	Params              `form:"*"`
	ApplicationFee      *int64   `form:"application_fee"`
	Billing             *string  `form:"billing"`
	Closed              *bool    `form:"closed"`
	Customer            *string  `form:"customer"`
	DaysUntilDue        *int64   `form:"days_until_due"`
	Description         *string  `form:"description"`
	DueDate             *int64   `form:"due_date"`
	Forgiven            *bool    `form:"forgiven"`
	Paid                *bool    `form:"paid"`
	StatementDescriptor *string  `form:"statement_descriptor"`
	Subscription        *string  `form:"subscription"`
	TaxPercent          *float64 `form:"tax_percent"`

	Coupon                         *string                           `form:"coupon"`
	InvoiceItems                   *InvoiceUpcomingInvoiceItemParams `form:"invoice_items"`
	SubscriptionBillingCycleAnchor *int64                            `form:"subscription_billing_cycle_anchor"`
	SubscriptionItems              []*SubscriptionItemsParams        `form:"subscription_items,indexed"`
	SubscriptionPlan               *string                           `form:"subscription_plan"`
	SubscriptionProrate            *bool                             `form:"subscription_prorate"`
	SubscriptionProrationDate      *int64                            `form:"subscription_proration_date"`
	SubscriptionQuantity           *int64                            `form:"subscription_quantity"`
	SubscriptionTaxPercent         *int64                            `form:"subscription_tax_percent"`
	SubscriptionTrialEnd           *int64                            `form:"subscription_trial_end"`
	SubscriptionTrialFromPlan      *bool                             `form:"subscription_trial_from_plan"`
}

InvoiceParams is the set of parameters that can be used when creating or updating an invoice. For more details see https://stripe.com/docs/api#create_invoice, https://stripe.com/docs/api#update_invoice.

type InvoicePayParams 

type InvoicePayParams struct {
	Params `form:"*"`
	Source *string `form:"source"`
}

InvoicePayParams is the set of parameters that can be used when paying invoices. For more details, see: https://stripe.com/docs/api#pay_invoice.

type InvoiceUpcomingInvoiceItemParams 

type InvoiceUpcomingInvoiceItemParams struct {
	Amount       *int64  `form:"amount"`
	Currency     *string `form:"currency"`
	Description  *string `form:"description"`
	Discountable *bool   `form:"discountable"`
	InvoiceItem  *string `form:"invoiceitem"`
}

InvoiceUpcomingInvoiceItemParams is the set of parameters that can be used when adding or modifying invoice items on an upcoming invoice. For more details see https://stripe.com/docs/api#upcoming_invoice-invoice_items.

type IssuerFraudRecord 

type IssuerFraudRecord struct {
	Charge          *Charge         `json:"charge"`
	Created         int64           `json:"created"`
	IssuerFraudType IssuerFraudType `json:"fraud_type"`
	ID              string          `json:"id"`
	Live            bool            `json:"livemode"`
	PostDate        int64           `json:"post_date"`
}

IssuerFraudRecord is the resource representing an issuer fraud record. For more details see https://stripe.com/docs/api#issuer_fraud_records.

type IssuerFraudRecordList 

type IssuerFraudRecordList struct {
	ListMeta
	Values []*IssuerFraudRecord `json:"data"`
}

IssuerFraudRecordList is a list of issuer fraud records as retrieved from a list endpoint.

type IssuerFraudRecordListParams 

type IssuerFraudRecordListParams struct {
	ListParams `form:"*"`
	Charge     *string `form:"-"`
}

IssuerFraudRecordListParams is the set of parameters that can be used when listing issuer fraud records. For more details see https://stripe.com/docs#list_issuer_fraud_records.

type IssuerFraudRecordParams 

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

IssuerFraudRecordParams is the set of parameters that can be used when retrieving issuer fraud records. For more details see https://stripe.com/docs#retrieve_issuer_fraud_records.

type IssuerFraudType 

type IssuerFraudType string

IssuerFraudType are strings that map to the fraud label category from the issuer. 

const (
	IssuerFraudTypeCardNeverReceived         IssuerFraudType = "card_never_received"
	IssuerFraudTypeFraudulentCardApplication IssuerFraudType = "fraudulent_card_application"
	IssuerFraudTypeMadeWithCounterfeitCard   IssuerFraudType = "made_with_counterfeit_card"
	IssuerFraudTypeMadeWithLostCard          IssuerFraudType = "made_with_lost_card"
	IssuerFraudTypeMadeWithStolenCard        IssuerFraudType = "made_with_stolen_card"
	IssuerFraudTypeMisc                      IssuerFraudType = "misc"
	IssuerFraudTypeUnauthorizedUseOfCard     IssuerFraudType = "unauthorized_use_of_card"
)

type Iter 

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

Iter provides a convenient interface for iterating over the elements returned from paginated list API calls. Successive calls to the Next method will step through each item in the list, fetching pages of items as needed. Iterators are not thread-safe, so they should not be consumed across multiple goroutines.

func GetIter 

func GetIter(container ListParamsContainer, query Query) *Iter

GetIter returns a new Iter for a given query and its options.

func (*Iter) Current 

func (it *Iter) Current() interface{}

Current returns the most recent item visited by a call to Next.

func (*Iter) Err 

func (it *Iter) Err() error

Err returns the error, if any, that caused the Iter to stop. It must be inspected after Next returns false.

func (*Iter) Meta 

func (it *Iter) Meta() *ListMeta

Meta returns the list metadata.

func (*Iter) Next 

func (it *Iter) Next() bool

Next advances the Iter to the next item in the list, which will then be available through the Current method. It returns false when the iterator stops at the end of the list.

type LegalEntity 

type LegalEntity struct {
	AdditionalOwners         []*AdditionalOwner    `json:"additional_owners"`
	Address                  *AccountAddress       `json:"address"`
	AddressKana              *AccountAddress       `json:"address_kana"`
	AddressKanji             *AccountAddress       `json:"address_kanji"`
	BusinessName             string                `json:"business_name"`
	BusinessNameKana         string                `json:"business_name_kana"`
	BusinessNameKanji        string                `json:"business_name_kanji"`
	BusinessTaxIDProvided    bool                  `json:"business_tax_id_provided"`
	BusinessVATIDProvided    bool                  `json:"business_vat_id_provided"`
	DOB                      *DOB                  `json:"dob"`
	FirstName                string                `json:"first_name"`
	FirstNameKana            string                `json:"first_name_kana"`
	FirstNameKanji           string                `json:"first_name_kanji"`
	Gender                   string                `json:"gender"`
	LastName                 string                `json:"last_name"`
	LastNameKana             string                `json:"last_name_kana"`
	LastNameKanji            string                `json:"last_name_kanji"`
	MaidenName               string                `json:"maiden_name"`
	PersonalAddress          *AccountAddress       `json:"personal_address"`
	PersonalAddressKana      *AccountAddress       `json:"personal_address_kana"`
	PersonalAddressKanji     *AccountAddress       `json:"personal_address_kanji"`
	PersonalIDNumberProvided bool                  `json:"personal_id_number_provided"`
	PhoneNumber              string                `json:"phone_number"`
	SSNLast4Provided         bool                  `json:"ssn_last_4_provided"`
	Type                     LegalEntityType       `json:"type"`
	Verification             *IdentityVerification `json:"verification"`
}

LegalEntity is the structure for properties related to an account's legal state.

type LegalEntityParams 

type LegalEntityParams struct {
	AdditionalOwners []*AdditionalOwnerParams `form:"additional_owners,indexed"`

	// AdditionalOwnersEmpty can be set to clear a legal entity's additional
	// owners.
	AdditionalOwnersEmpty bool `form:"additional_owners,empty"`

	Address              *AccountAddressParams       `form:"address"`
	AddressKana          *AccountAddressParams       `form:"address_kana"`
	AddressKanji         *AccountAddressParams       `form:"address_kanji"`
	BusinessName         *string                     `form:"business_name"`
	BusinessNameKana     *string                     `form:"business_name_kana"`
	BusinessNameKanji    *string                     `form:"business_name_kanji"`
	BusinessTaxID        *string                     `form:"business_tax_id"`
	BusinessVATID        *string                     `form:"business_vat_id"`
	DOB                  *DOBParams                  `form:"dob"`
	FirstName            *string                     `form:"first_name"`
	FirstNameKana        *string                     `form:"first_name_kana"`
	FirstNameKanji       *string                     `form:"first_name_kanji"`
	Gender               *string                     `form:"gender"`
	LastName             *string                     `form:"last_name"`
	LastNameKana         *string                     `form:"last_name_kana"`
	LastNameKanji        *string                     `form:"last_name_kanji"`
	MaidenName           *string                     `form:"maiden_name"`
	PersonalAddress      *AccountAddressParams       `form:"personal_address"`
	PersonalAddressKana  *AccountAddressParams       `form:"personal_address_kana"`
	PersonalAddressKanji *AccountAddressParams       `form:"personal_address_kanji"`
	PersonalIDNumber     *string                     `form:"personal_id_number"`
	PhoneNumber          *string                     `form:"phone_number"`
	SSNLast4             *string                     `form:"ssn_last_4"`
	Type                 *string                     `form:"type"`
	Verification         *IdentityVerificationParams `form:"verification"`
}

LegalEntityParams represents a legal_entity during account creation/updates.

type LegalEntityType 

type LegalEntityType string

LegalEntityType describes the types for a legal entity. 

const (
	LegalEntityTypeCompany    LegalEntityType = "company"
	LegalEntityTypeIndividual LegalEntityType = "individual"
)

type ListMeta 

type ListMeta struct {
	HasMore    bool   `json:"has_more"`
	TotalCount uint32 `json:"total_count"`
	URL        string `json:"url"`
}

ListMeta is the structure that contains the common properties of List iterators. The Count property is only populated if the total_count include option is passed in (see tests for example).

type ListParams 

type ListParams struct {
	// Context used for request. It may carry deadlines, cancelation signals,
	// and other request-scoped values across API boundaries and between
	// processes.
	//
	// Note that a cancelled or timed out context does not provide any
	// guarantee whether the operation was or was not completed on Stripe's API
	// servers. For certainty, you must either retry with the same idempotency
	// key or query the state of the API.
	Context context.Context `form:"-"`

	EndingBefore *string   `form:"ending_before"`
	Expand       []*string `form:"expand"`
	Filters      Filters   `form:"*"`
	Limit        *int64    `form:"limit"`

	// Single specifies whether this is a single page iterator. By default,
	// listing through an iterator will automatically grab additional pages as
	// the query progresses. To change this behavior and just load a single
	// page, set this to true.
	Single bool `form:"-"` // Not an API parameter

	StartingAfter *string `form:"starting_after"`

	// StripeAccount may contain the ID of a connected account. By including
	// this field, the request is made as if it originated from the connected
	// account instead of under the account of the owner of the configured
	// Stripe key.
	StripeAccount *string `form:"-"` // Passed as header
}

ListParams is the structure that contains the common properties of any *ListParams structure.

func (*ListParams) AddExpand 

func (p *ListParams) AddExpand(f string)

AddExpand appends a new field to expand.

func (*ListParams) GetListParams 

func (p *ListParams) GetListParams() *ListParams

GetListParams returns a ListParams struct (itself). It exists because any structs that embed ListParams will inherit it, and thus implement the ListParamsContainer interface.

func (*ListParams) GetParams 

func (p *ListParams) GetParams() *Params

GetParams returns ListParams as a Params struct. It exists because any structs that embed Params will inherit it, and thus implement the ParamsContainer interface.

func (*ListParams) SetStripeAccount 

func (p *ListParams) SetStripeAccount(val string)

SetStripeAccount sets a value for the Stripe-Account header.

func (*ListParams) ToParams 

func (p *ListParams) ToParams() *Params

ToParams converts a ListParams to a Params by moving over any fields that have valid targets in the new type. This is useful because fields in Params can be injected directly into an http.Request while generally ListParams is only used to build a set of parameters.

type ListParamsContainer 

type ListParamsContainer interface {
	GetListParams() *ListParams
}

ListParamsContainer is a general interface for which all list parameter structs should comply. They achieve this by embedding a ListParams struct and inheriting its implementation of this interface. 

type LoginLink struct {
	Created int64  `json:"created"`
	URL     string `json:"url"`
}

LoginLink is the resource representing a login link for Express accounts. For more details see https://stripe.com/docs/api#login_link_object

type LoginLinkParams 

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

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

type Order 

type Order struct {
	Amount                 int64             `json:"amount"`
	AmountReturned         int64             `json:"amount_returned"`
	Application            string            `json:"application"`
	ApplicationFee         int64             `json:"application_fee"`
	Charge                 *Charge           `json:"charge"`
	Created                int64             `json:"created"`
	Currency               Currency          `json:"currency"`
	Customer               Customer          `json:"customer"`
	Email                  string            `json:"email"`
	ID                     string            `json:"id"`
	Items                  []*OrderItem      `json:"items"`
	Livemode               bool              `json:"livemode"`
	Metadata               map[string]string `json:"metadata"`
	Returns                *OrderReturnList  `json:"returns"`
	SelectedShippingMethod *string           `json:"selected_shipping_method"`
	Shipping               *Shipping         `json:"shipping"`
	ShippingMethods        []*ShippingMethod `json:"shipping_methods"`
	Status                 string            `json:"status"`
	StatusTransitions      StatusTransitions `json:"status_transitions"`
	Updated                int64             `json:"updated"`
}

func (*Order) UnmarshalJSON 

func (o *Order) UnmarshalJSON(data []byte) error

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

type OrderDeliveryEstimateType 

type OrderDeliveryEstimateType string

OrderDeliveryEstimateType represents the type of delivery estimate for shipping methods 

const (
	OrderDeliveryEstimateTypeExact OrderDeliveryEstimateType = "exact"
	OrderDeliveryEstimateTypeRange OrderDeliveryEstimateType = "range"
)

type OrderItem 

type OrderItem struct {
	Amount      int64         `json:"amount"`
	Currency    Currency      `json:"currency"`
	Description string        `json:"description"`
	Parent      string        `json:"parent"`
	Quantity    int64         `json:"quantity"`
	Type        OrderItemType `json:"type"`
}

type OrderItemParams 

type OrderItemParams struct {
	Amount      *int64  `form:"amount"`
	Currency    *string `form:"currency"`
	Description *string `form:"description"`
	Parent      *string `form:"parent"`
	Quantity    *int64  `form:"quantity"`
	Type        *string `form:"type"`
}

type OrderItemType 

type OrderItemType string

OrderItemType represents the type of order item 

const (
	OrderItemTypeDiscount OrderItemType = "discount"
	OrderItemTypeShipping OrderItemType = "shipping"
	OrderItemTypeSKU      OrderItemType = "sku"
	OrderItemTypeTax      OrderItemType = "tax"
)

type OrderList 

type OrderList struct {
	ListMeta
	Data []*Order `json:"data"`
}

OrderList is a list of orders as retrieved from a list endpoint.

type OrderListParams 

type OrderListParams struct {
	ListParams   `form:"*"`
	Created      *int64            `form:"created"`
	CreatedRange *RangeQueryParams `form:"created"`
	Customer     *string           `form:"customer"`
	IDs          []*string         `form:"ids"`
	Status       *string           `form:"status"`
}

OrderListParams is the set of parameters that can be used when listing orders. For more details, see: https://stripe.com/docs/api#list_orders.

type OrderParams 

type OrderParams struct {
	Params   `form:"*"`
	Coupon   *string            `form:"coupon"`
	Currency *string            `form:"currency"`
	Customer *string            `form:"customer"`
	Email    *string            `form:"email"`
	Items    []*OrderItemParams `form:"items,indexed"`
	Shipping *ShippingParams    `form:"shipping"`
}

type OrderPayParams 

type OrderPayParams struct {
	Params         `form:"*"`
	ApplicationFee *int64        `form:"application_fee"`
	Customer       *string       `form:"customer"`
	Email          *string       `form:"email"`
	Source         *SourceParams `form:"*"` // SourceParams has custom encoding so brought to top level with "*"
}

OrderPayParams is the set of parameters that can be used when paying orders. For more details, see: https://stripe.com/docs/api#pay_order.

func (*OrderPayParams) SetSource 

func (op *OrderPayParams) SetSource(sp interface{}) error

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

type OrderReturn 

type OrderReturn struct {
	Amount   int64        `json:"amount"`
	Created  int64        `json:"created"`
	Currency Currency     `json:"currency"`
	ID       string       `json:"id"`
	Items    []*OrderItem `json:"items"`
	Livemode bool         `json:"livemode"`
	Order    *Order       `json:"order"`
	Refund   *Refund      `json:"refund"`
}

func (*OrderReturn) UnmarshalJSON 

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

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

type OrderReturnList 

type OrderReturnList struct {
	ListMeta
	Data []*OrderReturn `json:"data"`
}

OrderReturnList is a list of returns as retrieved from a list endpoint.

type OrderReturnListParams 

type OrderReturnListParams struct {
	ListParams   `form:"*"`
	Created      *int64            `form:"created"`
	CreatedRange *RangeQueryParams `form:"created"`
	Order        *string           `form:"order"`
}

OrderReturnListParams is the set of parameters that can be used when listing returns. For more details, see: https://stripe.com/docs/api#list_order_returns.

type OrderReturnParams 

type OrderReturnParams struct {
	Params `form:"*"`
	Items  []*OrderItemParams `form:"items,indexed"`
}

OrderReturnParams is the set of parameters that can be used when returning orders. For more details, see: https://stripe.com/docs/api#return_order.

type OrderStatus 

type OrderStatus string

OrderStatus represents the statuses of an order object. 

const (
	OrderStatusCanceled  OrderStatus = "canceled"
	OrderStatusCreated   OrderStatus = "created"
	OrderStatusFulfilled OrderStatus = "fulfilled"
	OrderStatusPaid      OrderStatus = "paid"
	OrderStatusReturned  OrderStatus = "returned"
)

type OrderUpdateParams 

type OrderUpdateParams struct {
	Params                 `form:"*"`
	Coupon                 *string                    `form:"coupon"`
	SelectedShippingMethod *string                    `form:"selected_shipping_method"`
	Shipping               *OrderUpdateShippingParams `form:"shipping"`
	Status                 *string                    `form:"status"`
}

type OrderUpdateShippingParams 

type OrderUpdateShippingParams struct {
	Carrier        *string `form:"carrier"`
	TrackingNumber *string `form:"tracking_number"`
}

type PIIParams 

type PIIParams struct {
	Params           `form:"*"`
	PersonalIDNumber *string `form:"personal_id_number"`
}

PIIParams are parameters for personal identifiable information (PII).

type PackageDimensions 

type PackageDimensions struct {
	Height float64 `json:"height"`
	Length float64 `json:"length"`
	Weight float64 `json:"weight"`
	Width  float64 `json:"width"`
}

PackageDimensions represents the dimension of a product or a sku from the perspective of shipping.

type PackageDimensionsParams 

type PackageDimensionsParams struct {
	Height *float64 `form:"height"`
	Length *float64 `form:"length"`
	Weight *float64 `form:"weight"`
	Width  *float64 `form:"width"`
}

PackageDimensions represents the dimension of a product or a sku from the perspective of shipping.

type Params 

type Params struct {
	// Context used for request. It may carry deadlines, cancelation signals,
	// and other request-scoped values across API boundaries and between
	// processes.
	//
	// Note that a cancelled or timed out context does not provide any
	// guarantee whether the operation was or was not completed on Stripe's API
	// servers. For certainty, you must either retry with the same idempotency
	// key or query the state of the API.
	Context context.Context `form:"-"`

	Expand []*string    `form:"expand"`
	Extra  *ExtraValues `form:"*"`

	// Headers may be used to provide extra header lines on the HTTP request.
	Headers http.Header `form:"-"`

	IdempotencyKey *string           `form:"-"` // Passed as header
	Metadata       map[string]string `form:"metadata"`

	// StripeAccount may contain the ID of a connected account. By including
	// this field, the request is made as if it originated from the connected
	// account instead of under the account of the owner of the configured
	// Stripe key.
	StripeAccount *string `form:"-"` // Passed as header
}

Params is the structure that contains the common properties of any *Params structure.

func (*Params) AddExpand 

func (p *Params) AddExpand(f string)

AddExpand appends a new field to expand.

func (*Params) AddExtra 

func (p *Params) AddExtra(key, value string)

AddExtra adds a new arbitrary key-value pair to the request data

func (*Params) AddMetadata 

func (p *Params) AddMetadata(key, value string)

AddMetadata adds a new key-value pair to the Metadata.

func (*Params) GetParams 

func (p *Params) GetParams() *Params

GetParams returns a Params struct (itself). It exists because any structs that embed Params will inherit it, and thus implement the ParamsContainer interface.

func (*Params) SetIdempotencyKey 

func (p *Params) SetIdempotencyKey(val string)

SetIdempotencyKey sets a value for the Idempotency-Key header.

func (*Params) SetStripeAccount 

func (p *Params) SetStripeAccount(val string)

SetStripeAccount sets a value for the Stripe-Account header.

type ParamsContainer 

type ParamsContainer interface {
	GetParams() *Params
}

ParamsContainer is a general interface for which all parameter structs should comply. They achieve this by embedding a Params struct and inheriting its implementation of this interface.

type PaymentSource 

type PaymentSource struct {
	BankAccount     *BankAccount      `json:"-"`
	BitcoinReceiver *BitcoinReceiver  `json:"-"`
	Card            *Card             `json:"-"`
	Deleted         bool              `json:"deleted"`
	ID              string            `json:"id"`
	SourceObject    *Source           `json:"-"`
	Type            PaymentSourceType `json:"object"`
}

PaymentSource describes the payment source used to make a Charge. The Type should indicate which object is fleshed out (eg. BitcoinReceiver or Card) For more details see https://stripe.com/docs/api#retrieve_charge

func (*PaymentSource) MarshalJSON 

func (s *PaymentSource) MarshalJSON() ([]byte, error)

MarshalJSON handles serialization of a PaymentSource. This custom marshaling is needed because the specific type of payment instrument it represents is specified by the Type

func (*PaymentSource) UnmarshalJSON 

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

UnmarshalJSON handles deserialization of a PaymentSource. This custom unmarshaling is needed because the specific type of payment instrument it refers to is specified in the JSON

type PaymentSourceType 

type PaymentSourceType string

PaymentSourceType consts represent valid payment sources. 

const (
	PaymentSourceTypeAccount         PaymentSourceType = "account"
	PaymentSourceTypeBankAccount     PaymentSourceType = "bank_account"
	PaymentSourceTypeBitcoinReceiver PaymentSourceType = "bitcoin_receiver"
	PaymentSourceTypeCard            PaymentSourceType = "card"
	PaymentSourceTypeObject          PaymentSourceType = "source"
)

type Payout 

type Payout struct {
	Amount                    int64               `json:"amount"`
	ArrivalDate               int64               `json:"arrival_date"`
	Automatic                 bool                `json:"automatic"`
	BalanceTransaction        *BalanceTransaction `json:"balance_transaction"`
	BankAccount               *BankAccount        `json:"bank_account"`
	Card                      *Card               `json:"card"`
	Created                   int64               `json:"created"`
	Currency                  Currency            `json:"currency"`
	Destination               string              `json:"destination"`
	FailureBalanceTransaction *BalanceTransaction `json:"failure_balance_transaction"`
	FailureCode               PayoutFailureCode   `json:"failure_code"`
	FailureMessage            string              `json:"failure_message"`
	ID                        string              `json:"id"`
	Livemode                  bool                `json:"livemode"`
	Metadata                  map[string]string   `json:"metadata"`
	Method                    PayoutMethodType    `json:"method"`
	SourceType                PayoutSourceType    `json:"source_type"`
	StatementDescriptor       string              `json:"statement_descriptor"`
	Status                    PayoutStatus        `json:"status"`
	Type                      PayoutType          `json:"type"`
}

Payout is the resource representing a Stripe payout. For more details see https://stripe.com/docs/api#payouts.

func (*Payout) UnmarshalJSON 

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

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

type PayoutDestination 

type PayoutDestination struct {
	BankAccount *BankAccount          `json:"-"`
	Card        *Card                 `json:"-"`
	ID          string                `json:"id"`
	Type        PayoutDestinationType `json:"object"`
}

PayoutDestination describes the destination of a Payout. The Type should indicate which object is fleshed out For more details see https://stripe.com/docs/api/go#payout_object

func (*PayoutDestination) MarshalJSON 

func (d *PayoutDestination) MarshalJSON() ([]byte, error)

MarshalJSON handles serialization of a PayoutDestination. This custom marshaling is needed because we can only send a string ID as a destination, even though it can be expanded to a full object when retrieving

func (*PayoutDestination) UnmarshalJSON 

func (d *PayoutDestination) UnmarshalJSON(data []byte) error

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

type PayoutDestinationType 

type PayoutDestinationType string

PayoutDestinationType consts represent valid payout destinations. 

const (
	PayoutDestinationTypeBankAccount PayoutDestinationType = "bank_account"
	PayoutDestinationTypeCard        PayoutDestinationType = "card"
)

type PayoutFailureCode 

type PayoutFailureCode string

PayoutFailureCode is the list of allowed values for the payout's failure code. 

const (
	PayoutFailureCodeAccountClosed         PayoutFailureCode = "account_closed"
	PayoutFailureCodeAccountFrozen         PayoutFailureCode = "account_frozen"
	PayoutFailureCodeBankAccountRestricted PayoutFailureCode = "bank_account_restricted"
	PayoutFailureCodeBankOwnershipChanged  PayoutFailureCode = "bank_ownership_changed"
	PayoutFailureCodeCouldNotProcess       PayoutFailureCode = "could_not_process"
	PayoutFailureCodeDebitNotAuthorized    PayoutFailureCode = "debit_not_authorized"
	PayoutFailureCodeInsufficientFunds     PayoutFailureCode = "insufficient_funds"
	PayoutFailureCodeInvalidAccountNumber  PayoutFailureCode = "invalid_account_number"
	PayoutFailureCodeInvalidCurrency       PayoutFailureCode = "invalid_currency"
	PayoutFailureCodeNoAccount             PayoutFailureCode = "no_account"
)

type PayoutInterval 

type PayoutInterval string

Interval describes the payout interval. 

const (
	PayoutIntervalDaily   PayoutInterval = "daily"
	PayoutIntervalManual  PayoutInterval = "manual"
	PayoutIntervalMonthly PayoutInterval = "monthly"
	PayoutIntervalWeekly  PayoutInterval = "weekly"
)

type PayoutList 

type PayoutList struct {
	ListMeta
	Data []*Payout `json:"data"`
}

PayoutList is a list of payouts as retrieved from a list endpoint.

type PayoutListParams 

type PayoutListParams struct {
	ListParams       `form:"*"`
	ArrivalDate      *int64            `form:"arrival_date"`
	ArrivalDateRange *RangeQueryParams `form:"arrival_date"`
	Created          *int64            `form:"created"`
	CreatedRange     *RangeQueryParams `form:"created"`
	Destination      *string           `form:"destination"`
	Status           *string           `form:"status"`
}

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

type PayoutMethodType 

type PayoutMethodType string

PayoutMethodType represents the type of payout 

const (
	PayoutMethodInstant  PayoutMethodType = "instant"
	PayoutMethodStandard PayoutMethodType = "standard"
)

type PayoutParams 

type PayoutParams struct {
	Params              `form:"*"`
	Amount              *int64  `form:"amount"`
	Currency            *string `form:"currency"`
	Destination         *string `form:"destination"`
	Method              *string `form:"method"`
	SourceType          *string `form:"source_type"`
	StatementDescriptor *string `form:"statement_descriptor"`
}

PayoutParams is the set of parameters that can be used when creating or updating a payout. For more details see https://stripe.com/docs/api#create_payout and https://stripe.com/docs/api#update_payout.

type PayoutSchedule 

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

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

type PayoutScheduleParams 

type PayoutScheduleParams struct {
	DelayDays        *int64  `form:"delay_days"`
	DelayDaysMinimum *bool   `form:"-"` // See custom AppendTo
	Interval         *string `form:"interval"`
	MonthlyAnchor    *int64  `form:"monthly_anchor"`
	WeeklyAnchor     *string `form:"weekly_anchor"`
}

PayoutScheduleParams are the parameters allowed for payout schedules.

func (*PayoutScheduleParams) AppendTo 

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

type PayoutSourceType 

type PayoutSourceType string

PayoutSourceType is the list of allowed values for the payout's source_type field. 

const (
	PayoutSourceTypeAlipayAccount   PayoutSourceType = "alipay_account"
	PayoutSourceTypeBankAccount     PayoutSourceType = "bank_account"
	PayoutSourceTypeBitcoinReceiver PayoutSourceType = "bitcoin_receiver"
	PayoutSourceTypeCard            PayoutSourceType = "card"
)

type PayoutStatus 

type PayoutStatus string

PayoutStatus is the list of allowed values for the payout's status. 

const (
	PayoutStatusCanceled  PayoutStatus = "canceled"
	PayoutStatusFailed    PayoutStatus = "failed"
	PayoutStatusInTransit PayoutStatus = "in_transit"
	PayoutStatusPaid      PayoutStatus = "paid"
	PayoutStatusPending   PayoutStatus = "pending"
)

type PayoutType 

type PayoutType string

PayoutType is the list of allowed values for the payout's type. 

const (
	PayoutTypeBank PayoutType = "bank_account"
	PayoutTypeCard PayoutType = "card"
)

type Period 

type Period struct {
	End   int64 `json:"end"`
	Start int64 `json:"start"`
}

Period is a structure representing a start and end dates.

type PermissionError 

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

PermissionError results when you attempt to make an API request for which your API key doesn't have the right permissions.

func (*PermissionError) Error 

func (e *PermissionError) Error() string

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

type Plan 

type Plan struct {
	Active          bool                `json:"active"`
	AggregateUsage  string              `json:"aggregate_usage"`
	Amount          int64               `json:"amount"`
	BillingScheme   PlanBillingScheme   `json:"billing_scheme"`
	Created         int64               `json:"created"`
	Currency        Currency            `json:"currency"`
	Deleted         bool                `json:"deleted"`
	ID              string              `json:"id"`
	Interval        PlanInterval        `json:"interval"`
	IntervalCount   int64               `json:"interval_count"`
	Livemode        bool                `json:"livemode"`
	Metadata        map[string]string   `json:"metadata"`
	Nickname        string              `json:"nickname"`
	Product         string              `json:"product"`
	Tiers           []*PlanTier         `json:"tiers"`
	TiersMode       string              `json:"tiers_mode"`
	TransformUsage  *PlanTransformUsage `json:"transform_usage"`
	TrialPeriodDays int64               `json:"trial_period_days"`
	UsageType       PlanUsageType       `json:"usage_type"`
}

Plan is the resource representing a Stripe plan. For more details see https://stripe.com/docs/api#plans.

Example (List) 
package main

import (
	"log"

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

func main() {
	stripe.Key = "sk_key"

	params := &stripe.PlanListParams{}
	params.Filters.AddFilter("limit", "", "3")
	params.Single = true

	it := plan.List(params)
	for it.Next() {
		log.Printf("%v ", it.Plan().Nickname)
	}
	if err := it.Err(); err != nil {
		log.Fatal(err)
	}
}

Output:

type PlanAggregateUsage 

type PlanAggregateUsage string

PlanAggregateUsage is the list of allowed values for a plan's aggregate usage. 

const (
	PlanAggregateUsageLastDuringPeriod PlanAggregateUsage = "last_during_period"
	PlanAggregateUsageLastEver         PlanAggregateUsage = "last_ever"
	PlanAggregateUsageMax              PlanAggregateUsage = "max"
	PlanAggregateUsageSum              PlanAggregateUsage = "sum"
)

type PlanBillingScheme 

type PlanBillingScheme string

PlanBillingScheme is the list of allowed values for a plan's billing scheme. 

const (
	PlanBillingSchemePerUnit PlanBillingScheme = "per_unit"
	PlanBillingSchemeTiered  PlanBillingScheme = "tiered"
)

type PlanInterval added in v1.0.1 

type PlanInterval string

PlanInterval is the list of allowed values for a plan's interval. 

const (
	PlanIntervalDay   PlanInterval = "day"
	PlanIntervalWeek  PlanInterval = "week"
	PlanIntervalMonth PlanInterval = "month"
	PlanIntervalYear  PlanInterval = "year"
)

type PlanList 

type PlanList struct {
	ListMeta
	Data []*Plan `json:"data"`
}

PlanList is a list of plans as returned from a list endpoint.

type PlanListParams 

type PlanListParams struct {
	ListParams   `form:"*"`
	Active       *bool             `form:"active"`
	Created      *int64            `form:"created"`
	CreatedRange *RangeQueryParams `form:"created"`
	Product      *string           `form:"product"`
}

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

type PlanParams 

type PlanParams struct {
	Params          `form:"*"`
	Active          *bool                     `form:"active"`
	AggregateUsage  *string                   `form:"aggregate_usage"`
	Amount          *int64                    `form:"amount"`
	BillingScheme   *string                   `form:"billing_scheme"`
	Currency        *string                   `form:"currency"`
	ID              *string                   `form:"id"`
	Interval        *string                   `form:"interval"`
	IntervalCount   *int64                    `form:"interval_count"`
	Nickname        *string                   `form:"nickname"`
	Product         *PlanProductParams        `form:"product"`
	ProductID       *string                   `form:"product"`
	Tiers           []*PlanTierParams         `form:"tiers,indexed"`
	TiersMode       *string                   `form:"tiers_mode"`
	TransformUsage  *PlanTransformUsageParams `form:"transform_usage"`
	TrialPeriodDays *int64                    `form:"trial_period_days"`
	UsageType       *string                   `form:"usage_type"`
}

PlanParams is the set of parameters that can be used when creating or updating a plan. For more details see https://stripe.com/docs/api#create_plan and https://stripe.com/docs/api#update_plan.

type PlanProductParams 

type PlanProductParams struct {
	ID                  *string           `form:"id"`
	Name                *string           `form:"name"`
	Metadata            map[string]string `form:"metadata"`
	StatementDescriptor *string           `form:"statement_descriptor"`
}

PlanProductParams is the set of parameters that can be used when creating a product inside a plan This can only be used on plan creation and won't work on plan update. For more details see https://stripe.com/docs/api#create_plan-product and https://stripe.com/docs/api#update_plan-product

type PlanTier 

type PlanTier struct {
	Amount int64 `json:"amount"`
	UpTo   int64 `json:"up_to"`
}

PlanTier configures tiered pricing

type PlanTierParams 

type PlanTierParams struct {
	Params  `form:"*"`
	Amount  *int64 `form:"amount"`
	UpTo    *int64 `form:"-"` // handled in custom AppendTo
	UpToInf *bool  `form:"-"` // handled in custom AppendTo
}

PlanTierParams configures tiered pricing

func (*PlanTierParams) AppendTo 

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

AppendTo implements custom up_to serialisation logic for tiers configuration

type PlanTiersMode 

type PlanTiersMode string

PlanTiersMode is the list of allowed values for a plan's tiers mode. 

const (
	PlanTiersModeGraduated PlanTiersMode = "graduated"
	PlanTiersModeVolume    PlanTiersMode = "volume"
)

type PlanTransformUsage 

type PlanTransformUsage struct {
	DivideBy int64                   `json:"divide_by"`
	Round    PlanTransformUsageRound `json:"round"`
}

PlanTransformUsage represents the bucket billing configuration.

type PlanTransformUsageParams 

type PlanTransformUsageParams struct {
	DivideBy *int64  `form:"divide_by"`
	Round    *string `form:"round"`
}

PlanTransformUsageParams represents the bucket billing configuration.

type PlanTransformUsageRound 

type PlanTransformUsageRound string

PlanTransformUsageRound is the list of allowed values for a plan's transform usage round logic. 

const (
	PlanTransformUsageRoundDown PlanTransformUsageRound = "down"
	PlanTransformUsageRoundUp   PlanTransformUsageRound = "up"
)

type PlanUsageType 

type PlanUsageType string

PlanUsageType is the list of allowed values for a plan's usage type. 

const (
	PlanUsageTypeLicensed PlanUsageType = "licensed"
	PlanUsageTypeMetered  PlanUsageType = "metered"
)

type Printfer 

type Printfer interface {
	Printf(format string, v ...interface{})
}

Printfer is an interface to be implemented by Logger. 

var Logger Printfer

Logger controls how stripe performs logging at a package level. It is useful to customise if you need it prefixed for your application to meet other requirements

type Product 

type Product struct {
	Active              bool               `json:"active"`
	Attributes          []string           `json:"attributes"`
	Caption             string             `json:"caption"`
	Created             int64              `json:"created"`
	DeactivateOn        []string           `json:"deactivate_on"`
	Description         string             `json:"description"`
	ID                  string             `json:"id"`
	Images              []string           `json:"images"`
	Livemode            bool               `json:"livemode"`
	Metadata            map[string]string  `json:"metadata"`
	Name                string             `json:"name"`
	PackageDimensions   *PackageDimensions `json:"package_dimensions"`
	Shippable           bool               `json:"shippable"`
	Skus                *SKUList           `json:"skus"`
	StatementDescriptor string             `json:"statement_descriptor"`
	Type                ProductType        `json:"type"`
	UnitLabel           string             `json:"unit_label"`
	URL                 string             `json:"url"`
	Updated             int64              `json:"updated"`
}

Product is the resource representing a Stripe product. For more details see https://stripe.com/docs/api#products.

func (*Product) UnmarshalJSON 

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

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

type ProductList 

type ProductList struct {
	ListMeta
	Data []*Product `json:"data"`
}

ProductList is a list of products as retrieved from a list endpoint.

type ProductListParams 

type ProductListParams struct {
	ListParams `form:"*"`
	Active     *bool     `form:"active"`
	IDs        []*string `form:"ids"`
	Shippable  *bool     `form:"shippable"`
	URL        *string   `form:"url"`
	Type       *string   `form:"type"`
}

ProductListParams is the set of parameters that can be used when listing products. For more details, see: https://stripe.com/docs/api#list_products.

type ProductParams 

type ProductParams struct {
	Params              `form:"*"`
	Active              *bool                    `form:"active"`
	Attributes          []*string                `form:"attributes"`
	Caption             *string                  `form:"caption"`
	DeactivateOn        []*string                `form:"deactivate_on"`
	Description         *string                  `form:"description"`
	ID                  *string                  `form:"id"`
	Images              []*string                `form:"images"`
	Name                *string                  `form:"name"`
	PackageDimensions   *PackageDimensionsParams `form:"package_dimensions"`
	Shippable           *bool                    `form:"shippable"`
	StatementDescriptor *string                  `form:"statement_descriptor"`
	Type                *string                  `form:"type"`
	UnitLabel           *string                  `form:"unit_label"`
	URL                 *string                  `form:"url"`
}

ProductParams is the set of parameters that can be used when creating or updating a product. For more details, see https://stripe.com/docs/api#create_product and https://stripe.com/docs/api#update_product.

type ProductType 

type ProductType string

ProductType is the type of a product. 

const (
	ProductTypeGood    ProductType = "good"
	ProductTypeService ProductType = "service"
)

type Query 

type Query func(*Params, *form.Values) ([]interface{}, ListMeta, error)

Query is the function used to get a page listing.

type RangeQueryParams 

type RangeQueryParams struct {
	// GreaterThan specifies that values should be a greater than this
	// timestamp.
	GreaterThan int64 `form:"gt"`

	// GreaterThanOrEqual specifies that values should be greater than or equal
	// to this timestamp.
	GreaterThanOrEqual int64 `form:"gte"`

	// LesserThan specifies that values should be lesser than this timetamp.
	LesserThan int64 `form:"lt"`

	// LesserThanOrEqual specifies that values should be lesser than or
	// equalthis timetamp.
	LesserThanOrEqual int64 `form:"lte"`
}

RangeQueryParams are a set of generic request parameters that are used on list endpoints to filter their results by some timestamp.

type RateLimitError 

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

RateLimitError occurs when the Stripe API is hit to with too many requests too quickly and indicates that the current request has been rate limited.

func (*RateLimitError) Error 

func (e *RateLimitError) Error() string

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

type ReceiverFlow 

type ReceiverFlow struct {
	Address                string                       `json:"address"`
	AmountCharged          int64                        `json:"amount_charged"`
	AmountReceived         int64                        `json:"amount_received"`
	AmountReturned         int64                        `json:"amount_returned"`
	RefundAttributesMethod SourceRefundAttributesMethod `json:"refund_attributes_method"`
	RefundAttributesStatus SourceRefundAttributesStatus `json:"refund_attributes_status"`
}

ReceiverFlow informs of the state of a receiver authentication flow.

type Recipient 

type Recipient struct {
	ActiveAccount *BankAccount      `json:"active_account"`
	Cards         *CardList         `json:"cards"`
	Created       int64             `json:"created"`
	DefaultCard   *Card             `json:"default_card"`
	Deleted       bool              `json:"deleted"`
	Description   string            `json:"description"`
	Email         string            `json:"email"`
	ID            string            `json:"id"`
	Livemode      bool              `json:"livemode"`
	Metadata      map[string]string `json:"metadata"`
	MigratedTo    *Account          `json:"migrated_to"`
	Name          string            `json:"name"`
	Type          RecipientType     `json:"type"`
}

Recipient is the resource representing a Stripe recipient. For more details see https://stripe.com/docs/api#recipients.

func (*Recipient) UnmarshalJSON 

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

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

type RecipientList 

type RecipientList struct {
	ListMeta
	Data []*Recipient `json:"data"`
}

RecipientList is a list of recipients as retrieved from a list endpoint.

type RecipientListParams 

type RecipientListParams struct {
	ListParams `form:"*"`
	Verified   *bool `form:"verified"`
}

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

type RecipientParams 

type RecipientParams struct {
	Params `form:"*"`

	BankAccount *BankAccountParams `form:"-"` // Kind of an abberation because a bank account's token will be replace the rest of its data. Keep this in a custom AppendTo for now.
	Card        *CardParams        `form:"card"`
	DefaultCard *string            `form:"default_card"`
	Description *string            `form:"description"`
	Email       *string            `form:"email"`
	Name        *string            `form:"name"`
	TaxID       *string            `form:"tax_id"`
	Token       *string            `form:"card"`
	Type        *string            `form:"-"` // Doesn't seem to be used anywhere
}

RecipientParams is the set of parameters that can be used when creating or updating recipients. For more details see https://stripe.com/docs/api#create_recipient and https://stripe.com/docs/api#update_recipient.

func (*RecipientParams) AppendTo 

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

AppendTo implements some custom behavior around a recipient's bank account. This was probably the wrong way to go about this, but grandfather the behavior for the time being.

type RecipientTransfer 

type RecipientTransfer struct {
	Amount              int64                        `json:"amount"`
	AmountReversed      int64                        `json:"amount_reversed"`
	BalanceTransaction  *BalanceTransaction          `json:"balance_transaction"`
	BankAccount         *BankAccount                 `json:"bank_account"`
	Card                *Card                        `json:"card"`
	Created             int64                        `json:"created"`
	Currency            Currency                     `json:"currency"`
	Date                int64                        `json:"date"`
	Description         string                       `json:"description"`
	Destination         string                       `json:"destination"`
	FailureCode         RecipientTransferFailureCode `json:"failure_code"`
	FailureMessage      string                       `json:"failure_message"`
	ID                  string                       `json:"id"`
	Livemode            bool                         `json:"livemode"`
	Metadata            map[string]string            `json:"metadata"`
	Method              RecipientTransferMethodType  `json:"method"`
	Recipient           *Recipient                   `json:"recipient"`
	Reversals           *ReversalList                `json:"reversals"`
	Reversed            bool                         `json:"reversed"`
	SourceTransaction   *BalanceTransactionSource    `json:"source_transaction"`
	SourceType          RecipientTransferSourceType  `json:"source_type"`
	StatementDescriptor string                       `json:"statement_descriptor"`
	Status              RecipientTransferStatus      `json:"status"`
	Type                RecipientTransferType        `json:"type"`
}

RecipientTransfer is the resource representing a Stripe recipient_transfer. For more details see https://stripe.com/docs/api#recipient_transfers.

func (*RecipientTransfer) UnmarshalJSON 

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

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

type RecipientTransferDestination 

type RecipientTransferDestination struct {
	BankAccount *BankAccount                     `json:"-"`
	Card        *Card                            `json:"-"`
	ID          string                           `json:"id"`
	Type        RecipientTransferDestinationType `json:"object"`
}

RecipientTransferDestination describes the destination of a RecipientTransfer. The Type should indicate which object is fleshed out For more details see https://stripe.com/docs/api/go#recipient_transfer_object

func (*RecipientTransferDestination) MarshalJSON 

func (d *RecipientTransferDestination) MarshalJSON() ([]byte, error)

MarshalJSON handles serialization of a RecipientTransferDestination. This custom marshaling is needed because we can only send a string ID as a destination, even though it can be expanded to a full object when retrieving

func (*RecipientTransferDestination) UnmarshalJSON 

func (d *RecipientTransferDestination) UnmarshalJSON(data []byte) error

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

type RecipientTransferDestinationType 

type RecipientTransferDestinationType string

RecipientTransferDestinationType consts represent valid recipient_transfer destinations. 

const (
	RecipientTransferDestinationBankAccount RecipientTransferDestinationType = "bank_account"
	RecipientTransferDestinationCard        RecipientTransferDestinationType = "card"
)

type RecipientTransferFailureCode 

type RecipientTransferFailureCode string

RecipientTransferFailureCode is the list of allowed values for the recipient_transfer's failure code. 

const (
	RecipientTransferFailureCodeAccountClosed         RecipientTransferFailureCode = "account_closed"
	RecipientTransferFailureCodeAccountFrozen         RecipientTransferFailureCode = "account_frozen"
	RecipientTransferFailureCodeBankAccountRestricted RecipientTransferFailureCode = "bank_account_restricted"
	RecipientTransferFailureCodeBankOwnershipChanged  RecipientTransferFailureCode = "bank_ownership_changed"
	RecipientTransferFailureCodeDebitNotAuthorized    RecipientTransferFailureCode = "debit_not_authorized"
	RecipientTransferFailureCodeCouldNotProcess       RecipientTransferFailureCode = "could_not_process"
	RecipientTransferFailureCodeInsufficientFunds     RecipientTransferFailureCode = "insufficient_funds"
	RecipientTransferFailureCodeInvalidAccountNumber  RecipientTransferFailureCode = "invalid_account_number"
	RecipientTransferFailureCodeInvalidCurrency       RecipientTransferFailureCode = "invalid_currency"
	RecipientTransferFailureCodeNoAccount             RecipientTransferFailureCode = "no_account"
)

type RecipientTransferMethodType 

type RecipientTransferMethodType string

RecipientTransferMethodType represents the type of recipient_transfer 

const (
	RecipientTransferMethodInstant  RecipientTransferMethodType = "instant"
	RecipientTransferMethodStandard RecipientTransferMethodType = "standard"
)

type RecipientTransferSourceType 

type RecipientTransferSourceType string

RecipientTransferSourceType is the list of allowed values for the recipient_transfer's source_type field. 

const (
	RecipientTransferSourceTypeAlipayAccount   RecipientTransferSourceType = "alipay_account"
	RecipientTransferSourceTypeBankAccount     RecipientTransferSourceType = "bank_account"
	RecipientTransferSourceTypeBitcoinReceiver RecipientTransferSourceType = "bitcoin_receiver"
	RecipientTransferSourceTypeCard            RecipientTransferSourceType = "card"
)

type RecipientTransferStatus 

type RecipientTransferStatus string

RecipientTransferStatus is the list of allowed values for the recipient_transfer's status. 

const (
	RecipientTransferStatusFailed    RecipientTransferStatus = "failed"
	RecipientTransferStatusInTransit RecipientTransferStatus = "in_transit"
	RecipientTransferStatusPaid      RecipientTransferStatus = "paid"
	RecipientTransferStatusPending   RecipientTransferStatus = "pending"
)

type RecipientTransferType 

type RecipientTransferType string

RecipientTransferType is the list of allowed values for the recipient_transfer's type. 

const (
	RecipientTransferTypeBankAccount RecipientTransferType = "bank_account"
	RecipientTransferTypeCard        RecipientTransferType = "card"
)

type RecipientType 

type RecipientType string

RecipientType is the list of allowed values for the recipient's type. 

const (
	RecipientTypeIndividual  RecipientType = "individual"
	RecipientTypeCorporation RecipientType = "corporation"
)

type RedirectFlow 

type RedirectFlow struct {
	FailureReason SourceRedirectFlowFailureReason `json:"failure_reason"`
	ReturnURL     string                          `json:"return_url"`
	Status        SourceRedirectFlowStatus        `json:"status"`
	URL           string                          `json:"url"`
}

ReceiverFlow informs of the state of a redirect authentication flow.

type RedirectParams 

type RedirectParams struct {
	ReturnURL *string `form:"return_url"`
}

type Refund 

type Refund struct {
	Amount             int64               `json:"amount"`
	BalanceTransaction *BalanceTransaction `json:"balance_transaction"`
	Charge             *Charge             `json:"charge"`
	Created            int64               `json:"created"`
	Currency           Currency            `json:"currency"`
	ID                 string              `json:"id"`
	Metadata           map[string]string   `json:"metadata"`
	Reason             RefundReason        `json:"reason"`
	ReceiptNumber      string              `json:"receipt_number"`
	Status             RefundStatus        `json:"status"`
}

Refund is the resource representing a Stripe refund. For more details see https://stripe.com/docs/api#refunds.

func (*Refund) UnmarshalJSON 

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

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

type RefundList 

type RefundList struct {
	ListMeta
	Data []*Refund `json:"data"`
}

RefundList is a list object for refunds.

type RefundListParams 

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

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

type RefundParams 

type RefundParams struct {
	Params               `form:"*"`
	Amount               *int64  `form:"amount"`
	Charge               *string `form:"charge"`
	Reason               *string `form:"reason"`
	RefundApplicationFee *bool   `form:"refund_application_fee"`
	ReverseTransfer      *bool   `form:"reverse_transfer"`
}

RefundParams is the set of parameters that can be used when refunding a charge. For more details see https://stripe.com/docs/api#refund.

type RefundReason 

type RefundReason string

RefundReason is, if set, the reason the refund is being made 

const (
	RefundReasonDuplicate           RefundReason = "duplicate"
	RefundReasonFraudulent          RefundReason = "fraudulent"
	RefundReasonRequestedByCustomer RefundReason = "requested_by_customer"
)

type RefundStatus 

type RefundStatus string

RefundStatus is the status of the refund. 

const (
	RefundStatusCanceled  RefundStatus = "canceled"
	RefundStatusFailed    RefundStatus = "failed"
	RefundStatusPending   RefundStatus = "pending"
	RefundStatusSucceeded RefundStatus = "succeeded"
)

type Reversal 

type Reversal struct {
	Amount             int64               `json:"amount"`
	BalanceTransaction *BalanceTransaction `json:"balance_transaction"`
	Created            int64               `json:"created"`
	Currency           Currency            `json:"currency"`
	ID                 string              `json:"id"`
	Metadata           map[string]string   `json:"metadata"`
	Transfer           string              `json:"transfer"`
}

Reversal represents a transfer reversal.

func (*Reversal) UnmarshalJSON 

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

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

type ReversalList 

type ReversalList struct {
	ListMeta
	Data []*Reversal `json:"data"`
}

ReversalList is a list of object for reversals.

type ReversalListParams 

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

ReversalListParams is the set of parameters that can be used when listing reversals.

type ReversalParams 

type ReversalParams struct {
	Params               `form:"*"`
	Amount               *int64  `form:"amount"`
	RefundApplicationFee *bool   `form:"refund_application_fee"`
	Transfer             *string `form:"-"` // Included in URL
}

ReversalParams is the set of parameters that can be used when reversing a transfer.

type Review 

type Review struct {
	Charge   *Charge          `json:"charge"`
	Created  int64            `json:"created"`
	ID       string           `json:"id"`
	Livemode bool             `json:"livemode"`
	Open     bool             `json:"open"`
	Reason   ReviewReasonType `json:"reason"`
}

func (*Review) UnmarshalJSON 

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

type ReviewReasonType 

type ReviewReasonType string

ReviewReasonType describes the reason why the review is open or closed. 

const (
	ReviewReasonApproved        ReviewReasonType = "approved"
	ReviewReasonDisputed        ReviewReasonType = "disputed"
	ReviewReasonManual          ReviewReasonType = "manual"
	ReviewReasonRefunded        ReviewReasonType = "refunded"
	ReviewReasonRefundedAsFraud ReviewReasonType = "refunded_as_fraud"
	ReviewReasonRule            ReviewReasonType = "rule"
)

type SKU 

type SKU struct {
	Active            bool               `json:"active"`
	Attributes        map[string]string  `json:"attributes"`
	Created           int64              `json:"created"`
	Currency          Currency           `json:"currency"`
	Description       string             `json:"description"`
	ID                string             `json:"id"`
	Image             string             `json:"image"`
	Inventory         *Inventory         `json:"inventory"`
	Livemode          bool               `json:"livemode"`
	Metadata          map[string]string  `json:"metadata"`
	PackageDimensions *PackageDimensions `json:"package_dimensions"`
	Price             int64              `json:"price"`
	Product           *Product           `json:"product"`
	Updated           int64              `json:"updated"`
}

func (*SKU) UnmarshalJSON 

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

type SKUInventoryType 

type SKUInventoryType string

SKUInventoryType describe's the possible value for inventory type 

const (
	SKUInventoryTypeBucket   SKUInventoryType = "bucket"
	SKUInventoryTypeFinite   SKUInventoryType = "finite"
	SKUInventoryTypeInfinite SKUInventoryType = "infinite"
)

type SKUInventoryValue 

type SKUInventoryValue string

SKUInventoryValue describe's the possible value for inventory value 

const (
	SKUInventoryValueInStock    SKUInventoryValue = "in_stock"
	SKUInventoryValueLimited    SKUInventoryValue = "limited"
	SKUInventoryValueOutOfStock SKUInventoryValue = "out_of_stock"
)

type SKUList 

type SKUList struct {
	ListMeta
	Data []*SKU `json:"data"`
}

type SKUListParams 

type SKUListParams struct {
	ListParams `form:"*"`
	Active     *bool             `form:"active"`
	Attributes map[string]string `form:"attributes"`
	IDs        []*string         `form:"ids"`
	InStock    *bool             `form:"in_stock"`
	Product    *string           `form:"product"`
}

type SKUParams 

type SKUParams struct {
	Params            `form:"*"`
	Active            *bool                    `form:"active"`
	Attributes        map[string]string        `form:"attributes"`
	Currency          *string                  `form:"currency"`
	Description       *string                  `form:"description"`
	ID                *string                  `form:"id"`
	Image             *string                  `form:"image"`
	Inventory         *InventoryParams         `form:"inventory"`
	PackageDimensions *PackageDimensionsParams `form:"package_dimensions"`
	Price             *int64                   `form:"price"`
	Product           *string                  `form:"product"`
}

type Shipping 

type Shipping struct {
	Address        *Address `json:"address"`
	Carrier        string   `json:"carrier"`
	Name           string   `json:"name"`
	Phone          string   `json:"phone"`
	TrackingNumber string   `json:"tracking_number"`
}

type ShippingDetails 

type ShippingDetails struct {
	Address        *Address `json:"address"`
	Carrier        string   `json:"carrier"`
	Name           string   `json:"name"`
	Phone          string   `json:"phone"`
	TrackingNumber string   `json:"tracking_number"`
}

ShippingDetails is the structure containing shipping information.

type ShippingDetailsParams 

type ShippingDetailsParams struct {
	Address        *AddressParams `form:"address"`
	Carrier        *string        `form:"carrier"`
	Name           *string        `form:"name"`
	Phone          *string        `form:"phone"`
	TrackingNumber *string        `form:"tracking_number"`
}

ShippingDetailsParams is the structure containing shipping information as parameters

type ShippingMethod 

type ShippingMethod struct {
	Amount           int64             `json:"amount"`
	ID               string            `json:"id"`
	Currency         Currency          `json:"currency"`
	DeliveryEstimate *DeliveryEstimate `json:"delivery_estimate"`
	Description      string            `json:"description"`
}

type ShippingParams 

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

type Source 

type Source struct {
	Amount              int64                 `json:"amount"`
	ClientSecret        string                `json:"client_secret"`
	CodeVerification    *CodeVerificationFlow `json:"code_verification,omitempty"`
	Created             int64                 `json:"created"`
	Currency            Currency              `json:"currency"`
	Flow                SourceFlow            `json:"flow"`
	ID                  string                `json:"id"`
	Livemode            bool                  `json:"livemode"`
	Mandate             *SourceMandate        `json:"mandate"`
	Metadata            map[string]string     `json:"metadata"`
	Owner               *SourceOwner          `json:"owner"`
	Receiver            *ReceiverFlow         `json:"receiver,omitempty"`
	Redirect            *RedirectFlow         `json:"redirect,omitempty"`
	StatementDescriptor string                `json:"statement_descriptor"`
	Status              SourceStatus          `json:"status"`
	Type                string                `json:"type"`
	TypeData            map[string]interface{}
	Usage               SourceUsage `json:"usage"`
}

func (*Source) UnmarshalJSON 

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

UnmarshalJSON handles deserialization of an Source. This custom unmarshaling is needed to extract the type specific data (accessible under `TypeData`) but stored in JSON under a hash named after the `type` of the source.

type SourceCodeVerificationFlowStatus 

type SourceCodeVerificationFlowStatus string

SourceCodeVerificationFlowStatus represents the possible statuses of a code verification flow. 

const (
	SourceCodeVerificationFlowStatusFailed    SourceCodeVerificationFlowStatus = "failed"
	SourceCodeVerificationFlowStatusPending   SourceCodeVerificationFlowStatus = "pending"
	SourceCodeVerificationFlowStatusSucceeded SourceCodeVerificationFlowStatus = "succeeded"
)

type SourceFlow 

type SourceFlow string

SourceFlow represents the possible flows of a source object. 

const (
	SourceFlowCodeVerification SourceFlow = "code_verification"
	SourceFlowNone             SourceFlow = "none"
	SourceFlowReceiver         SourceFlow = "receiver"
	SourceFlowRedirect         SourceFlow = "redirect"
)

type SourceList 

type SourceList struct {
	ListMeta
	Data []*PaymentSource `json:"data"`
}

SourceList is a list object for cards.

type SourceListParams 

type SourceListParams struct {
	ListParams `form:"*"`
	Customer   *string `form:"-"` // Handled in URL
}

SourceListParams are used to enumerate the payment sources that are attached to a Customer.

type SourceMandate 

type SourceMandate struct {
	Acceptance         *SourceMandateAcceptance `json:"acceptance"`
	NotificationMethod string                   `json:"notification_method"`
	Reference          string                   `json:"reference"`
	URL                string                   `json:"url"`
}

type SourceMandateAcceptance 

type SourceMandateAcceptance struct {
	Date      string                        `json:"date"`
	IP        string                        `json:"ip"`
	Status    SourceMandateAcceptanceStatus `json:"status"`
	UserAgent string                        `json:"user_agent"`
}

type SourceMandateAcceptanceStatus 

type SourceMandateAcceptanceStatus string

SourceMandateAcceptanceStatus represents the possible failure reasons of a redirect flow. 

const (
	SourceMandateAcceptanceStatusAccepted SourceMandateAcceptanceStatus = "accepted"
	SourceMandateAcceptanceStatusRefused  SourceMandateAcceptanceStatus = "refused"
)

type SourceObjectDetachParams 

type SourceObjectDetachParams struct {
	Params   `form:"*"`
	Customer *string `form:"-"`
}

SourceObjectDetachParams is the set of parameters that can be used when detaching a source from a customer.

type SourceObjectParams 

type SourceObjectParams struct {
	Params              `form:"*"`
	Amount              *int64             `form:"amount"`
	Currency            *string            `form:"currency"`
	Customer            *string            `form:"customer"`
	Flow                *string            `form:"flow"`
	OriginalSource      *string            `form:"original_source"`
	Owner               *SourceOwnerParams `form:"owner"`
	Redirect            *RedirectParams    `form:"redirect"`
	StatementDescriptor *string            `form:"statement_descriptor"`
	Token               *string            `form:"token"`
	Type                *string            `form:"type"`
	TypeData            map[string]string  `form:"-"`
	Usage               *string            `form:"usage"`
}

func (*SourceObjectParams) AppendTo 

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

AppendTo implements custom encoding logic for SourceObjectParams so that the special "TypeData" value for is sent as the correct parameter based on the Source type

type SourceOwner 

type SourceOwner struct {
	Address         *Address `json:"address,omitempty"`
	Email           string   `json:"email"`
	Name            string   `json:"name"`
	Phone           string   `json:"phone"`
	VerifiedAddress *Address `json:"verified_address,omitempty"`
	VerifiedEmail   string   `json:"verified_email"`
	VerifiedName    string   `json:"verified_name"`
	VerifiedPhone   string   `json:"verified_phone"`
}

type SourceOwnerParams 

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

type SourceParams 

type SourceParams struct {
	Card  *CardParams `form:"-"`
	Token *string     `form:"source"`
}

SourceParams is a union struct used to describe an arbitrary payment source.

func SourceParamsFor 

func SourceParamsFor(obj interface{}) (*SourceParams, error)

SourceParamsFor creates SourceParams objects around supported payment sources, returning errors if not.

Currently supported source types are Card (CardParams) and Tokens/IDs (string), where Tokens could be single use card tokens or bitcoin receiver ids

func (*SourceParams) AppendTo 

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

type SourceRedirectFlowFailureReason 

type SourceRedirectFlowFailureReason string

SourceRedirectFlowFailureReason represents the possible failure reasons of a redirect flow. 

const (
	SourceRedirectFlowFailureReasonDeclined        SourceRedirectFlowFailureReason = "declined"
	SourceRedirectFlowFailureReasonProcessingError SourceRedirectFlowFailureReason = "processing_error"
	SourceRedirectFlowFailureReasonUserAbort       SourceRedirectFlowFailureReason = "user_abort"
)

type SourceRedirectFlowStatus 

type SourceRedirectFlowStatus string

SourceRedirectFlowStatus represents the possible statuses of a redirect flow. 

const (
	SourceRedirectFlowStatusFailed      SourceRedirectFlowStatus = "failed"
	SourceRedirectFlowStatusNotRequired SourceRedirectFlowStatus = "not_required"
	SourceRedirectFlowStatusPending     SourceRedirectFlowStatus = "pending"
	SourceRedirectFlowStatusSucceeded   SourceRedirectFlowStatus = "succeeded"
)

type SourceRefundAttributesMethod 

type SourceRefundAttributesMethod string

SourceRefundAttributesMethod are the possible method to retrieve a receiver's refund attributes. 

const (
	SourceRefundAttributesMethodEmail  SourceRefundAttributesMethod = "email"
	SourceRefundAttributesMethodManual SourceRefundAttributesMethod = "manual"
)

type SourceRefundAttributesStatus 

type SourceRefundAttributesStatus string

SourceRefundAttributesStatus are the possible status of a receiver's refund attributes. 

const (
	SourceRefundAttributesStatusAvailable SourceRefundAttributesStatus = "available"
	SourceRefundAttributesStatusMissing   SourceRefundAttributesStatus = "missing"
	SourceRefundAttributesStatusRequested SourceRefundAttributesStatus = "requested"
)

type SourceStatus 

type SourceStatus string

SourceStatus represents the possible statuses of a source object. 

const (
	SourceStatusCanceled   SourceStatus = "canceled"
	SourceStatusChargeable SourceStatus = "chargeable"
	SourceStatusConsumed   SourceStatus = "consumed"
	SourceStatusFailed     SourceStatus = "failed"
	SourceStatusPending    SourceStatus = "pending"
)

type SourceTransaction 

type SourceTransaction struct {
	Amount       int64    `json:"amount"`
	Created      int64    `json:"created"`
	Currency     Currency `json:"currency"`
	CustomerData string   `json:"customer_data"`
	ID           string   `json:"id"`
	Live         bool     `json:"livemode"`
	Source       string   `json:"source"`
	Type         string   `json:"type"`
	TypeData     map[string]interface{}
}

SourceTransaction is the resource representing a Stripe source transaction.

func (*SourceTransaction) UnmarshalJSON 

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

UnmarshalJSON handles deserialization of a SourceTransaction. This custom unmarshaling is needed to extract the type specific data (accessible under `TypeData`) but stored in JSON under a hash named after the `type` of the source transaction.

type SourceTransactionList 

type SourceTransactionList struct {
	ListMeta
	Data []*SourceTransaction `json:"data"`
}

SourceTransactionList is a list object for SourceTransactions.

type SourceTransactionListParams 

type SourceTransactionListParams struct {
	ListParams `form:"*"`
	Source     *string `form:"-"` // Sent in with the URL
}

SourceTransactionListParams is the set of parameters that can be used when listing SourceTransactions.

type SourceUsage 

type SourceUsage string

SourceUsage represents the possible usages of a source object. 

const (
	SourceUsageReusable  SourceUsage = "reusable"
	SourceUsageSingleUse SourceUsage = "single_use"
)

type SourceVerifyParams 

type SourceVerifyParams struct {
	Params   `form:"*"`
	Amounts  [2]int64  `form:"amounts"` // Amounts is used when verifying bank accounts
	Customer *string   `form:"-"`       // Goes in the URL
	Values   []*string `form:"values"`  // Values is used when verifying sources
}

SourceVerifyParams are used to verify a customer source For more details see https://stripe.com/docs/guides/ach-beta

type StatusTransitions 

type StatusTransitions struct {
	Canceled  int64 `json:"canceled"`
	Fulfilled int64 `json:"fulfiled"`
	Paid      int64 `json:"paid"`
	Returned  int64 `json:"returned"`
}

StatusTransitions are the timestamps at which the order status was updated https://stripe.com/docs/api#order_object

type Subscription 

type Subscription struct {
	ApplicationFeePercent float64               `json:"application_fee_percent"`
	Billing               SubscriptionBilling   `json:"billing"`
	BillingCycleAnchor    int64                 `json:"billing_cycle_anchor"`
	CanceledAt            int64                 `json:"canceled_at"`
	Created               int64                 `json:"created"`
	CurrentPeriodEnd      int64                 `json:"current_period_end"`
	CurrentPeriodStart    int64                 `json:"current_period_start"`
	Customer              *Customer             `json:"customer"`
	DaysUntilDue          int64                 `json:"days_until_due"`
	Discount              *Discount             `json:"discount"`
	CancelAtPeriodEnd     bool                  `json:"cancel_at_period_end"`
	EndedAt               int64                 `json:"ended_at"`
	ID                    string                `json:"id"`
	Items                 *SubscriptionItemList `json:"items"`
	Metadata              map[string]string     `json:"metadata"`
	Plan                  *Plan                 `json:"plan"`
	Quantity              int64                 `json:"quantity"`
	Start                 int64                 `json:"start"`
	Status                SubscriptionStatus    `json:"status"`
	TaxPercent            float64               `json:"tax_percent"`
	TrialEnd              int64                 `json:"trial_end"`
	TrialStart            int64                 `json:"trial_start"`
}

Subscription is the resource representing a Stripe subscription. For more details see https://stripe.com/docs/api#subscriptions.

func (*Subscription) UnmarshalJSON 

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

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

type SubscriptionBilling 

type SubscriptionBilling string

SubscriptionBilling is the type of billing method for this subscription's invoices. 

const (
	SubscriptionBillingChargeAutomatically SubscriptionBilling = "charge_automatically"
	SubscriptionBillingSendInvoice         SubscriptionBilling = "send_invoice"
)

type SubscriptionCancelParams 

type SubscriptionCancelParams struct {
	Params      `form:"*"`
	AtPeriodEnd *bool `form:"at_period_end"`
}

SubscriptionCancelParams is the set of parameters that can be used when canceling a subscription. For more details see https://stripe.com/docs/api#cancel_subscription

type SubscriptionItem 

type SubscriptionItem struct {
	Created  int64             `json:"created"`
	Deleted  bool              `json:"deleted"`
	ID       string            `json:"id"`
	Metadata map[string]string `json:"metadata"`
	Plan     *Plan             `json:"plan"`
	Quantity int64             `json:"quantity"`
}

SubscriptionItem is the resource representing a Stripe subscription item. For more details see https://stripe.com/docs/api#subscription_items.

type SubscriptionItemList 

type SubscriptionItemList struct {
	ListMeta
	Data []*SubscriptionItem `json:"data"`
}

SubscriptionItemList is a list of invoice items as retrieved from a list endpoint.

type SubscriptionItemListParams 

type SubscriptionItemListParams struct {
	ListParams   `form:"*"`
	Subscription *string `form:"subscription"`
}

SubscriptionItemListParams is the set of parameters that can be used when listing invoice items. For more details see https://stripe.com/docs/api#list_invoiceitems.

type SubscriptionItemParams 

type SubscriptionItemParams struct {
	Params        `form:"*"`
	ID            *string `form:"-"` // Handled in URL
	Plan          *string `form:"plan"`
	Prorate       *bool   `form:"prorate"`
	ProrationDate *int64  `form:"proration_date"`
	Quantity      *int64  `form:"quantity"`
	Subscription  *string `form:"subscription"`
}

SubscriptionItemParams is the set of parameters that can be used when creating or updating a subscription item. For more details see https://stripe.com/docs/api#create_subscription_item and https://stripe.com/docs/api#update_subscription_item.

type SubscriptionItemsParams 

type SubscriptionItemsParams struct {
	Params     `form:"*"`
	ClearUsage *bool   `form:"clear_usage"`
	Deleted    *bool   `form:"deleted"`
	ID         *string `form:"id"`
	Plan       *string `form:"plan"`
	Quantity   *int64  `form:"quantity"`
}

SubscriptionItemsParams is the set of parameters that can be used when creating or updating a subscription item on a subscription For more details see https://stripe.com/docs/api#create_subscription and https://stripe.com/docs/api#update_subscription.

type SubscriptionList 

type SubscriptionList struct {
	ListMeta
	Data []*Subscription `json:"data"`
}

SubscriptionList is a list object for subscriptions.

type SubscriptionListParams 

type SubscriptionListParams struct {
	ListParams   `form:"*"`
	Billing      string            `form:"billing"`
	Created      int64             `form:"created"`
	CreatedRange *RangeQueryParams `form:"created"`
	Customer     string            `form:"customer"`
	Plan         string            `form:"plan"`
	Status       string            `form:"status"`
}

SubscriptionListParams is the set of parameters that can be used when listing active subscriptions. For more details see https://stripe.com/docs/api#list_subscriptions.

type SubscriptionParams 

type SubscriptionParams struct {
	Params                      `form:"*"`
	ApplicationFeePercent       *float64                   `form:"application_fee_percent"`
	Billing                     *string                    `form:"billing"`
	BillingCycleAnchor          *int64                     `form:"billing_cycle_anchor"`
	BillingCycleAnchorNow       *bool                      `form:"-"` // See custom AppendTo
	BillingCycleAnchorUnchanged *bool                      `form:"-"` // See custom AppendTo
	CancelAtPeriodEnd           *bool                      `form:"cancel_at_period_end"`
	Card                        *CardParams                `form:"card"`
	Coupon                      *string                    `form:"coupon"`
	Customer                    *string                    `form:"customer"`
	DaysUntilDue                *int64                     `form:"days_until_due"`
	Items                       []*SubscriptionItemsParams `form:"items,indexed"`
	OnBehalfOf                  *string                    `form:"on_behalf_of"`
	Plan                        *string                    `form:"plan"`
	Prorate                     *bool                      `form:"prorate"`
	ProrationDate               *int64                     `form:"proration_date"`
	Quantity                    *int64                     `form:"quantity"`
	Source                      *string                    `form:"source"`
	TaxPercent                  *float64                   `form:"tax_percent"`
	TrialEnd                    *int64                     `form:"trial_end"`
	TrialEndNow                 *bool                      `form:"-"` // See custom AppendTo
	TrialFromPlan               *bool                      `form:"trial_from_plan"`
	TrialPeriodDays             *int64                     `form:"trial_period_days"`
}

SubscriptionParams is the set of parameters that can be used when creating or updating a subscription. For more details see https://stripe.com/docs/api#create_subscription and https://stripe.com/docs/api#update_subscription.

func (*SubscriptionParams) AppendTo 

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

AppendTo implements custom encoding logic for SubscriptionParams so that the special "now" value for billing_cycle_anchor and trial_end can be implemented (they're otherwise timestamps rather than strings).

type SubscriptionStatus 

type SubscriptionStatus string

SubscriptionStatus is the list of allowed values for the subscription's status. 

const (
	SubscriptionStatusActive   SubscriptionStatus = "active"
	SubscriptionStatusAll      SubscriptionStatus = "all"
	SubscriptionStatusCanceled SubscriptionStatus = "canceled"
	SubscriptionStatusPastDue  SubscriptionStatus = "past_due"
	SubscriptionStatusTrialing SubscriptionStatus = "trialing"
	SubscriptionStatusUnpaid   SubscriptionStatus = "unpaid"
)

type SupportedBackend 

type SupportedBackend string

SupportedBackend is an enumeration of supported Stripe endpoints. Currently supported values are "api" and "uploads".

type TOSAcceptanceParams 

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

TOSAcceptanceParams represents tos_acceptance during account creation/updates.

type ThreeDSecure 

type ThreeDSecure struct {
	Amount        int64              `json:"amount"`
	Authenticated bool               `json:"authenticated"`
	Card          *Card              `json:"card"`
	Created       int64              `json:"created"`
	Currency      Currency           `json:"currency"`
	ID            string             `json:"id"`
	Livemode      bool               `json:"livemode"`
	RedirectURL   string             `json:"redirect_url"`
	Status        ThreeDSecureStatus `json:"status"`
	Supported     string             `json:"supported"`
}

ThreeDSecure is the resource representing a Stripe 3DS object For more details see https://stripe.com/docs/api#three_d_secure.

type ThreeDSecureParams 

type ThreeDSecureParams struct {
	Params    `form:"*"`
	Amount    *int64  `form:"amount"`
	Card      *string `form:"card"`
	Currency  *string `form:"currency"`
	Customer  *string `form:"customer"`
	ReturnURL *string `form:"return_url"`
}

ThreeDSecureParams is the set of parameters that can be used when creating a 3DS object. For more details see https://stripe.com/docs/api#create_three_d_secure.

type ThreeDSecureStatus 

type ThreeDSecureStatus string

type Token 

type Token struct {
	BankAccount *BankAccount `json:"bank_account"`
	Card        *Card        `json:"card"`
	ClientIP    string       `json:"client_ip"`
	Created     int64        `json:"created"`

	// Email is an undocumented field but included for all tokens created
	// with Stripe Checkout.
	Email string `json:"email"`

	ID       string    `json:"id"`
	Livemode bool      `json:"livemode"`
	Type     TokenType `json:"type"`
	Used     bool      `json:"used"`
}

Token is the resource representing a Stripe token. For more details see https://stripe.com/docs/api#tokens.

type TokenParams 

type TokenParams struct {
	Params      `form:"*"`
	BankAccount *BankAccountParams `form:"bank_account"`
	Card        *CardParams        `form:"card"`
	Customer    *string            `form:"customer"`

	// Email is an undocumented parameter used by Stripe Checkout
	// It may be removed from the API without notice.
	Email *string `form:"email"`

	PII *PIIParams `form:"pii"`
}

TokenParams is the set of parameters that can be used when creating a token. For more details see https://stripe.com/docs/api#create_card_token and https://stripe.com/docs/api#create_bank_account_token.

type TokenType 

type TokenType string

TokenType is the list of allowed values for a token's type. 

const (
	TokenTypeAccount     TokenType = "account"
	TokenTypeCard        TokenType = "card"
	TokenTypeBankAccount TokenType = "bank_account"
	TokenTypePII         TokenType = "pii"
)

type Topup 

type Topup struct {
	Amount                   int64               `json:"amount"`
	ArrivalDate              int64               `json:"arrival_date"`
	BalanceTransaction       *BalanceTransaction `json:"balance_transaction"`
	Created                  int64               `json:"created"`
	Currency                 Currency            `json:"currency"`
	Description              string              `json:"description"`
	ExpectedAvailabilityDate int64               `json:"expected_availability_date"`
	FailureCode              string              `json:"failure_code"`
	FailureMessage           string              `json:"failure_message"`
	ID                       string              `json:"id"`
	Livemode                 bool                `json:"livemode"`
	Source                   *PaymentSource      `json:"source"`
	StatementDescriptor      string              `json:"statement_descriptor"`
	Status                   string              `json:"status"`
}

Topup is the resource representing a Stripe top-up. For more details see https://stripe.com/docs/api#topups.

type TopupList 

type TopupList struct {
	ListMeta
	Data []*Topup `json:"data"`
}

TopupList is a list of top-ups as retrieved from a list endpoint.

type TopupListParams 

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

TopupListParams is the set of parameters that can be used when listing top-ups. For more details see https://stripe.com/docs/api#list_topups.

type TopupParams 

type TopupParams struct {
	Params              `form:"*"`
	Amount              *int64        `form:"amount"`
	Currency            *string       `form:"currency"`
	Description         *string       `form:"description"`
	Source              *SourceParams `form:"*"` // SourceParams has custom encoding so brought to top level with "*"
	StatementDescriptor *string       `form:"statement_descriptor"`
}

TopupParams is the set of parameters that can be used when creating or updating a top-up. For more details see https://stripe.com/docs/api#create_topup and https://stripe.com/docs/api#update_topup.

func (*TopupParams) SetSource 

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

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

type Transfer 

type Transfer struct {
	Amount             int64                     `json:"amount"`
	AmountReversed     int64                     `json:"amount_reversed"`
	BalanceTransaction *BalanceTransaction       `json:"balance_transaction"`
	Created            int64                     `json:"created"`
	Currency           Currency                  `json:"currency"`
	Destination        *TransferDestination      `json:"destination"`
	DestinationPayment *Charge                   `json:"destination_payment"`
	ID                 string                    `json:"id"`
	Livemode           bool                      `json:"livemode"`
	Metadata           map[string]string         `json:"metadata"`
	Reversals          *ReversalList             `json:"reversals"`
	Reversed           bool                      `json:"reversed"`
	SourceTransaction  *BalanceTransactionSource `json:"source_transaction"`
	SourceType         TransferSourceType        `json:"source_type"`
	TransferGroup      string                    `json:"transfer_group"`
}

Transfer is the resource representing a Stripe transfer. For more details see https://stripe.com/docs/api#transfers.

func (*Transfer) UnmarshalJSON 

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

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

type TransferDestination 

type TransferDestination struct {
	Account *Account `json:"-"`
	ID      string   `json:"id"`
}

TransferDestination describes the destination of a Transfer. The Type should indicate which object is fleshed out For more details see https://stripe.com/docs/api/go#transfer_object

func (*TransferDestination) MarshalJSON 

func (d *TransferDestination) MarshalJSON() ([]byte, error)

MarshalJSON handles serialization of a TransferDestination. This custom marshaling is needed because we can only send a string ID as a destination, even though it can be expanded to a full object when retrieving

func (*TransferDestination) UnmarshalJSON 

func (d *TransferDestination) UnmarshalJSON(data []byte) error

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

type TransferList 

type TransferList struct {
	ListMeta
	Data []*Transfer `json:"data"`
}

TransferList is a list of transfers as retrieved from a list endpoint.

type TransferListParams 

type TransferListParams struct {
	ListParams    `form:"*"`
	Created       *int64            `form:"created"`
	CreatedRange  *RangeQueryParams `form:"created"`
	Destination   *string           `form:"destination"`
	TransferGroup *string           `form:"transfer_group"`
}

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

type TransferParams 

type TransferParams struct {
	Params            `form:"*"`
	Amount            *int64  `form:"amount"`
	Currency          *string `form:"currency"`
	Destination       *string `form:"destination"`
	SourceTransaction *string `form:"source_transaction"`
	SourceType        *string `form:"source_type"`
	TransferGroup     *string `form:"transfer_group"`
}

TransferParams is the set of parameters that can be used when creating or updating a transfer. For more details see https://stripe.com/docs/api#create_transfer and https://stripe.com/docs/api#update_transfer.

type TransferSourceType 

type TransferSourceType string

TransferSourceType is the list of allowed values for the transfer's source_type field. 

const (
	TransferSourceTypeAlipayAccount   TransferSourceType = "alipay_account"
	TransferSourceTypeBankAccount     TransferSourceType = "bank_account"
	TransferSourceTypeBitcoinReceiver TransferSourceType = "bitcoin_receiver"
	TransferSourceTypeCard            TransferSourceType = "card"
)

type UsageRecord 

type UsageRecord struct {
	ID               string `json:"id"`
	Live             bool   `json:"livemode"`
	Quantity         int64  `json:"quantity"`
	SubscriptionItem string `json:"subscription_item"`
	Timestamp        int64  `json:"timestamp"`
}

UsageRecord represents a usage record. See https://stripe.com/docs/api#usage_records

type UsageRecordParams 

type UsageRecordParams struct {
	Params           `form:"*"`
	Action           *string `form:"action"`
	Quantity         *int64  `form:"quantity"`
	SubscriptionItem *string `form:"-"` // passed in the URL
	Timestamp        *int64  `form:"timestamp"`
}

UsageRecordParams create a usage record for a specified subscription item and date, and fills it with a quantity.

type VerificationFieldsList 

type VerificationFieldsList struct {
	AdditionalFields []string `json:"additional"`
	Minimum          []string `json:"minimum"`
}

VerificationFieldsList lists the fields needed for an account verification. For more details see https://stripe.com/docs/api#country_spec_object-verification_fields.

Source Files

View all Source files

Directories

Path Synopsis
Package account provides API functions related to accounts.
 Package account provides API functions related to accounts.
Package applepaydomain provides the /apple_pay/domains APIs
 Package applepaydomain provides the /apple_pay/domains APIs
Package balance provides the /balance APIs
 Package balance provides the /balance APIs
Package bankaccount provides the /bank_accounts APIs
 Package bankaccount provides the /bank_accounts APIs
Package bitcoinreceiver provides the /bitcoin/receivers APIs.
 Package bitcoinreceiver provides the /bitcoin/receivers APIs.
Package bitcointransaction provides the /bitcoin/transactions APIs.
 Package bitcointransaction provides the /bitcoin/transactions APIs.
Package card provides the /cards APIs
 Package card provides the /cards APIs
Package charge provides API functions related to charges.
 Package charge provides API functions related to charges.
Package client provides a Stripe client for invoking APIs across all resources
 Package client provides a Stripe client for invoking APIs across all resources
Package countryspec provides the /country_specs APIs
 Package countryspec provides the /country_specs APIs
Package coupon provides the /coupons APIs
 Package coupon provides the /coupons APIs
Package customer provides the /customers APIs
 Package customer provides the /customers APIs
Package discount provides the discount-related APIs
 Package discount provides the discount-related APIs
Package ephemeralkey provides the /ephemeral_keys APIs
 Package ephemeralkey provides the /ephemeral_keys APIs
Package event provides the /events APIs
 Package event provides the /events APIs
Package exchangerate provides the /exchange_rates APIs
 Package exchangerate provides the /exchange_rates APIs
Package fee provides the /application_fees APIs
 Package fee provides the /application_fees APIs
Package feerefund provides the /application_fees/refunds APIs
 Package feerefund provides the /application_fees/refunds APIs
Package fileupload provides the file upload related APIs
 Package fileupload provides the file upload related APIs
Package invoice provides the /invoices APIs
 Package invoice provides the /invoices APIs
Package invoiceitem provides the /invoiceitems APIs
 Package invoiceitem provides the /invoiceitems APIs
Package loginlink provides the /login_links APIs
 Package loginlink provides the /login_links APIs
Package paymentsource provides the /sources APIs
 Package paymentsource provides the /sources APIs
Package payout provides the /payouts APIs
 Package payout provides the /payouts APIs
Package plan provides the /plans APIs
 Package plan provides the /plans APIs
Package recipient provides the /recipients APIs
 Package recipient provides the /recipients APIs
Package recipienttransfer provides the /recipient_transfers APIs
 Package recipienttransfer provides the /recipient_transfers APIs
Package refund provides the /refunds APIs
 Package refund provides the /refunds APIs
Package reversal provides the /transfers/reversals APIs
 Package reversal provides the /transfers/reversals APIs
Package sourcetransaction provides the /source/transactions APIs.
 Package sourcetransaction provides the /source/transactions APIs.
Package sub provides the /subscriptions APIs
 Package sub provides the /subscriptions APIs
Package subitem provides the /subscription_items APIs
 Package subitem provides the /subscription_items APIs
Package threedsecure provides the /3d_secure APIs
 Package threedsecure provides the /3d_secure APIs
Package token provides the /tokens APIs
 Package token provides the /tokens APIs
Package transfer provides the /transfers APIs
 Package transfer provides the /transfers APIs
Package usage_record provides the /subscription_items/{SUBSCRIPTION_ITEM_ID}/usage_records APIs
 Package usage_record provides the /subscription_items/{SUBSCRIPTION_ITEM_ID}/usage_records APIs

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.