stripe

package module
v58.1.0+incompatible Latest Latest
Warning

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

Go to latest
Published: Mar 19, 2019 License: MIT Imports: 24 Imported by: 0

README

Go Stripe

GoDoc Build Status Coverage Status

The official Stripe Go client library.

Installation

Install stripe-go with:

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

Then, import it using:

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

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

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

module github.com/my/package

require (
    github.com/stripe/stripe-go v58.1.0
)

And use the same style of import paths as above:

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

Documentation

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

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

Below are a few simple examples:

Customers
params := &stripe.CustomerParams{
	AccountBalance:     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 event.Data.Raw property to unmarshal to the appropriate struct.

Authentication with Connect

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

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

// For a list request
listParams := &stripe.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
}
Configuring Automatic Retries

The library can be configured to automatically retry requests that fail due to an intermittent network problem or other knowingly non-deterministic errors:

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

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

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

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

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

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

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

go get -t -v

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

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

Run all tests:

make test

Run tests for one package:

go test ./invoice

Run a single test:

go test ./invoice -run TestInvoiceGet

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

Documentation

Overview

Package stripe provides the binding for Stripe REST APIs.

Index

Examples

Constants

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

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

View Source
const (
	// APIVersion is the currently supported API version
	APIVersion string = "2019-03-14"

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

	// UnknownPlatform is the string returned as the system name if we couldn't get
	// one from `uname`.
	UnknownPlatform string = "unknown platform"

	// UploadsBackend is a constant representing the uploads service backend.
	UploadsBackend SupportedBackend = "uploads"

	// UploadsURL is the URL of the uploads service backend.
	UploadsURL string = "https://files.stripe.com"
)
View Source
const (
	UsageRecordActionIncrement string = "increment"
	UsageRecordActionSet       string = "set"
)

Possible values for the action parameter on usage record creation.

Variables

View Source
var EnableTelemetry = false

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

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

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

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

func (*Account) UnmarshalJSON

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

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

type AccountAddress

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

	// Town/cho-me. Note that this is only used for Kana/Kanji representations
	// of an address.
	Town string `json:"town"`
}

AccountAddress is the structure for an account address.

type AccountAddressParams

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

	// Town/cho-me. Note that this is only used for Kana/Kanji representations
	// of an address.
	Town *string `form:"town"`
}

AccountAddressParams represents an address during account creation/updates.

type AccountBusinessProfile

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

AccountBusinessProfile represents optional information related to the business.

type AccountBusinessProfileParams

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

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

type AccountBusinessType

type AccountBusinessType string

AccountBusinessType describes the business type associated with an account.

const (
	AccountBusinessTypeCompany    AccountBusinessType = "company"
	AccountBusinessTypeIndividual AccountBusinessType = "individual"
)

List of values that AccountBusinessType can take.

type AccountCapabilities

type AccountCapabilities struct {
	CardPayments     AccountCapabilityStatus `json:"card_payments"`
	LegacyPayments   AccountCapabilityStatus `json:"legacy_payments"`
	PlatformPayments AccountCapabilityStatus `json:"platform_payments"`
}

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

type AccountCapability

type AccountCapability string

AccountCapability maps to a given capability for an account.

const (
	AccountCapabilityCardPayments     AccountCapability = "card_payments"
	AccountCapabilityLegacyPayments   AccountCapability = "legacy_payments"
	AccountCapabilityPlatformPayments AccountCapability = "platform_payments"
)

List of values that AccountCapability can take.

type AccountCapabilityStatus

type AccountCapabilityStatus string

AccountCapabilityStatus is the status a given capability can have

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

List of values that AccountCapabilityStatus can take.

type AccountCompany

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

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

type AccountCompanyParams

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

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

type AccountDeclineOn

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

AccountDeclineOn represents card charges decline behavior for that account.

type AccountDeclineSettingsParams

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

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

type AccountExternalAccountParams

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

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

func (*AccountExternalAccountParams) AppendTo

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

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

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

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

type AccountLinkCollect

type AccountLinkCollect string

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

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

List of values that AccountLinkCollect can take.

type AccountLinkParams

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

AccountLinkParams are the parameters allowed during an account link creation.

type AccountLinkType

type AccountLinkType string

AccountLinkType is the type of an account link.

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

List of values that AccountLinkType can take.

type AccountList

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

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

type AccountListParams

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

AccountListParams are the parameters allowed during account listing.

type AccountParams

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

AccountParams are the parameters allowed during account creation/updates.

type AccountPayoutSchedule

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

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

type AccountRejectParams

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

AccountRejectParams is the structure for the Reject function.

type AccountRejectReason

type AccountRejectReason string

AccountRejectReason describes the valid reason to reject an account

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

List of values that AccountRejectReason can take.

type AccountRequirements

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

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

type AccountRequirementsDisabledReason

type AccountRequirementsDisabledReason string

AccountRequirementsDisabledReason describes why an account is disabled.

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

List of values that AccountRequirementsDisabledReason can take.

type AccountSettings

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

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

type AccountSettingsBranding

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

AccountSettingsBranding represents settings specific to the account's branding.

type AccountSettingsBrandingParams

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

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

type AccountSettingsCardPayments

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

AccountSettingsCardPayments represents settings specific to card charging on the account.

type AccountSettingsCardPaymentsParams

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

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

type AccountSettingsDashboard

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

AccountSettingsDashboard represents settings specific to the account's Dashboard.

type AccountSettingsDashboardParams

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

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

type AccountSettingsParams

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

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

type AccountSettingsPayments

type AccountSettingsPayments struct {
	StatementDescriptor string `json:"statement_descriptor"`
}

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

type AccountSettingsPaymentsParams

type AccountSettingsPaymentsParams struct {
	StatementDescriptor *string `form:"statement_descriptor"`
}

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

type AccountSettingsPayouts

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

AccountSettingsPayouts represents settings specific to the account’s payouts.

type AccountSettingsPayoutsParams

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

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

type AccountTOSAcceptance

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

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

type AccountTOSAcceptanceParams

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

AccountTOSAcceptanceParams represents tos_acceptance during account creation/updates.

type AccountType

type AccountType string

AccountType is the type of an account.

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

List of values that AccountType can take.

type Address

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

Address describes common properties for an Address hash.

type AddressParams

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

AddressParams describes the common parameters for an Address.

type Amount

type Amount struct {
	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"`
	PartnerID string `json:"partner_id"`
	URL       string `json:"url"`
	Version   string `json:"version"`
}

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

type ApplePayDomain

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

ApplePayDomain is the resource representing a Stripe ApplePayDomain object

type ApplePayDomainList

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

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

type ApplePayDomainListParams

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

ApplePayDomainListParams are the parameters allowed during ApplePayDomain listing.

type ApplePayDomainParams

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

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

type Application

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

Application describes the properties for an Application.

func (*Application) UnmarshalJSON

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

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

type ApplicationFee

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

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

func (*ApplicationFee) UnmarshalJSON

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

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

type ApplicationFeeList

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

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

type ApplicationFeeListParams

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

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

type ApplicationFeeParams

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

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

type AuthenticationError

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

AuthenticationError is a failure to properly authenticate during a request.

func (*AuthenticationError) Error

func (e *AuthenticationError) Error() string

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

type AuthorizationControlsParams

type AuthorizationControlsParams struct {
	AllowedCategories []*string `form:"allowed_categories"`
	BlockedCategories []*string `form:"blocked_categories"`
	MaxAmount         *int64    `form:"max_amount"`
	MaxApprovals      *int64    `form:"max_approvals"`
}

AuthorizationControlsParams is the set of parameters that can be used for the shipping parameter.

type Backend

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

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

func GetBackend

func GetBackend(backendType SupportedBackend) Backend

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

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

func GetBackendWithConfig

func GetBackendWithConfig(backendType SupportedBackend, config *BackendConfig) Backend

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

type BackendConfig

type BackendConfig struct {
	// EnableTelemetry allows request metrics (request id and duration) to be sent
	// to Stripe in subsequent requests via the `X-Stripe-Client-Telemetry` header.
	//
	// Defaults to false.
	EnableTelemetry bool

	// HTTPClient is an HTTP client instance to use when making API requests.
	//
	// If left unset, it'll be set to a default HTTP client for the package.
	HTTPClient *http.Client

	// LogLevel is the logging level of the library and defined by:
	//
	// 0: no logging
	// 1: errors only
	// 2: errors + informational (default)
	// 3: errors + informational + debug
	//
	// Defaults to 0 (no logging), so please make sure to set this if you want
	// to see logging output in your custom configuration.
	LogLevel int

	// Logger is where this backend will write its logs.
	//
	// If left unset, it'll be set to Logger.
	Logger Printfer

	// MaxNetworkRetries sets maximum number of times that the library will
	// retry requests that appear to have failed due to an intermittent
	// problem.
	//
	// Defaults to 0.
	MaxNetworkRetries int

	// URL is the base URL to use for API paths.
	//
	// If left empty, it'll be set to the default for the SupportedBackend.
	URL string
}

BackendConfig is used to configure a new Stripe backend.

type BackendImplementation

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

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

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

func (*BackendImplementation) Call

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

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

func (*BackendImplementation) CallMultipart

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

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

func (*BackendImplementation) CallRaw

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

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

func (*BackendImplementation) Do

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

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

func (*BackendImplementation) NewRequest

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

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

func (*BackendImplementation) ResponseToError

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

ResponseToError converts a stripe response to an Error.

func (*BackendImplementation) SetMaxNetworkRetries

func (s *BackendImplementation) SetMaxNetworkRetries(maxNetworkRetries int)

SetMaxNetworkRetries sets max number of retries on failed requests

This function is deprecated. Please use GetBackendWithConfig instead.

func (*BackendImplementation) SetNetworkRetriesSleep

func (s *BackendImplementation) SetNetworkRetriesSleep(sleep bool)

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

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

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"`
	IssuingAuthorization *IssuingAuthorization        `json:"-"`
	IssuingTransaction   *IssuingAuthorization        `json:"-"`
	Payout               *Payout                      `json:"-"`
	RecipientTransfer    *RecipientTransfer           `json:"-"`
	Refund               *Refund                      `json:"-"`
	Reversal             *Reversal                    `json:"-"`
	Transfer             *Transfer                    `json:"-"`
	Type                 BalanceTransactionSourceType `json:"object"`
}

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

func (*BalanceTransactionSource) 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"
	BalanceTransactionSourceTypeIssuingAuthorization BalanceTransactionSourceType = "issuing.authorization"
	BalanceTransactionSourceTypeIssuingTransaction   BalanceTransactionSourceType = "issuing.transaction"
	BalanceTransactionSourceTypePayout               BalanceTransactionSourceType = "payout"
	BalanceTransactionSourceTypeRecipientTransfer    BalanceTransactionSourceType = "recipient_transfer"
	BalanceTransactionSourceTypeRefund               BalanceTransactionSourceType = "refund"
	BalanceTransactionSourceTypeReversal             BalanceTransactionSourceType = "reversal"
	BalanceTransactionSourceTypeTransfer             BalanceTransactionSourceType = "transfer"
)

List of values that BalanceTransactionSourceType can take.

type BalanceTransactionStatus

type BalanceTransactionStatus string

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

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

List of values that BalanceTransactionStatus can take.

type BalanceTransactionType

type BalanceTransactionType string

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

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

List of values that BalanceTransactionType can take.

type BankAccount

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

BankAccount represents a Stripe bank account.

func (*BankAccount) UnmarshalJSON

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

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

type BankAccountAccountHolderType

type BankAccountAccountHolderType string

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

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

List of values that BankAccountAccountHolderType can take.

type BankAccountList

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

BankAccountList is a list object for bank accounts.

type BankAccountListParams

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

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

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

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

func (*BankAccountListParams) AppendTo

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

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

type BankAccountParams

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

	// Account is the identifier of the parent account under which bank
	// accounts are nested.
	Account *string `form:"-"`

	AccountHolderName  *string `form:"account_holder_name"`
	AccountHolderType  *string `form:"account_holder_type"`
	AccountNumber      *string `form:"account_number"`
	Country            *string `form:"country"`
	Currency           *string `form:"currency"`
	Customer           *string `form:"-"`
	DefaultForCurrency *bool   `form:"default_for_currency"`
	RoutingNumber      *string `form:"routing_number"`

	// Token is a token referencing an external account like one returned from
	// Stripe.js.
	Token *string `form:"-"`

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

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

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

func (*BankAccountParams) AppendToAsSourceOrExternalAccount

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

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

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

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

type BankAccountStatus

type BankAccountStatus string

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

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

List of values that BankAccountStatus can take.

type BillingDetails

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

BillingDetails represents the billing details associated with a PaymentMethod.

type BillingDetailsParams

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

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

type BitcoinReceiver

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

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

func (*BitcoinReceiver) UnmarshalJSON

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

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

type BitcoinReceiverList

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

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

type BitcoinReceiverListParams

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

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

type BitcoinTransaction

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

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

func (*BitcoinTransaction) UnmarshalJSON

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

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

type BitcoinTransactionList

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

BitcoinTransactionList is a list object for BitcoinTransactions. It is a child object of 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"`
	ApplicationFeeAmount *int64   `form:"application_fee_amount"`
	ExchangeRate         *float64 `form:"exchange_rate"`
	ReceiptEmail         *string  `form:"receipt_email"`
	StatementDescriptor  *string  `form:"statement_descriptor"`

	// This property is considered deprecated. Prefer using ApplicationFeeAmount
	ApplicationFee *int64 `form:"application_fee"`
}

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

type Card

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

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

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

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

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

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

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

func (*Card) UnmarshalJSON

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

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

type CardAvailablePayoutMethod

type CardAvailablePayoutMethod string

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

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

List of values that CardAvailablePayoutMethod can take.

type CardBrand

type CardBrand string

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

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

List of values that CardBrand can take.

type CardError

type CardError struct {
	DeclineCode 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"
)

List of values that CardFunding can take.

type CardList

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

CardList is a list object for cards.

type CardListParams

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

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

func (*CardListParams) AppendTo

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

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

type CardParams

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

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

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

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

func (*CardParams) AppendToAsCardSourceOrExternalAccount

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

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

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

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

type CardTokenizationMethod

type CardTokenizationMethod string

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

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

List of values that CardTokenizationMethod can take.

type CardVerification

type CardVerification string

CardVerification is the list of allowed verification responses.

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

List of values that CardVerification can take.

type Charge

type Charge struct {
	Amount               int64                       `json:"amount"`
	AmountRefunded       int64                       `json:"amount_refunded"`
	Application          *Application                `json:"application"`
	ApplicationFee       *ApplicationFee             `json:"application_fee"`
	ApplicationFeeAmount int64                       `json:"application_fee_amount"`
	AuthorizationCode    string                      `json:"authorization_code"`
	BalanceTransaction   *BalanceTransaction         `json:"balance_transaction"`
	BillingDetails       *BillingDetails             `json:"billing_details"`
	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"`
	Level3               ChargeLevel3                `json:"level3"`
	Livemode             bool                        `json:"livemode"`
	Metadata             map[string]string           `json:"metadata"`
	OnBehalfOf           *Account                    `json:"on_behalf_of"`
	Outcome              *ChargeOutcome              `json:"outcome"`
	Paid                 bool                        `json:"paid"`
	PaymentIntent        string                      `json:"payment_intent"`
	PaymentMethod        string                      `json:"payment_method"`
	PaymentMethodDetails *ChargePaymentMethodDetails `json:"payment_method_details"`
	ReceiptEmail         string                      `json:"receipt_email"`
	ReceiptNumber        string                      `json:"receipt_number"`
	ReceiptURL           string                      `json:"receipt_url"`
	Refunded             bool                        `json:"refunded"`
	Refunds              *RefundList                 `json:"refunds"`
	Review               *Review                     `json:"review"`
	Shipping             *ShippingDetails            `json:"shipping"`
	Source               *PaymentSource              `json:"source"`
	SourceTransfer       *Transfer                   `json:"source_transfer"`
	StatementDescriptor  string                      `json:"statement_descriptor"`
	Status               string                      `json:"status"`
	Transfer             *Transfer                   `json:"transfer"`
	TransferData         *ChargeTransferData         `json:"transfer_data"`
	TransferGroup        string                      `json:"transfer_group"`
}

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

Example (Get)
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"
)

List of values that ChargeFraudStripeReport can take.

type ChargeFraudUserReport

type ChargeFraudUserReport string

ChargeFraudUserReport is the list of allowed values for reporting fraud.

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

List of values that ChargeFraudUserReport can take.

type ChargeLevel3

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

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

type ChargeLevel3LineItem

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

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

type ChargeLevel3LineItemsParams

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

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

type ChargeLevel3Params

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

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

type ChargeList

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

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

type ChargeListParams

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

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

type ChargeOutcome

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

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

type ChargeOutcomeRule

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

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

func (*ChargeOutcomeRule) UnmarshalJSON

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

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

type ChargeParams

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

	// This property is considered deprecated. Prefer using ApplicationFeeAmount
	ApplicationFee *int64 `form:"application_fee"`
}

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

func (*ChargeParams) SetSource

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

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

type ChargePaymentMethodDetails

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

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

type ChargePaymentMethodDetailsAchCreditTransfer

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

ChargePaymentMethodDetailsAchCreditTransfer represents details about the ACH Credit Transfer PaymentMethod.

type ChargePaymentMethodDetailsAchDebit

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

ChargePaymentMethodDetailsAchDebit represents details about the ACH Debit PaymentMethod.

type ChargePaymentMethodDetailsAlipay

type ChargePaymentMethodDetailsAlipay struct {
}

ChargePaymentMethodDetailsAlipay represents details about the Alipay PaymentMethod.

type ChargePaymentMethodDetailsBancontact

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

ChargePaymentMethodDetailsBancontact represents details about the Bancontact PaymentMethod.

type ChargePaymentMethodDetailsBitcoin

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

ChargePaymentMethodDetailsBitcoin represents details about the Bitcoin PaymentMethod.

type ChargePaymentMethodDetailsCard

type ChargePaymentMethodDetailsCard struct {
	Brand        PaymentMethodCardBrand                      `json:"brand"`
	Checks       *ChargePaymentMethodDetailsCardChecks       `json:"checks"`
	Country      string                                      `json:"country"`
	ExpMonth     uint64                                      `json:"exp_month"`
	ExpYear      uint64                                      `json:"exp_year"`
	Fingerprint  string                                      `json:"fingerprint"`
	Funding      CardFunding                                 `json:"funding"`
	Last4        string                                      `json:"last4"`
	ThreeDSecure *ChargePaymentMethodDetailsCardThreeDSecure `json:"three_d_secure"`
	Wallet       *ChargePaymentMethodDetailsCardWallet       `json:"wallet"`

	// Please note that the fields below are for internal use only and are not returned
	// as part of standard API requests.
	Description string `json:"description"`
	IIN         string `json:"iin"`
	Issuer      string `json:"issuer"`
}

ChargePaymentMethodDetailsCard represents details about the Card PaymentMethod.

type ChargePaymentMethodDetailsCardChecks

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

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

type ChargePaymentMethodDetailsCardPresent

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

ChargePaymentMethodDetailsCardPresent represents details about the Card Present PaymentMethod.

type ChargePaymentMethodDetailsCardPresentReceipt

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

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

type ChargePaymentMethodDetailsCardThreeDSecure

type ChargePaymentMethodDetailsCardThreeDSecure struct {
}

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

type ChargePaymentMethodDetailsCardWallet

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

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

type ChargePaymentMethodDetailsCardWalletAmexExpressCheckout

type ChargePaymentMethodDetailsCardWalletAmexExpressCheckout struct {
}

ChargePaymentMethodDetailsCardWalletAmexExpressCheckout represents the details of the Amex Express Checkout wallet.

type ChargePaymentMethodDetailsCardWalletApplePay

type ChargePaymentMethodDetailsCardWalletApplePay struct {
}

ChargePaymentMethodDetailsCardWalletApplePay represents the details of the Apple Pay wallet.

type ChargePaymentMethodDetailsCardWalletGooglePay

type ChargePaymentMethodDetailsCardWalletGooglePay struct {
}

ChargePaymentMethodDetailsCardWalletGooglePay represents the details of the Google Pay wallet.

type ChargePaymentMethodDetailsCardWalletMasterpass

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

ChargePaymentMethodDetailsCardWalletMasterpass represents the details of the Masterpass wallet.

type ChargePaymentMethodDetailsCardWalletSamsungPay

type ChargePaymentMethodDetailsCardWalletSamsungPay struct {
}

ChargePaymentMethodDetailsCardWalletSamsungPay represents the details of the Samsung Pay wallet.

type ChargePaymentMethodDetailsCardWalletVisaCheckout

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

ChargePaymentMethodDetailsCardWalletVisaCheckout represents the details of the Visa Checkout wallet.

type ChargePaymentMethodDetailsEps

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

ChargePaymentMethodDetailsEps represents details about the EPS PaymentMethod.

type ChargePaymentMethodDetailsGiropay

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

ChargePaymentMethodDetailsGiropay represents details about the Giropay PaymentMethod.

type ChargePaymentMethodDetailsIdeal

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

ChargePaymentMethodDetailsIdeal represents details about the Ideal PaymentMethod.

type ChargePaymentMethodDetailsMultibanco

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

ChargePaymentMethodDetailsMultibanco represents details about the Multibanco PaymentMethod.

type ChargePaymentMethodDetailsP24

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

ChargePaymentMethodDetailsP24 represents details about the P24 PaymentMethod.

type ChargePaymentMethodDetailsSepaDebit

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

ChargePaymentMethodDetailsSepaDebit represents details about the Sepa Debit PaymentMethod.

type ChargePaymentMethodDetailsSofort

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

ChargePaymentMethodDetailsSofort represents details about the Sofort PaymentMethod.

type ChargePaymentMethodDetailsStripeAccount

type ChargePaymentMethodDetailsStripeAccount struct {
}

ChargePaymentMethodDetailsStripeAccount represents details about the StripeAccount PaymentMethod.

type ChargePaymentMethodDetailsType

type ChargePaymentMethodDetailsType string

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

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

List of values that ChargeFraudUserReport can take.

type ChargePaymentMethodDetailsWechat

type ChargePaymentMethodDetailsWechat struct {
}

ChargePaymentMethodDetailsWechat represents details about the Wechat PaymentMethod.

type ChargeTransferData

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

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

type ChargeTransferDataParams

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

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

type CodeVerificationFlow

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

CodeVerificationFlow informs of the state of a verification authentication flow.

type Country

type Country string

Country is the list of supported countries

type CountrySpec

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

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

type CountrySpecList

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

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

type CountrySpecListParams

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

CountrySpecListParams are the parameters allowed during CountrySpec listing.

type CountrySpecParams

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

CountrySpecParams are the parameters allowed during CountrySpec retrieval.

type Coupon

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

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

func (*Coupon) UnmarshalJSON

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

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

type CouponDuration

type CouponDuration string

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

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

List of values that CouponDuration can take.

type CouponList

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

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

type CouponListParams

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

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

type CouponParams

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

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

type Currency

type Currency string

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

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

List of values that Currency can take.

type Customer

type Customer struct {
	AccountBalance      int64                        `json:"account_balance"`
	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"`
	InvoicePrefix       string                       `json:"invoice_prefix"`
	Livemode            bool                         `json:"livemode"`
	Metadata            map[string]string            `json:"metadata"`
	Shipping            *CustomerShippingDetails     `json:"shipping"`
	Sources             *SourceList                  `json:"sources"`
	Subscriptions       *SubscriptionList            `json:"subscriptions"`
	TaxInfo             *CustomerTaxInfo             `json:"tax_info"`
	TaxInfoVerification *CustomerTaxInfoVerification `json:"tax_info_verification"`
}

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"`
	Coupon         *string                        `form:"coupon"`
	DefaultSource  *string                        `form:"default_source"`
	Description    *string                        `form:"description"`
	Email          *string                        `form:"email"`
	InvoicePrefix  *string                        `form:"invoice_prefix"`
	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 "*"
	TaxInfo        *CustomerTaxInfoParams         `form:"tax_info"`
	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 CustomerTaxInfo

type CustomerTaxInfo struct {
	TaxID string              `json:"tax_id"`
	Type  CustomerTaxInfoType `json:"type"`
}

CustomerTaxInfo is the structure containing tax information for the customer.

type CustomerTaxInfoParams

type CustomerTaxInfoParams struct {
	TaxID *string `form:"tax_id"`
	Type  *string `form:"type"`
}

CustomerTaxInfoParams is the structure containing tax information for the customer.

type CustomerTaxInfoType

type CustomerTaxInfoType string

CustomerTaxInfoType is the type of tax info associated with a customer.

const (
	CustomerTaxInfoTypeVAT CustomerTaxInfoType = "vat"
)

List of values that CustomerTaxInfoType can take.

type CustomerTaxInfoVerification

type CustomerTaxInfoVerification struct {
	Status       CustomerTaxInfoVerificationStatus `json:"status"`
	VerifiedName string                            `json:"verified_name"`
}

CustomerTaxInfoVerification is the structure containing tax verification for the customer.

type CustomerTaxInfoVerificationStatus

type CustomerTaxInfoVerificationStatus string

CustomerTaxInfoVerificationStatus is the type of tax info associated with a customer.

const (
	CustomerTaxInfoVerificationStatusPending    CustomerTaxInfoVerificationStatus = "pending"
	CustomerTaxInfoVerificationStatusUnverified CustomerTaxInfoVerificationStatus = "unverified"
	CustomerTaxInfoVerificationStatusVerified   CustomerTaxInfoVerificationStatus = "verified"
)

List of values that CustomerTaxInfoType can take.

type DOB

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

DOB represents a Person'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"`
}

DeliveryEstimate represent the properties available for a shipping method's estimated delivery.

type DestinationParams

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

DestinationParams describes the parameters available for the destination hash when creating a charge.

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           *File  `json:"cancellation_policy"`
	CancellationPolicyDisclosure string `json:"cancellation_policy_disclosure"`
	CancellationRebuttal         string `json:"cancellation_rebuttal"`
	CustomerCommunication        *File  `json:"customer_communication"`
	CustomerEmailAddress         string `json:"customer_email_address"`
	CustomerName                 string `json:"customer_name"`
	CustomerPurchaseIP           string `json:"customer_purchase_ip"`
	CustomerSignature            *File  `json:"customer_signature"`
	DuplicateChargeDocumentation *File  `json:"duplicate_charge_documentation"`
	DuplicateChargeExplanation   string `json:"duplicate_charge_explanation"`
	DuplicateChargeID            string `json:"duplicate_charge_id"`
	ProductDescription           string `json:"product_description"`
	Receipt                      *File  `json:"receipt"`
	RefundPolicy                 *File  `json:"refund_policy"`
	RefundPolicyDisclosure       string `json:"refund_policy_disclosure"`
	RefundRefusalExplanation     string `json:"refund_refusal_explanation"`
	ServiceDate                  string `json:"service_date"`
	ServiceDocumentation         *File  `json:"service_documentation"`
	ShippingAddress              string `json:"shipping_address"`
	ShippingCarrier              string `json:"shipping_carrier"`
	ShippingDate                 string `json:"shipping_date"`
	ShippingDocumentation        *File  `json:"shipping_documentation"`
	ShippingTrackingNumber       string `json:"shipping_tracking_number"`
	UncategorizedFile            *File  `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"
)

List of values that DisputeReason can take.

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

List of values that DisputeStatus can take.

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"`
	IssuingCard   *string `form:"issuing_card"`
	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 CardError that indicates
	// exactly what went wrong during charging a card.
	Err error `json:"-"`

	HTTPStatusCode int            `json:"status,omitempty"`
	Msg            string         `json:"message"`
	Param          string         `json:"param,omitempty"`
	PaymentIntent  *PaymentIntent `json:"payment_intent,omitempty"`
	PaymentMethod  *PaymentMethod `json:"payment_method,omitempty"`
	RequestID      string         `json:"request_id,omitempty"`
	Source         *PaymentSource `json:"source,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"
	ErrorCodeResourceMissing    ErrorCode = "resource_missing"
)

List of values that ErrorCode can take.

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

List of values that ErrorType can take.

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 is a raw mapping of the API resource contained in the event.
	// Although marked with json:"-", it's still populated independently by
	// a custom UnmarshalJSON implementation.
	Object             map[string]interface{} `json:"-"`
	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"`
	DeliverySuccess *bool             `form:"delivery_success"`
	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"
)

List of values that ExternalAccountType can take.

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                *ApplicationFee     `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 File

type File struct {
	Created  int64         `json:"created"`
	ID       string        `json:"id"`
	Filename string        `json:"filename"`
	Links    *FileLinkList `json:"links"`
	Purpose  FilePurpose   `json:"purpose"`
	Size     int64         `json:"size"`
	Type     string        `json:"type"`
	URL      string        `json:"url"`
}

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

func (*File) UnmarshalJSON

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

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

type FileLink struct {
	Created   int64             `json:"created"`
	Expired   bool              `json:"expired"`
	ExpiresAt int64             `json:"expires_at"`
	File      *File             `json:"file"`
	ID        string            `json:"id"`
	Livemode  bool              `json:"livemode"`
	Metadata  map[string]string `json:"metadata"`
	Object    string            `json:"object"`
	URL       string            `json:"url"`
}

FileLink is the resource representing a Stripe file link. For more details see https://stripe.com/docs/api#file_links.

func (*FileLink) UnmarshalJSON

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

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

type FileLinkList struct {
	ListMeta
	Data []*FileLink `json:"data"`
}

FileLinkList is a list of file links as retrieved from a list endpoint.

type FileLinkListParams

type FileLinkListParams struct {
	ListParams   `form:"*"`
	Created      *int64            `form:"created"`
	CreatedRange *RangeQueryParams `form:"created"`
	Expired      *bool             `form:"expired"`
	File         *string           `form:"file"`
}

FileLinkListParams is the set of parameters that can be used when listing file links.

type FileLinkParams

type FileLinkParams struct {
	Params    `form:"*"`
	ExpiresAt *int64  `form:"expires_at"`
	File      *string `form:"file"`
}

FileLinkParams is the set of parameters that can be used when creating or updating a file link.

type FileList

type FileList struct {
	ListMeta
	Data []*File `json:"data"`
}

FileList is a list of files as retrieved from a list endpoint.

type FileListParams

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

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

type FileParams

type FileParams 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
}

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

func (*FileParams) GetBody

func (f *FileParams) GetBody() (*bytes.Buffer, string, error)

GetBody gets an appropriate multipart form payload to use in a request body to create a new file.

type FilePurpose

type FilePurpose string

FilePurpose is the purpose of a particular file.

const (
	FilePurposeCustomerSignature     FilePurpose = "customer_signature"
	FilePurposeDisputeEvidence       FilePurpose = "dispute_evidence"
	FilePurposeFinanceReportRun      FilePurpose = "finance_report_run"
	FilePurposeFoundersStockDocument FilePurpose = "founders_stock_document"
	FilePurposeIdentityDocument      FilePurpose = "identity_document"
	FilePurposePCIDocument           FilePurpose = "pci_document"
	FilePurposeSigmaScheduledQuery   FilePurpose = "sigma_scheduled_query"
	FilePurposeTaxDocumentUserUpload FilePurpose = "tax_document_user_upload"
)

List of values that FilePurpose can take.

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 IdentityVerificationStatus

type IdentityVerificationStatus string

IdentityVerificationStatus describes the different statuses for identity verification.

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

List of values that IdentityVerificationStatus can take.

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

Inventory represents the inventory options of a SKU.

type InventoryParams

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

InventoryParams is the set of parameters allowed as inventory on a SKU.

type Invoice

type Invoice struct {
	AmountDue                 int64                    `json:"amount_due"`
	AmountPaid                int64                    `json:"amount_paid"`
	AmountRemaining           int64                    `json:"amount_remaining"`
	ApplicationFeeAmount      int64                    `json:"application_fee_amount"`
	AttemptCount              int64                    `json:"attempt_count"`
	Attempted                 bool                     `json:"attempted"`
	AutoAdvance               bool                     `json:"auto_advance"`
	Billing                   InvoiceBilling           `json:"billing"`
	BillingReason             InvoiceBillingReason     `json:"billing_reason"`
	Charge                    *Charge                  `json:"charge"`
	Created                   int64                    `json:"created"`
	Currency                  Currency                 `json:"currency"`
	CustomFields              []*InvoiceCustomField    `json:"custom_fields"`
	Customer                  *Customer                `json:"customer"`
	DefaultSource             *PaymentSource           `json:"default_source"`
	Description               string                   `json:"description"`
	Discount                  *Discount                `json:"discount"`
	DueDate                   int64                    `json:"due_date"`
	EndingBalance             int64                    `json:"ending_balance"`
	Footer                    string                   `json:"footer"`
	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"`
	Status                    InvoiceBillingStatus     `json:"status"`
	StatusTransitions         InvoiceStatusTransitions `json:"status_transitions"`
	Subscription              string                   `json:"subscription"`
	SubscriptionProrationDate int64                    `json:"subscription_proration_date"`
	Subtotal                  int64                    `json:"subtotal"`
	Tax                       int64                    `json:"tax"`
	TaxPercent                float64                  `json:"tax_percent"`
	ThreasholdReason          *InvoiceThresholdReason  `json:"threshold_reason"`
	Total                     int64                    `json:"total"`
	TransferData              *InvoiceTransferData     `json:"transfer_data"`
	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"
)

List of values that InvoiceBilling can take.

type InvoiceBillingReason

type InvoiceBillingReason string

InvoiceBillingReason is the reason why a given invoice was created

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

List of values that InvoiceBillingReason can take.

type InvoiceBillingStatus

type InvoiceBillingStatus string

InvoiceBillingStatus is the reason why a given invoice was created

const (
	InvoiceBillingStatusDraft         InvoiceBillingStatus = "draft"
	InvoiceBillingStatusOpen          InvoiceBillingStatus = "open"
	InvoiceBillingStatusPaid          InvoiceBillingStatus = "paid"
	InvoiceBillingStatusUncollectible InvoiceBillingStatus = "uncollectible"
	InvoiceBillingStatusVoid          InvoiceBillingStatus = "void"
)

List of values that InvoiceBillingStatus can take.

type InvoiceCustomField

type InvoiceCustomField struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

InvoiceCustomField is a structure representing a custom field on an Invoice.

type InvoiceCustomFieldParams

type InvoiceCustomFieldParams struct {
	Name  *string `form:"name"`
	Value *string `form:"value"`
}

InvoiceCustomFieldParams represents the parameters associated with one custom field on an invoice.

type InvoiceFinalizeParams

type InvoiceFinalizeParams struct {
	Params      `form:"*"`
	AutoAdvance *bool `form:"auto_advance"`
}

InvoiceFinalizeParams is the set of parameters that can be used when finalizing invoices.

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"`
	UnitAmount   int64             `json:"unit_amount"`
}

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"`
	Invoice      *string           `form:"invoice"`
	Pending      *bool             `form:"pending"`
}

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"`
	Quantity     *int64  `form:"quantity"`
	Subscription *string `form:"subscription"`
	UnitAmount   *int64  `form:"unit_amount"`
}

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

List of values that InvoiceLineType can take.

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"`
	Created      *int64            `form:"created"`
	CreatedRange *RangeQueryParams `form:"created_range"`
	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 InvoiceMarkUncollectibleParams

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

InvoiceMarkUncollectibleParams is the set of parameters that can be used when marking invoices as uncollectible.

type InvoiceParams

type InvoiceParams struct {
	Params               `form:"*"`
	AutoAdvance          *bool                       `form:"auto_advance"`
	ApplicationFeeAmount *int64                      `form:"application_fee_amount"`
	Billing              *string                     `form:"billing"`
	CustomFields         []*InvoiceCustomFieldParams `form:"custom_fields"`
	Customer             *string                     `form:"customer"`
	DaysUntilDue         *int64                      `form:"days_until_due"`
	DefaultSource        *string                     `form:"default_source"`
	Description          *string                     `form:"description"`
	DueDate              *int64                      `form:"due_date"`
	Footer               *string                     `form:"footer"`
	Paid                 *bool                       `form:"paid"`
	StatementDescriptor  *string                     `form:"statement_descriptor"`
	Subscription         *string                     `form:"subscription"`
	TaxPercent           *float64                    `form:"tax_percent"`
	TransferData         *InvoiceTransferDataParams  `form:"transfer_data"`

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

	// This parameter is considered deprecated. Prefer using ApplicationFeeAmount
	ApplicationFee *int64 `form:"application_fee"`
}

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:"*"`
	Forgive       *bool   `form:"forgive"`
	PaidOutOfBand *bool   `form:"paid_out_of_band"`
	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 InvoiceSendParams

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

InvoiceSendParams is the set of parameters that can be used when sending invoices.

type InvoiceStatusTransitions

type InvoiceStatusTransitions struct {
	FinalizedAt           int64 `json:"finalized_at"`
	MarkedUncollectibleAt int64 `json:"marked_uncollectible_at"`
	PaidAt                int64 `json:"paid_at"`
	VoidedAt              int64 `json:"voided_at"`
}

InvoiceStatusTransitions are the timestamps at which the invoice status was updated.

type InvoiceThresholdReason

type InvoiceThresholdReason struct {
	AmountGTE   int64                               `json:"amount_gte"`
	ItemReasons []*InvoiceThresholdReasonItemReason `json:"item_reasons"`
}

InvoiceThresholdReason is a structure representing a reason for a billing threshold.

type InvoiceThresholdReasonItemReason

type InvoiceThresholdReasonItemReason struct {
	LineItemIDs []string `json:"line_item_ids"`
	UsageGTE    int64    `json:"usage_gte"`
}

InvoiceThresholdReasonItemReason is a structure representing the line items that triggered an invoice.

type InvoiceTransferData

type InvoiceTransferData struct {
	Destination *Account `json:"destination"`
}

InvoiceTransferData represents the information for the transfer_data associated with an invoice.

type InvoiceTransferDataParams

type InvoiceTransferDataParams struct {
	Destination *string `form:"destination"`
}

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

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"`
	Period       *InvoiceUpcomingInvoiceItemPeriodParams `form:"period"`
	Quantity     *int64                                  `form:"quantity"`
	UnitAmount   *int64                                  `form:"unit_amount"`
}

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 InvoiceUpcomingInvoiceItemPeriodParams

type InvoiceUpcomingInvoiceItemPeriodParams struct {
	End   *int64 `form:"end"`
	Start *int64 `form:"start"`
}

InvoiceUpcomingInvoiceItemPeriodParams represents the period associated with that invoice item

type InvoiceVoidParams

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

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

type IssuerFraudRecord

type IssuerFraudRecord struct {
	Actionable        bool            `json:"actionable"`
	Charge            *Charge         `json:"charge"`
	Created           int64           `json:"created"`
	FraudType         IssuerFraudType `json:"fraud_type"`
	HasLiabilityShift bool            `json:"has_liability_shift"`
	ID                string          `json:"id"`
	Livemode          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"
)

List of values that IssuerFraudType can take.

type IssuingAuthorization

type IssuingAuthorization struct {
	Approved                 bool                                    `json:"approved"`
	AuthorizationMethod      IssuingAuthorizationAuthorizationMethod `json:"authorization_method"`
	AuthorizedAmount         int64                                   `json:"authorized_amount"`
	AuthorizedCurrency       Currency                                `json:"authorized_currency"`
	BalanceTransactions      []*BalanceTransaction                   `json:"balance_transactions"`
	Card                     *IssuingCard                            `json:"card"`
	Cardholder               *IssuingCardholder                      `json:"cardholder"`
	Created                  int64                                   `json:"created"`
	HeldAmount               int64                                   `json:"held_amount"`
	HeldCurrency             Currency                                `json:"held_currency"`
	ID                       string                                  `json:"id"`
	IsHeldAmountControllable bool                                    `json:"is_held_amount_controllable"`
	Livemode                 bool                                    `json:"livemode"`
	MerchantData             *IssuingMerchantData                    `json:"merchant_data"`
	Metadata                 map[string]string                       `json:"metadata"`
	Object                   string                                  `json:"object"`
	PendingAuthorizedAmount  int64                                   `json:"pending_authorized_amount"`
	PendingHeldAmount        int64                                   `json:"pending_held_amount"`
	RequestHistory           []*IssuingAuthorizationRequestHistory   `json:"request_history"`
	Status                   IssuingAuthorizationStatus              `json:"status"`
	Transactions             []*IssuingTransaction                   `json:"transactions"`
	VerificationData         *IssuingAuthorizationVerificationData   `json:"verification_data"`
	WalletProvider           IssuingAuthorizationWalletProviderType  `json:"wallet_provider"`
}

IssuingAuthorization is the resource representing a Stripe issuing authorization.

func (*IssuingAuthorization) UnmarshalJSON

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

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

type IssuingAuthorizationAuthorizationControls

type IssuingAuthorizationAuthorizationControls struct {
	AllowedCategories []string `json:"allowed_categories"`
	BlockedCategories []string `json:"blocked_categories"`
	Currency          Currency `json:"currency"`
	MaxAmount         int64    `json:"max_amount"`
	MaxApprovals      int64    `json:"max_approvals"`
}

IssuingAuthorizationAuthorizationControls is the resource representing authorization controls on an issuing authorization.

type IssuingAuthorizationAuthorizationMethod

type IssuingAuthorizationAuthorizationMethod string

IssuingAuthorizationAuthorizationMethod is the list of possible values for the authorization method on an issuing authorization.

const (
	IssuingAuthorizationAuthorizationMethodChip        IssuingAuthorizationAuthorizationMethod = "chip"
	IssuingAuthorizationAuthorizationMethodContactless IssuingAuthorizationAuthorizationMethod = "contactless"
	IssuingAuthorizationAuthorizationMethodKeyedIn     IssuingAuthorizationAuthorizationMethod = "keyed_in"
	IssuingAuthorizationAuthorizationMethodOnline      IssuingAuthorizationAuthorizationMethod = "online"
	IssuingAuthorizationAuthorizationMethodSwipe       IssuingAuthorizationAuthorizationMethod = "swipe"
)

List of values that IssuingAuthorizationAuthorizationMethod can take.

type IssuingAuthorizationList

type IssuingAuthorizationList struct {
	ListMeta
	Data []*IssuingAuthorization `json:"data"`
}

IssuingAuthorizationList is a list of issuing authorizations as retrieved from a list endpoint.

type IssuingAuthorizationListParams

type IssuingAuthorizationListParams struct {
	ListParams   `form:"*"`
	Card         *string           `form:"card"`
	Cardholder   *string           `form:"cardholder"`
	Created      *int64            `form:"created"`
	CreatedRange *RangeQueryParams `form:"created"`
	Status       *string           `form:"status"`
}

IssuingAuthorizationListParams is the set of parameters that can be used when listing issuing authorizations.

type IssuingAuthorizationParams

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

IssuingAuthorizationParams is the set of parameters that can be used when updating an issuing authorization.

type IssuingAuthorizationRequestHistory

type IssuingAuthorizationRequestHistory struct {
	Approved           bool                                     `json:"approved"`
	AuthorizedAmount   int64                                    `json:"authorized_amount"`
	AuthorizedCurrency Currency                                 `json:"authorized_currency"`
	Created            int64                                    `json:"created"`
	HeldAmount         int64                                    `json:"held_amount"`
	HeldCurrency       Currency                                 `json:"held_currency"`
	Reason             IssuingAuthorizationRequestHistoryReason `json:"reason"`
}

IssuingAuthorizationRequestHistory is the resource representing a request history on an issuing authorization.

type IssuingAuthorizationRequestHistoryReason

type IssuingAuthorizationRequestHistoryReason string

IssuingAuthorizationRequestHistoryReason is the list of possible values for the request history reason on an issuing authorization.

const (
	IssuingAuthorizationRequestHistoryReasonAuthorizationControls IssuingAuthorizationRequestHistoryReason = "authorization_controls"
	IssuingAuthorizationRequestHistoryReasonCardActive            IssuingAuthorizationRequestHistoryReason = "card_active"
	IssuingAuthorizationRequestHistoryReasonCardInactive          IssuingAuthorizationRequestHistoryReason = "card_inactive"
	IssuingAuthorizationRequestHistoryReasonInsufficientFunds     IssuingAuthorizationRequestHistoryReason = "insufficient_funds"
	IssuingAuthorizationRequestHistoryReasonWebhookApproved       IssuingAuthorizationRequestHistoryReason = "webhook_approved"
	IssuingAuthorizationRequestHistoryReasonWebhookDeclined       IssuingAuthorizationRequestHistoryReason = "webhook_declined"
	IssuingAuthorizationRequestHistoryReasonWebhookTimeout        IssuingAuthorizationRequestHistoryReason = "webhook_timeout"
)

List of values that IssuingAuthorizationRequestHistoryReason can take.

type IssuingAuthorizationStatus

type IssuingAuthorizationStatus string

IssuingAuthorizationStatus is the possible values for status for an issuing authorization.

const (
	IssuingAuthorizationStatusClosed   IssuingAuthorizationStatus = "closed"
	IssuingAuthorizationStatusPending  IssuingAuthorizationStatus = "pending"
	IssuingAuthorizationStatusReversed IssuingAuthorizationStatus = "reversed"
)

List of values that IssuingAuthorizationStatus can take.

type IssuingAuthorizationVerificationData

type IssuingAuthorizationVerificationData struct {
	AddressLine1Check IssuingAuthorizationVerificationDataCheck `json:"address_line1_check"`
	AddressZipCheck   IssuingAuthorizationVerificationDataCheck `json:"address_zip_check"`
	CVCCheck          IssuingAuthorizationVerificationDataCheck `json:"cvc_check"`
}

IssuingAuthorizationVerificationData is the resource representing verification data on an issuing authorization.

type IssuingAuthorizationVerificationDataCheck

type IssuingAuthorizationVerificationDataCheck string

IssuingAuthorizationVerificationDataCheck is the list of possible values for result of a check for verification data on an issuing authorization.

const (
	IssuingAuthorizationVerificationDataCheckMatch       IssuingAuthorizationVerificationDataCheck = "match"
	IssuingAuthorizationVerificationDataCheckMismatch    IssuingAuthorizationVerificationDataCheck = "mismatch"
	IssuingAuthorizationVerificationDataCheckNotProvided IssuingAuthorizationVerificationDataCheck = "not_provided"
)

List of values that IssuingAuthorizationVerificationDataCheck can take.

type IssuingAuthorizationWalletProviderType

type IssuingAuthorizationWalletProviderType string

IssuingAuthorizationWalletProviderType is the list of possible values for the authorization's wallet provider.

const (
	IssuingAuthorizationWalletProviderTypeApplePay   IssuingAuthorizationWalletProviderType = "apple_pay"
	IssuingAuthorizationWalletProviderTypeGooglePay  IssuingAuthorizationWalletProviderType = "google_pay"
	IssuingAuthorizationWalletProviderTypeSamsungPay IssuingAuthorizationWalletProviderType = "samsung_pay"
)

List of values that IssuingAuthorizationWalletProviderType can take.

type IssuingBilling

type IssuingBilling struct {
	Address *Address `json:"address"`
	Name    string   `json:"name"`
}

IssuingBilling is the resource representing the billing hash with the Issuing APIs.

type IssuingBillingParams

type IssuingBillingParams struct {
	Address *AddressParams `form:"address"`
	Name    *string        `form:"name"`
}

IssuingBillingParams isis the set of parameters that can be used for billing with the Issuing APIs.

type IssuingCard

type IssuingCard struct {
	AuthorizationControls *IssuingCardAuthorizationControls `json:"authorization_controls"`
	Billing               *IssuingBilling                   `json:"billing"`
	Brand                 string                            `json:"brand"`
	Cardholder            *IssuingCardholder                `json:"cardholder"`
	Created               int64                             `json:"created"`
	ExpMonth              int64                             `json:"exp_month"`
	ExpYear               int64                             `json:"exp_year"`
	Last4                 string                            `json:"last4"`
	ID                    string                            `json:"id"`
	Livemode              bool                              `json:"livemode"`
	Metadata              map[string]string                 `json:"metadata"`
	Name                  string                            `json:"name"`
	Object                string                            `json:"object"`
	Shipping              *IssuingCardShipping              `json:"shipping"`
	Status                IssuingCardStatus                 `json:"status"`
	Type                  IssuingCardType                   `json:"type"`
}

IssuingCard is the resource representing a Stripe issuing card.

func (*IssuingCard) UnmarshalJSON

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

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

type IssuingCardAuthorizationControls

type IssuingCardAuthorizationControls struct {
	AllowedCategories []string `json:"allowed_categories"`
	BlockedCategories []string `json:"blocked_categories"`
	Currency          Currency `json:"currency"`
	MaxAmount         int64    `json:"max_amount"`
	MaxApprovals      int64    `json:"max_approvals"`
}

IssuingCardAuthorizationControls is the resource representing authorization controls on an issuing card.

type IssuingCardDetails

type IssuingCardDetails struct {
	Card     *IssuingCard `json:"card"`
	CVC      string       `json:"cvc"`
	ExpMonth *string      `form:"exp_month"`
	ExpYear  *string      `form:"exp_year"`
	Number   string       `json:"number"`
	Object   string       `json:"object"`
}

IssuingCardDetails is the resource representing issuing card details.

type IssuingCardList

type IssuingCardList struct {
	ListMeta
	Data []*IssuingCard `json:"data"`
}

IssuingCardList is a list of issuing cards as retrieved from a list endpoint.

type IssuingCardListParams

type IssuingCardListParams struct {
	ListParams   `form:"*"`
	Cardholder   *string           `form:"cardholder"`
	Created      *int64            `form:"created"`
	CreatedRange *RangeQueryParams `form:"created"`
	ExpMonth     *int64            `form:"exp_month"`
	ExpYear      *int64            `form:"exp_year"`
	Last4        *string           `form:"last4"`
	Source       *string           `form:"source"`
	Status       *string           `form:"status"`
	Type         *string           `form:"type"`
}

IssuingCardListParams is the set of parameters that can be used when listing issuing cards.

type IssuingCardParams

type IssuingCardParams struct {
	Params                `form:"*"`
	AuthorizationControls *AuthorizationControlsParams `form:"authorization_controls"`
	Billing               *IssuingBillingParams        `form:"billing"`
	Cardholder            *string                      `form:"cardholder"`
	Currency              *string                      `form:"currency"`
	Name                  *string                      `form:"name"`
	Status                *string                      `form:"status"`
	Shipping              *IssuingCardShippingParams   `form:"shipping"`
	Type                  *string                      `form:"type"`
}

IssuingCardParams is the set of parameters that can be used when creating or updating an issuing card.

type IssuingCardShipping

type IssuingCardShipping struct {
	Address        *Address                  `json:"address"`
	Carrier        string                    `json:"carrier"`
	ETA            int64                     `json:"eta"`
	Name           string                    `json:"name"`
	Phone          string                    `json:"phone"`
	Status         IssuingCardShippingStatus `json:"status"`
	TrackingNumber string                    `json:"tracking_number"`
	Type           IssuingCardShippingType   `json:"type"`
}

IssuingCardShipping is the resource representing shipping on an issuing card.

type IssuingCardShippingParams

type IssuingCardShippingParams struct {
	Address *AddressParams `form:"address"`
	Name    string         `form:"name"`
	Type    *string        `form:"type"`
}

IssuingCardShippingParams is the set of parameters that can be used for the shipping parameter.

type IssuingCardShippingStatus

type IssuingCardShippingStatus string

IssuingCardShippingStatus is the list of possible values for the shipping status on an issuing card.

const (
	IssuingCardShippingTypeDelivered IssuingCardShippingStatus = "delivered"
	IssuingCardShippingTypeFailure   IssuingCardShippingStatus = "failure"
	IssuingCardShippingTypePending   IssuingCardShippingStatus = "pending"
	IssuingCardShippingTypeReturned  IssuingCardShippingStatus = "returned"
	IssuingCardShippingTypeShipped   IssuingCardShippingStatus = "shipped"
)

List of values that IssuingCardShippingStatus can take.

type IssuingCardShippingType

type IssuingCardShippingType string

IssuingCardShippingType is the list of possible values for the shipping type on an issuing card.

const (
	IssuingCardShippingTypeBulk       IssuingCardShippingType = "bulk"
	IssuingCardShippingTypeIndividual IssuingCardShippingType = "individual"
)

List of values that IssuingCardShippingType can take.

type IssuingCardStatus

type IssuingCardStatus string

IssuingCardStatus is the list of possible values for status on an issuing card.

const (
	IssuingCardStatusActive   IssuingCardStatus = "active"
	IssuingCardStatusCanceled IssuingCardStatus = "canceled"
	IssuingCardStatusInactive IssuingCardStatus = "inactive"
	IssuingCardStatusPending  IssuingCardStatus = "pending"
)

List of values that IssuingCardStatus can take.

type IssuingCardType

type IssuingCardType string

IssuingCardType is the type of an issuing card.

const (
	IssuingCardTypePhysical IssuingCardType = "physical"
	IssuingCardTypeVirtual  IssuingCardType = "virtual"
)

List of values that IssuingCardType can take.

type IssuingCardholder

type IssuingCardholder struct {
	Billing     *IssuingBilling         `json:"billing"`
	Created     int64                   `json:"created"`
	Email       string                  `json:"email"`
	ID          string                  `json:"id"`
	Livemode    bool                    `json:"livemode"`
	Metadata    map[string]string       `json:"metadata"`
	Name        string                  `json:"name"`
	Object      string                  `json:"object"`
	PhoneNumber string                  `json:"phone_number"`
	Status      IssuingCardholderStatus `json:"status"`
	Type        IssuingCardholderType   `json:"type"`
}

IssuingCardholder is the resource representing a Stripe issuing cardholder.

func (*IssuingCardholder) UnmarshalJSON

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

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

type IssuingCardholderList

type IssuingCardholderList struct {
	ListMeta
	Data []*IssuingCardholder `json:"data"`
}

IssuingCardholderList is a list of issuing cardholders as retrieved from a list endpoint.

type IssuingCardholderListParams

type IssuingCardholderListParams struct {
	ListParams   `form:"*"`
	Created      *int64            `form:"created"`
	CreatedRange *RangeQueryParams `form:"created"`
	Email        *string           `form:"email"`
	PhoneNumber  *string           `form:"phone_number"`
	Status       *string           `form:"status"`
	Type         *string           `form:"type"`
}

IssuingCardholderListParams is the set of parameters that can be used when listing issuing cardholders.

type IssuingCardholderParams

type IssuingCardholderParams struct {
	Params      `form:"*"`
	Billing     *IssuingBillingParams `form:"billing"`
	Email       *string               `form:"email"`
	Name        *string               `form:"name"`
	PhoneNumber *string               `form:"phone_number"`
	Type        *string               `form:"type"`
}

IssuingCardholderParams is the set of parameters that can be used when creating or updating an issuing cardholder.

type IssuingCardholderStatus

type IssuingCardholderStatus string

IssuingCardholderStatus is the possible values for status on an issuing cardholder.

const (
	IssuingCardholderStatusActive   IssuingCardholderStatus = "active"
	IssuingCardholderStatusInactive IssuingCardholderStatus = "inactive"
	IssuingCardholderStatusPending  IssuingCardholderStatus = "pending"
)

List of values that IssuingCardholderStatus can take.

type IssuingCardholderType

type IssuingCardholderType string

IssuingCardholderType is the type of an issuing cardholder.

const (
	IssuingCardholderTypeBusinessEntity IssuingCardholderType = "business_entity"
	IssuingCardholderTypeIndividual     IssuingCardholderType = "individual"
)

List of values that IssuingCardholderType can take.

type IssuingDispute

type IssuingDispute struct {
	Amount      int64                   `json:"amount"`
	Created     int64                   `json:"created"`
	Currency    Currency                `json:"currency"`
	Evidence    *IssuingDisputeEvidence `json:"evidence"`
	ID          string                  `json:"id"`
	Livemode    bool                    `json:"livemode"`
	Metadata    map[string]string       `json:"metadata"`
	Object      string                  `json:"object"`
	Reason      IssuingDisputeReason    `json:"reason"`
	Status      IssuingDisputeStatus    `json:"status"`
	Transaction *IssuingTransaction     `json:"transaction"`
}

IssuingDispute is the resource representing an issuing dispute.

func (*IssuingDispute) UnmarshalJSON

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

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

type IssuingDisputeEvidence

type IssuingDisputeEvidence struct {
	Fraudulent *IssuingDisputeEvidenceFraudulent `json:"fraudulent"`
	Other      *IssuingDisputeEvidenceOther      `json:"other"`
}

IssuingDisputeEvidence is the resource representing evidence on an issuing dispute.

type IssuingDisputeEvidenceFraudulent

type IssuingDisputeEvidenceFraudulent struct {
	DisputeExplanation string `json:"dispute_explanation"`
	UncategorizedFile  *File  `json:"uncategorized_file"`
}

IssuingDisputeEvidenceFraudulent is the resource representing the evidence hash on an issuing dispute with the reason set as fraudulent.

type IssuingDisputeEvidenceFraudulentParams

type IssuingDisputeEvidenceFraudulentParams struct {
	DisputeExplanation *string `form:"dispute_explanation"`
	UncategorizedFile  *string `form:"uncategorized_file"`
}

IssuingDisputeEvidenceFraudulentParams is the subset of parameters that can be sent as evidence for an issuing dispute with the reason set as fraudulent.

type IssuingDisputeEvidenceOther

type IssuingDisputeEvidenceOther struct {
	DisputeExplanation string `json:"dispute_explanation"`
	UncategorizedFile  *File  `json:"uncategorized_file"`
}

IssuingDisputeEvidenceOther is the resource representing the evidence hash on an issuing dispute with the reason set as other.

type IssuingDisputeEvidenceOtherParams

type IssuingDisputeEvidenceOtherParams struct {
	DisputeExplanation *string `form:"dispute_explanation"`
	UncategorizedFile  *string `form:"uncategorized_file"`
}

IssuingDisputeEvidenceOtherParams is the subset of parameters that can be sent as evidence for an issuing dispute with the reason set as other.

type IssuingDisputeEvidenceParams

type IssuingDisputeEvidenceParams struct {
	Fraudulent *IssuingDisputeEvidenceFraudulentParams `form:"fraudulent"`
	Other      *IssuingDisputeEvidenceOtherParams      `form:"other"`
}

IssuingDisputeEvidenceParams is the set of parameters that can be sent as evidence for an issuing dispute.

type IssuingDisputeList

type IssuingDisputeList struct {
	ListMeta
	Data []*IssuingDispute `json:"data"`
}

IssuingDisputeList is a list of issuing disputes as retrieved from a list endpoint.

type IssuingDisputeListParams

type IssuingDisputeListParams struct {
	ListParams   `form:"*"`
	Created      *int64            `form:"created"`
	CreatedRange *RangeQueryParams `form:"created"`
	Transaction  *string           `form:"transaction"`
}

IssuingDisputeListParams is the set of parameters that can be used when listing issuing dispute.

type IssuingDisputeParams

type IssuingDisputeParams struct {
	Params              `form:"*"`
	Amount              *int64                        `form:"amount"`
	Evidence            *IssuingDisputeEvidenceParams `form:"evidence"`
	Reason              *string                       `form:"reason"`
	DisputedTransaction *string                       `form:"disputed_transaction"`
}

IssuingDisputeParams is the set of parameters that can be used when creating or updating an issuing dispute.

type IssuingDisputeReason

type IssuingDisputeReason string

IssuingDisputeReason is the list of possible values for status on an issuing dispute.

const (
	IssuingDisputeReasonFraudulent IssuingDisputeReason = "fraudulent"
	IssuingDisputeReasonOther      IssuingDisputeReason = "other"
)

List of values that IssuingDisputeReason can take.

type IssuingDisputeStatus

type IssuingDisputeStatus string

IssuingDisputeStatus is the list of possible values for status on an issuing dispute.

const (
	IssuingDisputeStatusLost        IssuingDisputeStatus = "lost"
	IssuingDisputeStatusUnderReview IssuingDisputeStatus = "under_review"
	IssuingDisputeStatusUnsubmitted IssuingDisputeStatus = "unsubmitted"
	IssuingDisputeStatusWon         IssuingDisputeStatus = "won"
)

List of values that IssuingDisputeStatus can take.

type IssuingMerchantData

type IssuingMerchantData struct {
	Category   string `json:"category"`
	City       string `json:"city"`
	Country    string `json:"country"`
	Name       string `json:"name"`
	NetworkID  string `json:"network_id"`
	PostalCode string `json:"postal_code"`
	State      string `json:"state"`
}

IssuingMerchantData is the resource representing merchant data on Issuing APIs.

type IssuingTransaction

type IssuingTransaction struct {
	Amount             int64                  `json:"amount"`
	Authorization      *IssuingAuthorization  `json:"authorization"`
	BalanceTransaction *BalanceTransaction    `json:"balance_transaction"`
	Card               *IssuingCard           `json:"card"`
	Cardholder         *IssuingCardholder     `json:"cardholder"`
	Created            int64                  `json:"created"`
	Currency           Currency               `json:"currency"`
	Dispute            *IssuingDispute        `json:"dispute"`
	ID                 string                 `json:"id"`
	Livemode           bool                   `json:"livemode"`
	MerchantData       *IssuingMerchantData   `json:"merchant_data"`
	Metadata           map[string]string      `json:"metadata"`
	Object             string                 `json:"object"`
	Type               IssuingTransactionType `json:"type"`
}

IssuingTransaction is the resource representing a Stripe issuing transaction.

func (*IssuingTransaction) UnmarshalJSON

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

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

type IssuingTransactionList

type IssuingTransactionList struct {
	ListMeta
	Data []*IssuingTransaction `json:"data"`
}

IssuingTransactionList is a list of issuing transactions as retrieved from a list endpoint.

type IssuingTransactionListParams

type IssuingTransactionListParams struct {
	ListParams   `form:"*"`
	Card         *string           `form:"card"`
	Cardholder   *string           `form:"cardholder"`
	Created      *int64            `form:"created"`
	CreatedRange *RangeQueryParams `form:"created"`
}

IssuingTransactionListParams is the set of parameters that can be used when listing issuing transactions.

type IssuingTransactionParams

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

IssuingTransactionParams is the set of parameters that can be used when creating or updating an issuing transaction.

type IssuingTransactionType

type IssuingTransactionType string

IssuingTransactionType is the type of an issuing transaction.

const (
	IssuingTransactionTypeCapture        IssuingTransactionType = "capture"
	IssuingTransactionTypeCashWithdrawal IssuingTransactionType = "cash_withdrawal"
	IssuingTransactionTypeRefund         IssuingTransactionType = "refund"
	IssuingTransactionTypeRefundReversal IssuingTransactionType = "refund_reversal"
)

List of values that IssuingTransactionType can take.

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

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

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

List of values that OrderDeliveryEstimateType can take.

type OrderItem

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

OrderItem is the resource representing an order item.

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

OrderItemParams is the set of parameters describing an order item on order creation or update.

type OrderItemParent

type OrderItemParent struct {
	ID   string              `json:"id"`
	SKU  *SKU                `json:"-"`
	Type OrderItemParentType `json:"object"`
}

OrderItemParent describes the parent of an order item.

func (*OrderItemParent) UnmarshalJSON

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

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

type OrderItemParentType

type OrderItemParentType string

OrderItemParentType represents the type of order item parent

const (
	OrderItemParentTypeCoupon   OrderItemParentType = "coupon"
	OrderItemParentTypeDiscount OrderItemParentType = "discount"
	OrderItemParentTypeSKU      OrderItemParentType = "sku"
	OrderItemParentTypeShipping OrderItemParentType = "shipping"
	OrderItemParentTypeTax      OrderItemParentType = "tax"
)

List of values that OrderItemParentType can take.

type OrderItemType

type OrderItemType string

OrderItemType represents the type of order item

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

List of values that OrderItemType can take.

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"`
	StatusTransitions *StatusTransitionsFilterParams `form:"status_transitions"`
}

OrderListParams is the set of parameters that can be used when listing 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"`
	Shipping *ShippingParams    `form:"shipping"`
}

OrderParams is the set of parameters that can be used when creating an order.

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.

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

OrderReturn is the resource representing an order return. For more details see https://stripe.com/docs/api#order_returns.

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 order 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 order returns.

type OrderReturnParams

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

OrderReturnParams is the set of parameters that can be used when returning orders.

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

List of values that OrderStatus can take.

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

OrderUpdateParams is the set of parameters that can be used when updating an order.

type OrderUpdateShippingParams

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

OrderUpdateShippingParams is the set of parameters that can be used for the shipping hash on order update.

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

PackageDimensionsParams represents the set of parameters for the 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 PaymentIntent

type PaymentIntent struct {
	Amount              int64                           `json:"amount"`
	AmountCapturable    int64                           `json:"amount_capturable"`
	AmountReceived      int64                           `json:"amount_received"`
	Application         *Application                    `json:"application"`
	ApplicationFee      int64                           `json:"application_fee"`
	CanceledAt          int64                           `json:"canceled_at"`
	CaptureMethod       PaymentIntentCaptureMethod      `json:"capture_method"`
	Charges             *ChargeList                     `json:"charges"`
	ClientSecret        string                          `json:"client_secret"`
	ConfirmationMethod  PaymentIntentConfirmationMethod `json:"confirmation_method"`
	Created             int64                           `json:"created"`
	Currency            string                          `json:"currency"`
	Customer            *Customer                       `json:"customer"`
	Description         string                          `json:"description"`
	LastPaymentError    *PaymentIntentLastPaymentError  `json:"last_payment_error"`
	Livemode            bool                            `json:"livemode"`
	ID                  string                          `json:"id"`
	Metadata            map[string]string               `json:"metadata"`
	NextAction          *PaymentIntentNextAction        `json:"next_action"`
	OnBehalfOf          *Account                        `json:"on_behalf_of"`
	PaymentMethod       *PaymentMethod                  `json:"payment_method"`
	PaymentMethodTypes  []string                        `json:"payment_method_types"`
	ReceiptEmail        string                          `json:"receipt_email"`
	Review              *Review                         `json:"review"`
	Shipping            ShippingDetails                 `json:"shipping"`
	Source              *PaymentSource                  `json:"source"`
	StatementDescriptor string                          `json:"statement_descriptor"`
	Status              PaymentIntentStatus             `json:"status"`
	TransferData        *PaymentIntentTransferData      `json:"transfer_data"`
	TransferGroup       string                          `json:"transfer_group"`
}

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

func (*PaymentIntent) UnmarshalJSON

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

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

type PaymentIntentCancelParams

type PaymentIntentCancelParams struct {
	Params             `form:"*"`
	CancellationReason *string `form:"cancellation_reason"`
}

PaymentIntentCancelParams is the set of parameters that can be used when canceling a payment intent.

type PaymentIntentCancellationReason

type PaymentIntentCancellationReason string

PaymentIntentCancellationReason is the list of allowed values for the cancelation reason.

const (
	PaymentIntentCancellationReasonDuplicate           PaymentIntentCancellationReason = "duplicate"
	PaymentIntentCancellationReasonFraudulent          PaymentIntentCancellationReason = "fraudulent"
	PaymentIntentCancellationReasonRequestedByCustomer PaymentIntentCancellationReason = "requested_by_customer"
)

List of values that PaymentIntentCaptureMethod can take.

type PaymentIntentCaptureMethod

type PaymentIntentCaptureMethod string

PaymentIntentCaptureMethod is the list of allowed values for the capture method.

const (
	PaymentIntentCaptureMethodAutomatic PaymentIntentCaptureMethod = "automatic"
	PaymentIntentCaptureMethodManual    PaymentIntentCaptureMethod = "manual"
)

List of values that PaymentIntentCaptureMethod can take.

type PaymentIntentCaptureParams

type PaymentIntentCaptureParams struct {
	Params               `form:"*"`
	AmountToCapture      *int64                           `form:"amount_to_capture"`
	ApplicationFeeAmount *int64                           `form:"application_fee_amount"`
	TransferData         *PaymentIntentTransferDataParams `form:"transfer_data"`
}

PaymentIntentCaptureParams is the set of parameters that can be used when capturing a payment intent.

type PaymentIntentConfirmParams

type PaymentIntentConfirmParams struct {
	Params            `form:"*"`
	PaymentMethod     *string                `form:"payment_method"`
	ReceiptEmail      *string                `form:"receipt_email"`
	ReturnURL         *string                `form:"return_url"`
	SavePaymentMethod *bool                  `form:"save_payment_method"`
	Shipping          *ShippingDetailsParams `form:"shipping"`
	Source            *string                `form:"source"`
}

PaymentIntentConfirmParams is the set of parameters that can be used when confirming a payment intent.

type PaymentIntentConfirmationMethod

type PaymentIntentConfirmationMethod string

PaymentIntentConfirmationMethod is the list of allowed values for the confirmation method.

const (
	PaymentIntentConfirmationMethodPublishable PaymentIntentConfirmationMethod = "publishable"
	PaymentIntentConfirmationMethodSecret      PaymentIntentConfirmationMethod = "secret"
)

List of values that PaymentIntentConfirmationMethod can take.

type PaymentIntentLastPaymentError

type PaymentIntentLastPaymentError struct {
	Charge        string         `json:"charge"`
	Code          string         `json:"code"`
	DeclineCode   string         `json:"decline_code"`
	DocURL        string         `json:"doc_url"`
	Message       string         `json:"message"`
	Param         string         `json:"param"`
	PaymentIntent *PaymentIntent `json:"payment_intent"`
	PaymentMethod *PaymentMethod `json:"payment_method"`
	Source        *PaymentSource `json:"source"`
	Type          ErrorType      `json:"type"`
}

PaymentIntentLastPaymentError represents the last error happening on a payment intent.

type PaymentIntentList

type PaymentIntentList struct {
	ListMeta
	Data []*PaymentIntent `json:"data"`
}

PaymentIntentList is a list of payment intents as retrieved from a list endpoint.

type PaymentIntentListParams

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

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

type PaymentIntentNextAction

type PaymentIntentNextAction struct {
	RedirectToURL *PaymentIntentNextActionRedirectToURL `json:"redirect_to_url"`
	Type          PaymentIntentNextActionType           `json:"type"`
}

PaymentIntentNextAction represents the type of action to take on a payment intent.

type PaymentIntentNextActionRedirectToURL

type PaymentIntentNextActionRedirectToURL struct {
	ReturnURL string `json:"return_url"`
	URL       string `json:"url"`
}

PaymentIntentNextActionRedirectToURL represents the resource for the next action of type "redirect_to_url".

type PaymentIntentNextActionType

type PaymentIntentNextActionType string

PaymentIntentNextActionType is the list of allowed values for the next action's type.

const (
	PaymentIntentNextActionTypeRedirectToURL PaymentIntentNextActionType = "redirect_to_url"
)

List of values that PaymentIntentNextActionType can take.

type PaymentIntentParams

type PaymentIntentParams struct {
	Params               `form:"*"`
	Amount               *int64                           `form:"amount"`
	ApplicationFeeAmount *int64                           `form:"application_fee_amount"`
	Confirm              *bool                            `form:"confirm"`
	CaptureMethod        *string                          `form:"capture_method"`
	Currency             *string                          `form:"currency"`
	Customer             *string                          `form:"customer"`
	Description          *string                          `form:"description"`
	OnBehalfOf           *string                          `form:"on_behalf_of"`
	PaymentMethod        *string                          `form:"payment_method"`
	PaymentMethodTypes   []*string                        `form:"payment_method_types"`
	ReceiptEmail         *string                          `form:"receipt_email"`
	ReturnURL            *string                          `form:"return_url"`
	SavePaymentMethod    *bool                            `form:"save_payment_method"`
	Shipping             *ShippingDetailsParams           `form:"shipping"`
	Source               *string                          `form:"source"`
	StatementDescriptor  *string                          `form:"statement_descriptor"`
	TransferData         *PaymentIntentTransferDataParams `form:"transfer_data"`
	TransferGroup        *string                          `form:"transfer_group"`
}

PaymentIntentParams is the set of parameters that can be used when handling a payment intent.

type PaymentIntentStatus

type PaymentIntentStatus string

PaymentIntentStatus is the list of allowed values for the payment intent's status.

const (
	PaymentIntentStatusCanceled              PaymentIntentStatus = "canceled"
	PaymentIntentStatusProcessing            PaymentIntentStatus = "processing"
	PaymentIntentStatusRequiresAction        PaymentIntentStatus = "requires_action"
	PaymentIntentStatusRequiresCapture       PaymentIntentStatus = "requires_capture"
	PaymentIntentStatusRequiresConfirmation  PaymentIntentStatus = "requires_confirmation"
	PaymentIntentStatusRequiresPaymentMethod PaymentIntentStatus = "requires_payment_method"
	PaymentIntentStatusSucceeded             PaymentIntentStatus = "succeeded"
)

List of values that PaymentIntentStatus can take.

type PaymentIntentTransferData

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

PaymentIntentTransferData represents the information for the transfer associated with a payment intent.

type PaymentIntentTransferDataParams

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

PaymentIntentTransferDataParams is the set of parameters allowed for the transfer hash.

type PaymentMethod

type PaymentMethod struct {
	BillingDetails *BillingDetails           `json:"billing_details"`
	Card           *PaymentMethodCard        `json:"card"`
	CardPresent    *PaymentMethodCardPresent `json:"card_present"`
	Created        int64                     `json:"created"`
	Customer       *Customer                 `json:"customer"`
	ID             string                    `json:"id"`
	Livemode       bool                      `json:"livemode"`
	Metadata       map[string]string         `json:"metadata"`
	Object         string                    `json:"object"`
	Type           PaymentMethodType         `json:"type"`
}

PaymentMethod is the resource representing a PaymentMethod.

func (*PaymentMethod) UnmarshalJSON

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

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

type PaymentMethodAttachParams

type PaymentMethodAttachParams struct {
	Params   `form:"*"`
	Customer *string `form:"customer"`
}

PaymentMethodAttachParams is the set of parameters that can be used when attaching a PaymentMethod to a Customer.

type PaymentMethodCard

type PaymentMethodCard struct {
	Brand             PaymentMethodCardBrand              `json:"brand"`
	Checks            *PaymentMethodCardChecks            `json:"checks"`
	Country           string                              `json:"country"`
	ExpMonth          uint64                              `json:"exp_month"`
	ExpYear           uint64                              `json:"exp_year"`
	Fingerprint       string                              `json:"fingerprint"`
	Funding           CardFunding                         `json:"funding"`
	Last4             string                              `json:"last4"`
	ThreeDSecureUsage *PaymentMethodCardThreeDSecureUsage `json:"three_d_secure_usage"`
	Wallet            *PaymentMethodCardWallet            `json:"wallet"`

	// Please note that the fields below are for internal use only and are not returned
	// as part of standard API requests.
	Description string `json:"description"`
	IIN         string `json:"iin"`
	Issuer      string `json:"issuer"`
}

PaymentMethodCard represents the card-specific properties on a PaymentMethod.

type PaymentMethodCardBrand

type PaymentMethodCardBrand string

PaymentMethodCardBrand is the list of allowed values for the brand property on a Card PaymentMethod.

const (
	PaymentMethodCardBrandAmex       PaymentMethodCardBrand = "amex"
	PaymentMethodCardBrandDiners     PaymentMethodCardBrand = "diners"
	PaymentMethodCardBrandDiscover   PaymentMethodCardBrand = "discover"
	PaymentMethodCardBrandJCB        PaymentMethodCardBrand = "jcb"
	PaymentMethodCardBrandMastercard PaymentMethodCardBrand = "mastercard"
	PaymentMethodCardBrandUnionpay   PaymentMethodCardBrand = "unionpay"
	PaymentMethodCardBrandUnknown    PaymentMethodCardBrand = "unknown"
	PaymentMethodCardBrandVisa       PaymentMethodCardBrand = "visa"
)

List of values that PaymentMethodCardBrand can take.

type PaymentMethodCardChecks

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

PaymentMethodCardChecks represents the checks associated with a Card PaymentMethod.

type PaymentMethodCardParams

type PaymentMethodCardParams struct {
	CVC      *string `form:"cvc"`
	ExpMonth *string `form:"exp_month"`
	ExpYear  *string `form:"exp_year"`
	Number   *string `form:"number"`
	Token    *string `form:"token"`
}

PaymentMethodCardParams is the set of parameters allowed for the `card` hash when creating a PaymentMethod of type card.

type PaymentMethodCardPresent

type PaymentMethodCardPresent struct {
}

PaymentMethodCardPresent represents the card-present-specific properties on a PaymentMethod.

type PaymentMethodCardThreeDSecureUsage

type PaymentMethodCardThreeDSecureUsage struct {
	Supported bool `json:"supported"`
}

PaymentMethodCardThreeDSecureUsage represents the 3DS usage for that Card PaymentMethod.

type PaymentMethodCardWallet

type PaymentMethodCardWallet struct {
	DynamicLast4 string                      `json:"dynamic_last4"`
	Type         PaymentMethodCardWalletType `json:"type"`
}

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

type PaymentMethodCardWalletType

type PaymentMethodCardWalletType string

PaymentMethodCardWalletType is the list of allowed values for the type a wallet can take on a Card PaymentMethod.

const (
	PaymentMethodCardWalletTypeAmexExpressCheckout PaymentMethodCardWalletType = "amex_express_checkout"
	PaymentMethodCardWalletTypeApplePay            PaymentMethodCardWalletType = "apple_pay"
	PaymentMethodCardWalletTypeGooglePay           PaymentMethodCardWalletType = "google_pay"
	PaymentMethodCardWalletTypeMasterpass          PaymentMethodCardWalletType = "masterpass"
	PaymentMethodCardWalletTypeSamsungPay          PaymentMethodCardWalletType = "samsung_pay"
	PaymentMethodCardWalletTypeVisaCheckout        PaymentMethodCardWalletType = "visa_checkout"
)

List of values that PaymentMethodCardWalletType can take.

type PaymentMethodDetachParams

type PaymentMethodDetachParams struct {
	Params   `form:"*"`
	Customer *string `form:"customer"`
}

PaymentMethodDetachParams is the set of parameters that can be used when detaching a PaymentMethod.

type PaymentMethodList

type PaymentMethodList struct {
	ListMeta
	Data []*PaymentMethod `json:"data"`
}

PaymentMethodList is a list of PaymentMethods as retrieved from a list endpoint.

type PaymentMethodListParams

type PaymentMethodListParams struct {
	ListParams `form:"*"`
	Customer   *string `form:"customer"`
	Type       *string `form:"type"`
}

PaymentMethodListParams is the set of parameters that can be used when listing PaymentMethods.

type PaymentMethodParams

type PaymentMethodParams struct {
	Params         `form:"*"`
	BillingDetails *BillingDetailsParams    `form:"billing_details"`
	Card           *PaymentMethodCardParams `form:"card"`
	Customer       *string                  `form:"customer"`
	PaymentMethod  *string                  `form:"payment_method"`
	Type           *string                  `form:"type"`
}

PaymentMethodParams is the set of parameters that can be used when creating or updating a PaymentMethod.

type PaymentMethodType

type PaymentMethodType string

PaymentMethodType is the list of allowed values for the payment method type.

const (
	PaymentMethodTypeCard        PaymentMethodType = "card"
	PaymentMethodTypeCardPresent PaymentMethodType = "card_present"
)

List of values that PaymentMethodType can take.

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

List of values that PaymentSourceType can take.

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               *PayoutDestination  `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"
)

List of values that PayoutDestinationType can take.

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

List of values that PayoutFailureCode can take.

type PayoutInterval

type PayoutInterval string

PayoutInterval describes the payout interval.

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

List of values that PayoutInterval can take.

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

List of values that PayoutMethodType can take.

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

AppendTo implements custom encoding logic for PayoutScheduleParams so that we can send a special value for `delay_days` field if needed.

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

List of values that PayoutSourceType can take.

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

List of values that PayoutStatus can take.

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

List of values that PayoutType can take.

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 Person

type Person struct {
	Account          string              `json:"account"`
	Address          *AccountAddress     `json:"address"`
	AddressKana      *AccountAddress     `json:"address_kana"`
	AddressKanji     *AccountAddress     `json:"address_kanji"`
	Deleted          bool                `json:"deleted"`
	DOB              *DOB                `json:"dob"`
	Email            string              `json:"email"`
	FirstName        string              `json:"first_name"`
	FirstNameKana    string              `json:"first_name_kana"`
	FirstNameKanji   string              `json:"first_name_kanji"`
	Gender           string              `json:"gender"`
	ID               string              `json:"id"`
	IDNumberProvided bool                `json:"id_number_provided"`
	LastName         string              `json:"last_name"`
	LastNameKana     string              `json:"last_name_kana"`
	LastNameKanji    string              `json:"last_name_kanji"`
	MaidenName       string              `json:"maiden_name"`
	Metadata         map[string]string   `json:"metadata"`
	Object           string              `json:"object"`
	Phone            string              `json:"phone"`
	Relationship     *Relationship       `json:"relationship"`
	Requirements     *Requirements       `json:"requirements"`
	SSNLast4Provided bool                `json:"ssn_last_4_provided"`
	Verification     *PersonVerification `json:"verification"`
}

Person is the resource representing a Stripe person. For more details see https://stripe.com/docs/api#persons.

func (*Person) UnmarshalJSON

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

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

type PersonList

type PersonList struct {
	ListMeta
	Data []*Person `json:"data"`
}

PersonList is a list of persons as retrieved from a list endpoint.

type PersonListParams

type PersonListParams struct {
	ListParams   `form:"*"`
	Account      *string                 `form:"-"` // Included in URL
	Relationship *RelationshipListParams `form:"relationship"`
}

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

type PersonParams

type PersonParams struct {
	Params         `form:"*"`
	Account        *string                   `form:"-"` // Included in URL
	Address        *AccountAddressParams     `form:"address"`
	AddressKana    *AccountAddressParams     `form:"address_kana"`
	AddressKanji   *AccountAddressParams     `form:"address_kanji"`
	DOB            *DOBParams                `form:"dob"`
	Email          *string                   `form:"email"`
	FirstName      *string                   `form:"first_name"`
	FirstNameKana  *string                   `form:"first_name_kana"`
	FirstNameKanji *string                   `form:"first_name_kanji"`
	Gender         *string                   `form:"gender"`
	IDNumber       *string                   `form:"id_number"`
	LastName       *string                   `form:"last_name"`
	LastNameKana   *string                   `form:"last_name_kana"`
	LastNameKanji  *string                   `form:"last_name_kanji"`
	MaidenName     *string                   `form:"maiden_name"`
	PersonToken    *string                   `form:"person_token"`
	Phone          *string                   `form:"phone"`
	Relationship   *RelationshipParams       `form:"relationship"`
	SSNLast4       *string                   `form:"ssn_last_4"`
	Verification   *PersonVerificationParams `form:"verification"`
}

PersonParams is the set of parameters that can be used when creating or updating a person. For more details see https://stripe.com/docs/api#create_person.

type PersonVerification

type PersonVerification struct {
	Details     string                        `json:"details"`
	DetailsCode PersonVerificationDetailsCode `json:"details_code"`
	Document    *PersonVerificationDocument   `json:"document"`
	Status      IdentityVerificationStatus    `json:"status"`
}

PersonVerification is the structure for a person's verification details.

type PersonVerificationDetailsCode

type PersonVerificationDetailsCode string

PersonVerificationDetailsCode is a machine-readable code specifying the verification state of a person.

const (
	PersonVerificationDetailsCodeFailedKeyedIdentity PersonVerificationDetailsCode = "failed_keyed_identity"
	PersonVerificationDetailsCodeFailedOther         PersonVerificationDetailsCode = "failed_other"
	PersonVerificationDetailsCodeScanNameMismatch    PersonVerificationDetailsCode = "scan_name_mismatch"
)

List of values that IdentityVerificationDetailsCode can take.

type PersonVerificationDocument

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

PersonVerificationDocument represents the documents associated with a Person.

type PersonVerificationDocumentParams

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

PersonVerificationDocumentParams represents the parameters available for the document verifying a person's identity.

type PersonVerificationParams

type PersonVerificationParams struct {
	Document *PersonVerificationDocumentParams `form:"document"`
}

PersonVerificationParams is used to represent parameters associated with a person's verification details.

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         *Product            `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:

func (*Plan) UnmarshalJSON

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

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

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

List of values that PlanAggregateUsage can take.

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

List of values that PlanBillingScheme can take.

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

List of values that PlanInterval can take.

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"`
	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 {
	FlatAmount int64 `json:"flat_amount"`
	UnitAmount int64 `json:"unit_amount"`
	UpTo       int64 `json:"up_to"`
}

PlanTier configures tiered pricing

type PlanTierParams

type PlanTierParams struct {
	Params     `form:"*"`
	FlatAmount *int64 `form:"flat_amount"`
	UnitAmount *int64 `form:"unit_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"
)

List of values that PlanTiersMode can take.

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

List of values that PlanTransformUsageRound can take.

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

List of values that PlanUsageType can take.

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.

This Logger will be inherited by any backends created by default, but will be overridden if a backend is created with GetBackendWithConfig.

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

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.

type ProductType

type ProductType string

ProductType is the type of a product.

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

List of values that ProductType can take.

type Query

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

Query is the function used to get a page listing.

type RadarValueList

type RadarValueList struct {
	Alias     string                  `json:"alias"`
	Created   int64                   `json:"created"`
	CreatedBy string                  `json:"created_by"`
	Deleted   bool                    `json:"deleted"`
	ID        string                  `json:"id"`
	ItemType  RadarValueListItemType  `json:"item_type"`
	ListItems *RadarValueListItemList `json:"list_items"`
	Livemode  bool                    `json:"livemode"`
	Metadata  map[string]string       `json:"metadata"`
	Name      string                  `json:"name"`
	Object    string                  `json:"object"`
	Updated   int64                   `json:"updated"`
	UpdatedBy string                  `json:"updated_by"`
}

RadarValueList is the resource representing a value list.

type RadarValueListItem

type RadarValueListItem struct {
	Created        int64  `json:"created"`
	CreatedBy      string `json:"created_by"`
	Deleted        bool   `json:"deleted"`
	ID             string `json:"id"`
	Livemode       bool   `json:"livemode"`
	Name           string `json:"name"`
	Object         string `json:"object"`
	Value          string `json:"value"`
	RadarValueList string `json:"value_list"`
}

RadarValueListItem is the resource representing a value list item.

type RadarValueListItemList

type RadarValueListItemList struct {
	ListMeta
	Data []*RadarValueListItem `json:"data"`
}

RadarValueListItemList is a list of value list items as retrieved from a list endpoint.

type RadarValueListItemListParams

type RadarValueListItemListParams struct {
	ListParams     `form:"*"`
	Created        *int64            `form:"created"`
	CreatedRange   *RangeQueryParams `form:"created"`
	RadarValueList *string           `form:"value_list"`
	Value          *string           `form:"value"`
}

RadarValueListItemListParams is the set of parameters that can be used when listing value list items.

type RadarValueListItemParams

type RadarValueListItemParams struct {
	Params         `form:"*"`
	Value          *string `form:"value"`
	RadarValueList *string `form:"value_list"`
}

RadarValueListItemParams is the set of parameters that can be used when creating a value list item.

type RadarValueListItemType

type RadarValueListItemType string

RadarValueListItemType is the possible values for a type of value list items.

const (
	RadarValueListItemTypeCardBin             RadarValueListItemType = "card_bin"
	RadarValueListItemTypeCardFingerprint     RadarValueListItemType = "card_fingerprint"
	RadarValueListItemTypeCountry             RadarValueListItemType = "country"
	RadarValueListItemTypeEmail               RadarValueListItemType = "email"
	RadarValueListItemTypeIPAddress           RadarValueListItemType = "ip_address"
	RadarValueListItemTypeString              RadarValueListItemType = "string"
	RadarValueListItemTypeCaseSensitiveString RadarValueListItemType = "case_sensitive_string"
)

List of values that RadarValueListItemType can take.

type RadarValueListList

type RadarValueListList struct {
	ListMeta
	Data []*RadarValueList `json:"data"`
}

RadarValueListList is a list of value lists as retrieved from a list endpoint.

type RadarValueListListParams

type RadarValueListListParams struct {
	ListParams   `form:"*"`
	Alias        *string           `form:"alias"`
	Contains     *string           `form:"contains"`
	Created      *int64            `form:"created"`
	CreatedRange *RangeQueryParams `form:"created"`
}

RadarValueListListParams is the set of parameters that can be used when listing value lists.

type RadarValueListParams

type RadarValueListParams struct {
	Params   `form:"*"`
	Alias    *string `form:"alias"`
	ItemType *string `form:"item_type"`
	Name     *string `form:"name"`
}

RadarValueListParams is the set of parameters that can be used when creating a value list.

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

List of values that RecipientTransferDestinationType can take.

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

List of values that RecipientTransferFailureCode can take.

type RecipientTransferMethodType

type RecipientTransferMethodType string

RecipientTransferMethodType represents the type of recipient_transfer

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

List of values that RecipientTransferMethodType can take.

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

List of values that RecipientTransferSourceType can take.

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

List of values that RecipientTransferStatus can take.

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

List of values that RecipientTransferType can take.

type RecipientType

type RecipientType string

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

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

List of values that RecipientType can take.

type RedirectFlow

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

RedirectFlow informs of the state of a redirect authentication flow.

type RedirectParams

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

RedirectParams is the set of parameters allowed for the redirect hash on source creation or update.

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"`
	FailureBalanceTransaction *BalanceTransaction `json:"failure_balance_transaction"`
	ID                        string              `json:"id"`
	Metadata                  map[string]string   `json:"metadata"`
	Object                    string              `json:"object"`
	Reason                    RefundReason        `json:"reason"`
	ReceiptNumber             string              `json:"receipt_number"`
	SourceTransferReversal    *Reversal           `json:"source_transfer_reversal"`
	Status                    RefundStatus        `json:"status"`
	TransferReversal          *Reversal           `json:"transfer_reversal"`
}

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

List of values that RefundReason can take.

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

List of values that RefundStatus can take.

type Relationship

type Relationship struct {
	AccountOpener    bool    `json:"account_opener"`
	Director         bool    `json:"director"`
	Owner            bool    `json:"owner"`
	PercentOwnership float64 `json:"percent_ownership"`
	Title            string  `json:"title"`
}

Relationship represents how the Person relates to the business.

type RelationshipListParams

type RelationshipListParams struct {
	AccountOpener *bool `form:"account_opener"`
	Director      *bool `form:"director"`
	Owner         *bool `form:"owner"`
}

RelationshipListParams is used to filter persons by the relationship

type RelationshipParams

type RelationshipParams struct {
	AccountOpener    *bool    `form:"account_opener"`
	Director         *bool    `form:"director"`
	Owner            *bool    `form:"owner"`
	PercentOwnership *float64 `form:"percent_ownership"`
	Title            *string  `form:"title"`
}

RelationshipParams is used to set the relationship between an account and a person.

type ReportRun

type ReportRun struct {
	Created     int64                `json:"created"`
	Error       string               `json:"error"`
	ID          string               `json:"id"`
	Livemode    bool                 `json:"livemode"`
	Object      string               `json:"object"`
	Parameters  *ReportRunParameters `json:"parameters"`
	ReportType  string               `json:"report_type"`
	Result      *File                `json:"result"`
	Status      ReportRunStatus      `json:"status"`
	SucceededAt int64                `json:"succeeded_at"`
}

ReportRun is the resource representing a report run.

type ReportRunList

type ReportRunList struct {
	ListMeta
	Data []*ReportRun `json:"data"`
}

ReportRunList is a list of report runs as retrieved from a list endpoint.

type ReportRunListParams

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

ReportRunListParams is the set of parameters that can be used when listing report runs.

type ReportRunParameters

type ReportRunParameters struct {
	Columns           []string `json:"columns"`
	ConnectedAccount  string   `json:"connected_account"`
	Currency          Currency `json:"currency"`
	IntervalEnd       int64    `json:"interval_end"`
	IntervalStart     int64    `json:"interval_start"`
	Payout            string   `json:"payout"`
	ReportingCategory string   `json:"reporting_category"`
}

ReportRunParameters describes the parameters hash on a report run.

type ReportRunParametersParams

type ReportRunParametersParams struct {
	Columns           []*string `form:"columns"`
	ConnectedAccount  *string   `form:"connected_account"`
	Currency          *string   `form:"currency"`
	IntervalEnd       *int64    `form:"interval_end"`
	IntervalStart     *int64    `form:"interval_start"`
	Payout            *string   `form:"payout"`
	ReportingCategory *string   `form:"reporting_category"`
}

ReportRunParametersParams is the set of parameters that can be used when creating a report run.

type ReportRunParams

type ReportRunParams struct {
	Params     `form:"*"`
	Parameters *ReportRunParametersParams `form:"parameters"`
	ReportType *string                    `form:"report_type"`
}

ReportRunParams is the set of parameters that can be used when creating a report run.

type ReportRunStatus

type ReportRunStatus string

ReportRunStatus is the possible values for status on a report run.

const (
	ReportRunStatusFailed    ReportRunStatus = "failed"
	ReportRunStatusPending   ReportRunStatus = "pending"
	ReportRunStatusSucceeded ReportRunStatus = "succeeded"
)

List of values that ReportRunStatus can take.

type ReportType

type ReportType struct {
	DefaultColumns     []string `json:"default_columns"`
	Created            int64    `json:"created"`
	DataAvailableEnd   int64    `json:"data_available_end"`
	DataAvailableStart int64    `json:"data_available_start"`
	ID                 string   `json:"id"`
	Name               string   `json:"name"`
	Object             string   `json:"object"`
	Updated            int64    `json:"updated"`
	Version            int64    `json:"version"`
}

ReportType is the resource representing a report type.

type ReportTypeList

type ReportTypeList struct {
	ListMeta
	Data []*ReportType `json:"data"`
}

ReportTypeList is a list of report types as retrieved from a list endpoint.

type ReportTypeListParams

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

ReportTypeListParams is the set of parameters that can be used when listing report types.

type ReportTypeParams

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

ReportTypeParams is the set of parameters that can be used when retrieving a report type.

type Requirements

type Requirements struct {
	CurrentlyDue  []string `json:"currently_due"`
	EventuallyDue []string `json:"eventually_due"`
	PastDue       []string `json:"past_due"`
}

Requirements represents what's missing to verify a Person.

type Reversal

type Reversal struct {
	Amount                   int64               `json:"amount"`
	BalanceTransaction       *BalanceTransaction `json:"balance_transaction"`
	Created                  int64               `json:"created"`
	Currency                 Currency            `json:"currency"`
	DestinationPaymentRefund *Refund             `json:"destination_payment_refund"`
	ID                       string              `json:"id"`
	Metadata                 map[string]string   `json:"metadata"`
	SourceRefund             *Refund             `json:"source_refund"`
	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"`
	Object        string           `json:"object"`
	Open          bool             `json:"open"`
	PaymentIntent *PaymentIntent   `json:"payment_intent"`
	Reason        ReviewReasonType `json:"reason"`
}

Review is the resource representing a Radar review. For more details see https://stripe.com/docs/api#reviews.

func (*Review) UnmarshalJSON

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

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

type ReviewApproveParams

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

ReviewApproveParams is the set of parameters that can be used when approving a review.

type ReviewList

type ReviewList struct {
	ListMeta
	Data []*Review `json:"data"`
}

ReviewList is a list of reviews as retrieved from a list endpoint.

type ReviewListParams

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

ReviewListParams is the set of parameters that can be used when listing reviews.

type ReviewParams

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

ReviewParams is the set of parameters that can be used when approving a review.

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

List of values that ReviewReasonType can take.

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

SKU is the resource representing a SKU. For more details see https://stripe.com/docs/api#skus.

func (*SKU) UnmarshalJSON

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

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

type SKUInventoryType

type SKUInventoryType string

SKUInventoryType describe's the possible value for inventory type

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

List of values that SKUInventoryType can take.

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

List of values that SKUInventoryValue can take.

type SKUList

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

SKUList is a list of SKUs as returned from a list endpoint.

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

SKUListParams is the set of parameters that can be used when listing SKUs.

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

SKUParams is the set of parameters allowed on SKU creation or update.

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

Shipping describes the shipping hash on an order.

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

ShippingMethod describes a shipping method as available on an order.

type ShippingParams

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

ShippingParams is the set of parameters that can be used for the shipping hash on order creation.

type SigmaScheduledQueryRun

type SigmaScheduledQueryRun struct {
	Created              int64                        `json:"created"`
	DataLoadTime         int64                        `json:"data_load_time"`
	Error                string                       `json:"error"`
	File                 *File                        `json:"file"`
	ID                   string                       `json:"id"`
	Livemode             bool                         `json:"livemode"`
	Object               string                       `json:"object"`
	ResultAvailableUntil int64                        `json:"result_available_until"`
	SQL                  string                       `json:"sql"`
	Status               SigmaScheduledQueryRunStatus `json:"status"`
	Query                string                       `json:"query"`
}

SigmaScheduledQueryRun is the resource representing a scheduled query run.

func (*SigmaScheduledQueryRun) UnmarshalJSON

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

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

type SigmaScheduledQueryRunList

type SigmaScheduledQueryRunList struct {
	ListMeta
	Data []*SigmaScheduledQueryRun `json:"data"`
}

SigmaScheduledQueryRunList is a list of scheduled query runs as retrieved from a list endpoint.

type SigmaScheduledQueryRunListParams

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

SigmaScheduledQueryRunListParams is the set of parameters that can be used when listing scheduled query runs.

type SigmaScheduledQueryRunParams

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

SigmaScheduledQueryRunParams is the set of parameters that can be used when updating a scheduled query run.

type SigmaScheduledQueryRunStatus

type SigmaScheduledQueryRunStatus string

SigmaScheduledQueryRunStatus is the possible values for status for a scheduled query run.

const (
	SigmaScheduledQueryRunStatusCanceled  SigmaScheduledQueryRunStatus = "canceled"
	SigmaScheduledQueryRunStatusCompleted SigmaScheduledQueryRunStatus = "completed"
	SigmaScheduledQueryRunStatusFailed    SigmaScheduledQueryRunStatus = "failed"
	SigmaScheduledQueryRunStatusTimedOut  SigmaScheduledQueryRunStatus = "timed_out"
)

List of values that SigmaScheduledQueryRunStatus can take.

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

Source is the resource representing a Source. For more details see https://stripe.com/docs/api#sources.

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

List of values that SourceCodeVerificationFlowStatus can take.

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

List of values that SourceFlow can take.

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 SourceMandateNotificationMethod `json:"notification_method"`
	Reference          string                          `json:"reference"`
	URL                string                          `json:"url"`
}

SourceMandate describes a source mandate.

type SourceMandateAcceptance

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

SourceMandateAcceptance describes a source mandate acceptance state.

type SourceMandateAcceptanceParams

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

SourceMandateAcceptanceParams describes the set of parameters allowed for the `acceptance` hash on source creation or update.

type SourceMandateAcceptanceStatus

type SourceMandateAcceptanceStatus string

SourceMandateAcceptanceStatus represents the possible failure reasons of a redirect flow.

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

List of values that SourceMandateAcceptanceStatus can take.

type SourceMandateNotificationMethod

type SourceMandateNotificationMethod string

SourceMandateNotificationMethod represents the possible methods of notification for a mandate.

const (
	SourceMandateNotificationMethodEmail  SourceMandateNotificationMethod = "email"
	SourceMandateNotificationMethodManual SourceMandateNotificationMethod = "manual"
	SourceMandateNotificationMethodNone   SourceMandateNotificationMethod = "none"
)

List of values that SourceMandateNotificationMethod can take.

type SourceMandateParams

type SourceMandateParams struct {
	Acceptance         *SourceMandateAcceptanceParams `form:"acceptance"`
	NotificationMethod *string                        `form:"notification_method"`
}

SourceMandateParams describes the set of parameters allowed for the `mandate` hash on source creation or update.

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"`
	Mandate             *SourceMandateParams  `form:"mandate"`
	OriginalSource      *string               `form:"original_source"`
	Owner               *SourceOwnerParams    `form:"owner"`
	Receiver            *SourceReceiverParams `form:"receiver"`
	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"`
}

SourceObjectParams is the set of parameters allowed on source creation or update.

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

SourceOwner describes the owner hash on a source.

type SourceOwnerParams

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

SourceOwnerParams is the set of parameters allowed for the owner hash on source creation or update.

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)

AppendTo implements custom encoding logic for SourceParams.

type SourceReceiverParams

type SourceReceiverParams struct {
	RefundAttributesMethod *string `form:"refund_attributes_method"`
}

SourceReceiverParams is the set of parameters allowed for the `receiver` hash on source creation or update.

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

List of values that SourceRedirectFlowFailureReason can take.

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

List of values that SourceRedirectFlowStatus can take.

type SourceRefundAttributesMethod

type SourceRefundAttributesMethod string

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

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

List of values that SourceRefundAttributesMethod can take.

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

List of values that SourceRefundAttributesStatus can take.

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

List of values that SourceStatus can take.

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

List of values that SourceUsage can take.

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.

type StatusTransitionsFilterParams

type StatusTransitionsFilterParams struct {
	Canceled       *int64            `form:"canceled"`
	CanceledRange  *RangeQueryParams `form:"canceled"`
	Fulfilled      *int64            `form:"fulfilled"`
	FulfilledRange *RangeQueryParams `form:"fulfilled"`
	Paid           *int64            `form:"paid"`
	PaidRange      *RangeQueryParams `form:"paid"`
	Returned       *int64            `form:"returned"`
	ReturnedRange  *RangeQueryParams `form:"returned"`
}

StatusTransitionsFilterParams are parameters that can used to filter on status_transition when listing orders.

type Subscription

type Subscription struct {
	ApplicationFeePercent float64                        `json:"application_fee_percent"`
	Billing               SubscriptionBilling            `json:"billing"`
	BillingCycleAnchor    int64                          `json:"billing_cycle_anchor"`
	BillingThresholds     *SubscriptionBillingThresholds `json:"billing_thresholds"`
	CancelAt              int64                          `json:"cancel_at"`
	CancelAtPeriodEnd     bool                           `json:"cancel_at_period_end"`
	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"`
	DefaultSource         *PaymentSource                 `json:"default_source"`
	Discount              *Discount                      `json:"discount"`
	EndedAt               int64                          `json:"ended_at"`
	ID                    string                         `json:"id"`
	Items                 *SubscriptionItemList          `json:"items"`
	LatestInvoice         *Invoice                       `json:"latest_invoice"`
	Livemode              bool                           `json:"livemode"`
	Metadata              map[string]string              `json:"metadata"`
	Object                string                         `json:"object"`
	OnBehalfOf            *Account                       `json:"on_behalf_of"`
	Plan                  *Plan                          `json:"plan"`
	Quantity              int64                          `json:"quantity"`
	Start                 int64                          `json:"start"`
	Status                SubscriptionStatus             `json:"status"`
	TaxPercent            float64                        `json:"tax_percent"`
	TransferData          *SubscriptionTransferData      `json:"transfer_data"`
	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"
)

List of values that SubscriptionBilling can take.

type SubscriptionBillingThresholds

type SubscriptionBillingThresholds struct {
	AmountGTE               int64 `json:"amount_gte"`
	ResetBillingCycleAnchor bool  `json:"reset_billing_cycle_anchor"`
}

SubscriptionBillingThresholds is a structure representing the billing thresholds for a subscription.

type SubscriptionBillingThresholdsParams

type SubscriptionBillingThresholdsParams struct {
	AmountGTE               *int64 `form:"amount_gte"`
	ResetBillingCycleAnchor *bool  `form:"reset_billing_cycle_anchor"`
}

SubscriptionBillingThresholdsParams is a structure representing the parameters allowed to control billing thresholds for a subscription.

type SubscriptionCancelParams

type SubscriptionCancelParams struct {
	Params     `form:"*"`
	InvoiceNow *bool `form:"invoice_now"`
	Prorate    *bool `form:"prorate"`
}

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 {
	BillingThresholds SubscriptionItemBillingThresholds `json:"billing_thresholds"`
	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"`
	Subscription      string                            `json:"subscription"`
}

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

type SubscriptionItemBillingThresholds

type SubscriptionItemBillingThresholds struct {
	UsageGTE int64 `form:"usage_gte"`
}

SubscriptionItemBillingThresholds is a structure representing the billing thresholds for a subscription item.

type SubscriptionItemBillingThresholdsParams

type SubscriptionItemBillingThresholdsParams struct {
	UsageGTE *int64 `form:"usage_gte"`
}

SubscriptionItemBillingThresholdsParams is a structure representing the parameters allowed to control billing thresholds for a subscription item.

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
	BillingThresholds *SubscriptionItemBillingThresholdsParams `form:"billing_thresholds"`
	ClearUsage        *bool                                    `form:"clear_usage"`
	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"`
	CurrentPeriodEnd        *int64            `form:"current_period_end"`
	CurrentPeriodEndRange   *RangeQueryParams `form:"current_period_end"`
	CurrentPeriodStart      *int64            `form:"current_period_start"`
	CurrentPeriodStartRange *RangeQueryParams `form:"current_period_start"`
	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"`
	BackdateStartDate           *int64                               `form:"backdate_start_date"`
	Billing                     *string                              `form:"billing"`
	BillingCycleAnchor          *int64                               `form:"billing_cycle_anchor"`
	BillingCycleAnchorNow       *bool                                `form:"-"` // See custom AppendTo
	BillingCycleAnchorUnchanged *bool                                `form:"-"` // See custom AppendTo
	BillingThresholds           *SubscriptionBillingThresholdsParams `form:"billing_thresholds"`
	CancelAt                    *int64                               `form:"cancel_at"`
	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"`
	DefaultSource               *string                              `form:"default_source"`
	Items                       []*SubscriptionItemsParams           `form:"items"`
	OnBehalfOf                  *string                              `form:"on_behalf_of"`
	Plan                        *string                              `form:"plan"`
	Prorate                     *bool                                `form:"prorate"`
	ProrationDate               *int64                               `form:"proration_date"`
	Quantity                    *int64                               `form:"quantity"`
	TaxPercent                  *float64                             `form:"tax_percent"`
	TrialEnd                    *int64                               `form:"trial_end"`
	TransferData                *SubscriptionTransferDataParams      `form:"transfer_data"`
	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 SubscriptionSchedule

type SubscriptionSchedule struct {
	Billing              SubscriptionBilling                  `json:"billing"`
	BillingThresholds    *SubscriptionBillingThresholds       `json:"billing_thresholds"`
	CanceledAt           int64                                `json:"canceled_at"`
	CompletedAt          int64                                `json:"completed_at"`
	Created              int64                                `json:"created"`
	CurrentPhase         *SubscriptionScheduleCurrentPhase    `json:"current_phase"`
	Customer             *Customer                            `json:"customer"`
	ID                   string                               `json:"id"`
	InvoiceSettings      *SubscriptionScheduleInvoiceSettings `json:"invoice_settings"`
	Livemode             bool                                 `json:"livemode"`
	Metadata             map[string]string                    `json:"metadata"`
	Object               string                               `json:"object"`
	Phases               []*SubscriptionSchedulePhase         `json:"phases"`
	ReleasedSubscription *Subscription                        `json:"released_subscription"`
	Revision             *SubscriptionScheduleRevision        `json:"revision"`
	RenewalBehavior      SubscriptionScheduleRenewalBehavior  `json:"renewal_behavior"`
	RenewalInterval      *SubscriptionScheduleRenewalInterval `json:"renewal_interval"`
	Status               SubscriptionScheduleStatus           `json:"status"`
	Subscription         *Subscription                        `json:"subscription"`
}

SubscriptionSchedule is the resource representing a Stripe subscription schedule.

func (*SubscriptionSchedule) UnmarshalJSON

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

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

type SubscriptionScheduleCancelParams

type SubscriptionScheduleCancelParams struct {
	Params     `form:"*"`
	InvoiceNow *bool `form:"invoice_now"`
	Prorate    *bool `form:"prorate"`
}

SubscriptionScheduleCancelParams is the set of parameters that can be used when canceling a subscription schedule.

type SubscriptionScheduleCurrentPhase

type SubscriptionScheduleCurrentPhase struct {
	EndDate   int64 `json:"end_date"`
	StartDate int64 `json:"start_date"`
}

SubscriptionScheduleCurrentPhase is a structure the current phase's period.

type SubscriptionScheduleInvoiceSettings

type SubscriptionScheduleInvoiceSettings struct {
	DaysUntilDue int64 `json:"days_until_due"`
}

SubscriptionScheduleInvoiceSettings is a structure representing the settings applied to invoices associated with a subscription schedule.

type SubscriptionScheduleInvoiceSettingsParams

type SubscriptionScheduleInvoiceSettingsParams struct {
	DaysUntilDue *int64 `form:"days_until_due"`
}

SubscriptionScheduleInvoiceSettingsParams is a structure representing the parameters allowed to control invoice settings on invoices associated with a subscription schedule.

type SubscriptionScheduleList

type SubscriptionScheduleList struct {
	ListMeta
	Data []*SubscriptionSchedule `json:"data"`
}

SubscriptionScheduleList is a list object for subscription schedules.

type SubscriptionScheduleListParams

type SubscriptionScheduleListParams struct {
	ListParams       `form:"*"`
	CanceledAt       int64             `form:"canceled_at"`
	CanceledAtRange  *RangeQueryParams `form:"canceled_at"`
	CompletedAt      int64             `form:"completed_at"`
	CompletedAtRange *RangeQueryParams `form:"completed_at"`
	Created          int64             `form:"created"`
	CreatedRange     *RangeQueryParams `form:"created"`
	Customer         string            `form:"customer"`
	ReleasedAt       int64             `form:"released_at"`
	ReleasedAtRange  *RangeQueryParams `form:"released_at"`
	Scheduled        *bool             `form:"scheduled"`
}

SubscriptionScheduleListParams is the set of parameters that can be used when listing subscription schedules.

type SubscriptionScheduleParams

type SubscriptionScheduleParams struct {
	Params            `form:"*"`
	Billing           *string                                    `form:"billing"`
	BillingThresholds *SubscriptionBillingThresholdsParams       `form:"billing_thresholds"`
	Customer          *string                                    `form:"customer"`
	FromSubscription  *string                                    `form:"from_subscription"`
	InvoiceSettings   *SubscriptionScheduleInvoiceSettingsParams `form:"invoice_settings"`
	Phases            []*SubscriptionSchedulePhaseParams         `form:"phases"`
	RenewalBehavior   *string                                    `form:"renewal_behavior"`
	StartDate         *int64                                     `form:"start_date"`
}

SubscriptionScheduleParams is the set of parameters that can be used when creating or updating a subscription schedule.

type SubscriptionSchedulePhase

type SubscriptionSchedulePhase struct {
	ApplicationFeePercent float64                          `json:"application_fee_percent"`
	Coupon                *Coupon                          `json:"coupon"`
	EndDate               int64                            `json:"end_date"`
	Plans                 []*SubscriptionSchedulePhaseItem `json:"plans"`
	StartDate             int64                            `json:"start_date"`
	TaxPercent            float64                          `json:"tax_percent"`
	TrialEnd              int64                            `json:"trial_end"`
}

SubscriptionSchedulePhase is a structure a phase of a subscription schedule.

type SubscriptionSchedulePhaseItem

type SubscriptionSchedulePhaseItem struct {
	BillingThresholds *SubscriptionItemBillingThresholds `json:"billing_thresholds"`
	Plan              *Plan                              `json:"plan"`
	Quantity          int64                              `json:"quantity"`
}

SubscriptionSchedulePhaseItem represents plan details for a given phase

type SubscriptionSchedulePhaseItemParams

type SubscriptionSchedulePhaseItemParams struct {
	BillingThresholds *SubscriptionItemBillingThresholdsParams `form:"billing_thresholds"`
	Plan              *string                                  `form:"plan"`
	Quantity          *int64                                   `form:"quantity"`
}

SubscriptionSchedulePhaseItemParams is a structure representing the parameters allowed to control a specic plan on a phase on a subscription schedule.

type SubscriptionSchedulePhaseParams

type SubscriptionSchedulePhaseParams struct {
	ApplicationFeePercent *int64                                 `form:"application_fee_percent"`
	Coupon                *string                                `form:"coupon"`
	EndDate               *int64                                 `form:"end_date"`
	Iterations            *int64                                 `form:"iterations"`
	Plans                 []*SubscriptionSchedulePhaseItemParams `form:"plans"`
	Trial                 *bool                                  `form:"trial"`
	TrialEnd              *int64                                 `form:"trial_end"`
}

SubscriptionSchedulePhaseParams is a structure representing the parameters allowed to control a phase on a subscription schedule.

type SubscriptionScheduleReleaseParams

type SubscriptionScheduleReleaseParams struct {
	Params             `form:"*"`
	PreserveCancelDate *bool `form:"preserve_cancel_date"`
}

SubscriptionScheduleReleaseParams is the set of parameters that can be used when releasing a subscription schedule.

type SubscriptionScheduleRenewalBehavior

type SubscriptionScheduleRenewalBehavior string

SubscriptionScheduleRenewalBehavior describe what happens to a schedule when it ends.

const (
	SubscriptionScheduleRenewalBehaviorNone    SubscriptionScheduleRenewalBehavior = "none"
	SubscriptionScheduleRenewalBehaviorRenew   SubscriptionScheduleRenewalBehavior = "release"
	SubscriptionScheduleRenewalBehaviorRelease SubscriptionScheduleRenewalBehavior = "renew"
)

List of values that SubscriptionScheduleRenewalBehavior can take.

type SubscriptionScheduleRenewalInterval

type SubscriptionScheduleRenewalInterval struct {
	Interval PlanInterval `form:"interval"`
	Length   int64        `form:"length"`
}

SubscriptionScheduleRenewalInterval represents the interval and duration of a schedule.

type SubscriptionScheduleRevision

type SubscriptionScheduleRevision struct {
	Created          int64                                `json:"created"`
	ID               string                               `json:"id"`
	Livemode         bool                                 `json:"livemode"`
	Metadata         map[string]string                    `json:"metadata"`
	Object           string                               `json:"object"`
	Phases           []*SubscriptionSchedulePhase         `json:"phases"`
	PreviousRevision *SubscriptionSchedule                `json:"previous_revision"`
	RenewalBehavior  SubscriptionScheduleRenewalBehavior  `json:"renewal_behavior"`
	RenewalInterval  *SubscriptionScheduleRenewalInterval `json:"renewal_interval"`
	Schedule         *SubscriptionSchedule                `json:"schedule"`
}

SubscriptionScheduleRevision is the resource representing a Stripe subscription schedule revision.

func (*SubscriptionScheduleRevision) UnmarshalJSON

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

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

type SubscriptionScheduleRevisionList

type SubscriptionScheduleRevisionList struct {
	ListMeta
	Data []*SubscriptionScheduleRevision `json:"data"`
}

SubscriptionScheduleRevisionList is a list object for subscription schedule revisions.

type SubscriptionScheduleRevisionListParams

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

SubscriptionScheduleRevisionListParams is the set of parameters that can be used when listing subscription schedules.

type SubscriptionScheduleRevisionParams

type SubscriptionScheduleRevisionParams struct {
	Params   `form:"*"`
	Schedule *string `form:"-"` // Included in the URL
}

SubscriptionScheduleRevisionParams is used when retrieving a schedule revision.

type SubscriptionScheduleStatus

type SubscriptionScheduleStatus string

SubscriptionScheduleStatus is the list of allowed values for the schedule's status.

const (
	SubscriptionScheduleStatusActive    SubscriptionScheduleStatus = "active"
	SubscriptionScheduleStatusCanceled  SubscriptionScheduleStatus = "canceled"
	SubscriptionScheduleStatusCompleted SubscriptionScheduleStatus = "completed"
	SubscriptionScheduleStatusPastDue   SubscriptionScheduleStatus = "not_started"
	SubscriptionScheduleStatusTrialing  SubscriptionScheduleStatus = "released"
)

List of values that SubscriptionScheduleStatus can take.

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"
	SubscriptionStatusIncomplete        SubscriptionStatus = "incomplete"
	SubscriptionStatusIncompleteExpired SubscriptionStatus = "incomplete_expired"
	SubscriptionStatusPastDue           SubscriptionStatus = "past_due"
	SubscriptionStatusTrialing          SubscriptionStatus = "trialing"
	SubscriptionStatusUnpaid            SubscriptionStatus = "unpaid"
)

List of values that SubscriptionStatus can take.

type SubscriptionTransferData

type SubscriptionTransferData struct {
	Destination *Account `json:"destination"`
}

SubscriptionTransferData represents the information for the transfer_data associated with a subscription.

type SubscriptionTransferDataParams

type SubscriptionTransferDataParams struct {
	Destination *string `form:"destination"`
}

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

type SupportedBackend

type SupportedBackend string

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

type TerminalConnectionToken

type TerminalConnectionToken struct {
	Object string `json:"object"`
	Secret string `json:"secret"`
}

TerminalConnectionToken is the resource representing a Stripe terminal connection token.

type TerminalConnectionTokenParams

type TerminalConnectionTokenParams struct {
	Params          `form:"*"`
	OperatorAccount *string `form:"operator_account"`
}

TerminalConnectionTokenParams is the set of parameters that can be used when creating a terminal connection token.

type TerminalLocation

type TerminalLocation struct {
	Address     *AccountAddressParams `json:"address"`
	Deleted     bool                  `json:"deleted"`
	DisplayName string                `json:"display_name"`
	ID          string                `json:"id"`
	Object      string                `json:"object"`
}

TerminalLocation is the resource representing a Stripe terminal location.

type TerminalLocationList

type TerminalLocationList struct {
	ListMeta
	Data []*TerminalLocation `json:"data"`
}

TerminalLocationList is a list of terminal readers as retrieved from a list endpoint.

type TerminalLocationListParams

type TerminalLocationListParams struct {
	ListParams      `form:"*"`
	OperatorAccount *string `form:"operator_account"`
}

TerminalLocationListParams is the set of parameters that can be used when listing temrinal locations.

type TerminalLocationParams

type TerminalLocationParams struct {
	Params          `form:"*"`
	Address         *AccountAddressParams `form:"address"`
	DisplayName     *string               `form:"display_name"`
	OperatorAccount *string               `form:"operator_account"`
}

TerminalLocationParams is the set of parameters that can be used when creating or updating a terminal location.

type TerminalReader

type TerminalReader struct {
	Deleted         bool   `json:"deleted"`
	DeviceSwVersion string `json:"device_sw_version"`
	DeviceType      string `json:"device_type"`
	ID              string `json:"id"`
	IPAddress       string `json:"ip_address"`
	Label           string `json:"label"`
	Location        string `json:"location"`
	Object          string `json:"object"`
	SerialNumber    string `json:"serial_number"`
	Status          string `json:"status"`
}

TerminalReader is the resource representing a Stripe terminal reader.

type TerminalReaderGetParams

type TerminalReaderGetParams struct {
	Params          `form:"*"`
	OperatorAccount *string `form:"operator_account"`
}

TerminalReaderGetParams is the set of parameters that can be used to get a terminal reader.

type TerminalReaderList

type TerminalReaderList struct {
	ListMeta
	Data []*TerminalReader `json:"data"`
}

TerminalReaderList is a list of terminal readers as retrieved from a list endpoint.

type TerminalReaderListParams

type TerminalReaderListParams struct {
	ListParams      `form:"*"`
	Location        *string `form:"location"`
	OperatorAccount *string `form:"operator_account"`
	Status          *string `form:"status"`
}

TerminalReaderListParams is the set of parameters that can be used when listing temrinal readers.

type TerminalReaderParams

type TerminalReaderParams struct {
	Params           `form:"*"`
	Label            *string `form:"label"`
	Location         *string `form:"location"`
	OperatorAccount  *string `form:"operator_account"`
	RegistrationCode *string `form:"registration_code"`
}

TerminalReaderParams is the set of parameters that can be used for creating or updating a terminal reader.

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.

type ThreeDSecureStatus

type ThreeDSecureStatus string

ThreeDSecureStatus represents the possible statuses of a ThreeDSecure object.

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

List of values that TokenType can take.

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

List of values that TransferSourceType can take.

type UsageRecord

type UsageRecord struct {
	ID               string `json:"id"`
	Livemode         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 UsageRecordSummary

type UsageRecordSummary struct {
	ID               string  `json:"id"`
	Invoice          string  `json:"invoice"`
	Livemode         bool    `json:"livemode"`
	Object           string  `json:"object"`
	Period           *Period `json:"period"`
	SubscriptionItem string  `json:"subscription_item"`
	TotalUsage       int64   `json:"total_usage"`
}

UsageRecordSummary represents a usage record summary. See https://stripe.com/docs/api#usage_records

type UsageRecordSummaryList

type UsageRecordSummaryList struct {
	ListMeta
	Data []*UsageRecordSummary `json:"data"`
}

UsageRecordSummaryList is a list of usage record summaries as retrieved from a list endpoint.

type UsageRecordSummaryListParams

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

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

type VerificationDocumentDetailsCode

type VerificationDocumentDetailsCode string

VerificationDocumentDetailsCode is a machine-readable code specifying the verification state of a document associated with a person.

const (
	VerificationDocumentDetailsCodeDocumentCorrupt               VerificationDocumentDetailsCode = "document_corrupt"
	VerificationDocumentDetailsCodeDocumentFailedCopy            VerificationDocumentDetailsCode = "document_failed_copy"
	VerificationDocumentDetailsCodeDocumentFailedGreyscale       VerificationDocumentDetailsCode = "document_failed_greyscale"
	VerificationDocumentDetailsCodeDocumentFailedOther           VerificationDocumentDetailsCode = "document_failed_other"
	VerificationDocumentDetailsCodeDocumentFailedTestMode        VerificationDocumentDetailsCode = "document_failed_test_mode"
	VerificationDocumentDetailsCodeDocumentFraudulent            VerificationDocumentDetailsCode = "document_fraudulent"
	VerificationDocumentDetailsCodeDocumentIDTypeNotSupported    VerificationDocumentDetailsCode = "document_id_type_not_supported"
	VerificationDocumentDetailsCodeDocumentIDCountryNotSupported VerificationDocumentDetailsCode = "document_id_country_not_supported"
	VerificationDocumentDetailsCodeDocumentManipulated           VerificationDocumentDetailsCode = "document_manipulated"
	VerificationDocumentDetailsCodeDocumentMissingBack           VerificationDocumentDetailsCode = "document_missing_back"
	VerificationDocumentDetailsCodeDocumentMissingFront          VerificationDocumentDetailsCode = "document_missing_front"
	VerificationDocumentDetailsCodeDocumentNotReadable           VerificationDocumentDetailsCode = "document_not_readable"
	VerificationDocumentDetailsCodeDocumentNotUploaded           VerificationDocumentDetailsCode = "document_not_uploaded"
	VerificationDocumentDetailsCodeDocumentTooLarge              VerificationDocumentDetailsCode = "document_too_large"
)

List of values that IdentityVerificationDetailsCode can take.

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.

type WebhookEndpoint

type WebhookEndpoint struct {
	APIVersion    string   `json:"api_version"`
	Application   string   `json:"application"`
	Connect       bool     `json:"connect"`
	Created       int64    `json:"created"`
	Deleted       bool     `json:"deleted"`
	EnabledEvents []string `json:"enabled_events"`
	ID            string   `json:"id"`
	Livemode      bool     `json:"livemode"`
	Object        string   `json:"object"`
	Secret        string   `json:"secret"`
	Status        string   `json:"status"`
	URL           string   `json:"url"`
}

WebhookEndpoint is the resource representing a Stripe webhook endpoint. For more details see https://stripe.com/docs/api#webhook_endpoints.

func (*WebhookEndpoint) UnmarshalJSON

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

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

type WebhookEndpointList

type WebhookEndpointList struct {
	ListMeta
	Data []*WebhookEndpoint `json:"data"`
}

WebhookEndpointList is a list of webhook endpoints as retrieved from a list endpoint.

type WebhookEndpointListParams

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

WebhookEndpointListParams is the set of parameters that can be used when listing webhook endpoints. For more detail see https://stripe.com/docs/api#list_webhook_endpoints.

type WebhookEndpointParams

type WebhookEndpointParams struct {
	Params        `form:"*"`
	Connect       *bool     `form:"connect"`
	Disabled      *bool     `form:"disabled"`
	EnabledEvents []*string `form:"enabled_events"`
	URL           *string   `form:"url"`

	// This parameter is only available on creation.
	// We recommend setting the API version that the library is pinned to. See apiversion in stripe.go
	APIVersion *string `form:"api_version"`
}

WebhookEndpointParams is the set of parameters that can be used when creating a webhook endpoint. For more details see https://stripe.com/docs/api#create_webhook_endpoint.

Directories

Path Synopsis
Package account provides API functions related to accounts.
Package account provides API functions related to accounts.
Package accountlink provides API functions related to account links.
Package accountlink provides API functions related to account links.
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 file provides the file related APIs
Package file provides the file related APIs
Package filelink provides API functions related to file links.
Package filelink provides API functions related to file links.
Package invoice provides the /invoices APIs
Package invoice provides the /invoices APIs
Package invoiceitem provides the /invoiceitems APIs
Package invoiceitem provides the /invoiceitems APIs
issuing
authorization
Package authorization provides API functions related to issuing authorizations.
Package authorization provides API functions related to issuing authorizations.
card
Package card provides API functions related to issuing cards.
Package card provides API functions related to issuing cards.
cardholder
Package cardholder provides API functions related to issuing cardholders.
Package cardholder provides API functions related to issuing cardholders.
dispute
Package dispute provides API functions related to issuing disputes.
Package dispute provides API functions related to issuing disputes.
transaction
Package transaction provides API functions related to issuing transactions.
Package transaction provides API functions related to issuing transactions.
Package loginlink provides the /login_links APIs
Package loginlink provides the /login_links APIs
Package paymentintent provides API functions related to payment intents.
Package paymentintent provides API functions related to payment intents.
Package paymentmethod provides the /payment_methods APIs
Package paymentmethod provides the /payment_methods 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 person provides the /accounts/persons APIs
Package person provides the /accounts/persons APIs
Package plan provides the /plans APIs
Package plan provides the /plans APIs
radar
valuelist
Package valuelist provides API functions related to value lists.
Package valuelist provides API functions related to value lists.
valuelistitem
Package valuelistitem provides API functions related to value list items.
Package valuelistitem provides API functions related to value list items.
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
reporting
reportrun
Package reportrun provides API functions related to report runs.
Package reportrun provides API functions related to report runs.
reporttype
Package reporttype provides API functions related to report types.
Package reporttype provides API functions related to report types.
Package reversal provides the /transfers/reversals APIs
Package reversal provides the /transfers/reversals APIs
Package review provides the /reviews APIs
Package review provides the /reviews APIs
A script that wraps the run of the project test suite and starts stripe-mock with a custom OpenAPI + fixtures bundle if one was found in the appropriate spot (see `pathSpec` below).
A script that wraps the run of the project test suite and starts stripe-mock with a custom OpenAPI + fixtures bundle if one was found in the appropriate spot (see `pathSpec` below).
sigma
scheduledqueryrun
Package scheduledqueryrun provides API functions related to scheduled query runs.
Package scheduledqueryrun provides API functions related to scheduled query runs.
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 subschedule provides the /subscription_schedules APIs
Package subschedule provides the /subscription_schedules APIs
Package subschedulerevision provides the /subscription_schedules/revisions APIs
Package subschedulerevision provides the /subscription_schedules/revisions APIs
terminal
connectiontoken
Package connectiontoken provides API functions related to terminal connection tokens
Package connectiontoken provides API functions related to terminal connection tokens
location
Package location provides API functions related to terminal locations
Package location provides API functions related to terminal locations
reader
Package reader provides API functions related to terminal readers
Package reader provides API functions related to terminal readers
Package threedsecure provides the /3d_secure APIs This package is deprecated and should not be used anymore.
Package threedsecure provides the /3d_secure APIs This package is deprecated and should not be used anymore.
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 usagerecord provides the /subscription_items/{SUBSCRIPTION_ITEM_ID}/usage_records APIs
Package usagerecord provides the /subscription_items/{SUBSCRIPTION_ITEM_ID}/usage_records APIs
Package usagerecordsummary provides the /subscription_items/{SUBSCRIPTION_ITEM_ID}/usage_record_summaries APIs
Package usagerecordsummary provides the /subscription_items/{SUBSCRIPTION_ITEM_ID}/usage_record_summaries APIs
Package webhookendpoint provides the /webhook_endpoints APIs
Package webhookendpoint provides the /webhook_endpoints APIs

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL