vhad/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/gosticks/DefinitelyTyped.git synced 2026-10-04 06:47:03 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #28599 from keylockerbv/master

Browse Source 
StripeJS V3.0 Typings for Stripe.js API
This commit is contained in:
Mine Starks
2018-09-07 15:28:29 -07:00
committed by GitHub
parent be6085e575 51e6ce8edc
commit f01a82e714
10 changed files with 1778 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
types/stripejs/customer.d.ts
Vendored
+299
View File
@@ -0,0 +1,299 @@
export interface Customer {
/**
* The Address of the customer
*/
address: Address;
/**
* The email address of the customer
*/
email: string;
/**
* The full name of the owner
*/
name: string;
/**
* The phone number of the customer
* NOTE: This includes the extension
*/
phone: string;
/**
* Verified customer’s address
*/
readonly verified_address: Address;
/**
* Verified customer’s email address
*/
readonly verified_email: string;
/**
* Verified customer’s full name
*/
readonly verified_name: string;
/**
* Verified customer’s phone number
*/
readonly verified_phone: string;
}
// --- CUSTOMER ADDRESS --- //
export interface Address {
/**
* City/District/Suburb/Town/Village.
*/
city: string;
/**
* Two-letter country code, capitalized
* NOTE: The codes are specified by the ISO3166 alpha-2
*/
country: string;
/**
* Address line 1 (Street address/PO Box/Company name).
*/
line1: string;
/**
* Address line 2 (Apartment/Suite/Unit/Building).
*/
line2: string;
/**
* ZIP or postal code
*/
postal_code: string;
/**
* State/County/Province/Region.
*/
state: string;
}
// --- CARD PAYMENT OPTION --- //
/**
* @see https://stripe.com/docs/api#card_object
*/
export interface Card {
/**
* The unique identifier of the bank account
*/
id: string;
/**
* The account this card belongs to.
* NOTE: This attribute will not be in the card object if the card belongs to a customer or recipient instead.
*/
object: 'card';
account?: string;
/**
* City/District/Suburb/Town/Village
*/
address_city: string;
/**
* The country in which the address is located
*/
address_country: string;
/**
* Address line 1 (Street address/PO Box/Company name)
*/
address_line1: string;
/**
* The results of address_line1 if it was provided
*/
address_line1_check: checkStatus;
/**
* Address line 2 (Apartment/Suite/Unit/Building)
*/
address_line2: string;
/**
* State/County/Province/Region.
*/
address_state: string;
/**
* ZIP or postal code
*/
address_zip: string;
/**
* The results of address_zip if it was provided
*/
address_zip_check: checkStatus;
/**
* A set of available payout methods for this card
* NOTE: Only values from this set should be passed as the method when creating a transfer
*/
available_payout_methods: ['standard'] | ['standard', 'instant'];
/**
* The brand of the card
*/
brand: 'American Express' | 'Diners Club' | 'Discover' | 'JCB' | 'MasterCard' | 'UnionPay' | 'Visa' | 'Unknown';
/**
* Two-letter ISO code representing the country of the card
* You could use this attribute to get a sense of the international breakdown of cards you’ve collected
*/
country: string;
/**
* Three-letter ISO code for currency
* Only applicable on accounts (not customers or recipients).
* The card can be used as a transfer destination for funds in this currency
*/
currency?: string;
/**
* The customer that this card belongs to
* NOTE: This attribute will not be in the card object if the card belongs to an account or recipient instead
*/
customer?: any;
/**
* If a CVC was provided, results of the check
*/
cvc_check: checkStatus;
/**
* Only applicable on accounts (not customers or recipients)
* This indicates whether this card is the default external account for its currency
*/
default_for_currency?: boolean;
/**
* The last four digits of the device account number.
* NOTE: For tokenized numbers only
*/
dynamic_last4: string;
/**
* Two-digit number representing the card’s expiration month
*/
exp_month: number;
/**
* Four-digit number representing the card’s expiration year
*/
exp_year: number;
/**
* Uniquely identifies this particular card number
*/
fingerprint: string;
/**
* Card funding type
*/
funding: 'credit' | 'debit' | 'prepaid' | 'unknown';
/**
* The last four digits of the card
*/
last4: string;
/**
* The name of the cardholder
*/
name: string;
/**
* The recipient that this card belongs to.
* NOTE: This attribute will not be in the card object if the card belongs to a customer or account instead
*/
recipient?: string;
/**
* If the card number is tokenized, this is the method that was used
*/
tokenization_method: 'apple_pay' | 'android_pay';
/**
* Your own saved information with this card
*/
metadata: { [key: string]: string };
}
export type checkStatus = 'pass' | 'fail' | 'unavailable' | 'unchecked';
// --- BANK ACCOUNT PAYMENT OPTION --- //
/**
* @see https://stripe.com/docs/api#customer_bank_account_object
*/
export interface BankAccount {
/**
* The unique identifier of the bank account
*/
id: string;
object: 'bank_account';
/**
* The name of the person or business that owns the bank account.
*/
account_holder_name: string;
/**
* The type of entity that holds the account.
*/
account_holder_type: 'individual' | 'company';
/**
* Name of the bank associated with the routing number
* @example 'STRIPE TEST BANK'
*/
bank_name: string;
/**
* The routing transit number for the bank account
*/
routing_number: string;
/**
* Two-letter ISO code representing the country the bank account is located in
* @example 'US'
*/
country: string;
/**
* Three-letter ISO code for the currency paid out to the bank account
* @example 'usd'
*/
currency: string;
customer: string;
/**
* Uniquely identifies this particular bank account.
* NOTE: You can use this attribute to check whether two bank accounts are the same
*/
fingerprint: string;
/**
* The last 4 digits of the bank number
*/
last4: string;
/**
* Your own saved information with this bank account
*/
metadata: { [key: string]: string };
/**
* The status of the bank account
* @see https://stripe.com/docs/api#customer_bank_account_object-status
*/
status: 'new' | 'validated' | 'verified' | 'verification_failed' | 'errored';
}
types/stripejs/element.d.ts
Vendored
+414
View File
@@ -0,0 +1,414 @@
import { StripeError } from "./index";
export interface ElementFactory {
/**
* Creates a new StripeJS element
* @see https://stripe.com/docs/stripe-js/reference#elements-create
* @param type - The type of element that should be created
* @param options - Any options that should be used to con
*
* @example ```
* const style = {
* base: {
* color: '#303238',
* fontSize: '16px',
* color: "#32325d",
* fontSmoothing: 'antialiased',
* '::placeholder': {
* color: '#ccc',
* },
* },
* invalid: {
* color: '#e5424d',
* ':focus': {
* color: '#303238',
* },
* },
* };
* const cardElement = elementCreator.create('card', {style: style})
* ```
*
* @return The created element
*/
create(
type: ElementType,
options: CardElementOptions | IBANElementOptions | IdealBankOptions | PaymentButtonOptions
): Element;
}
export interface ElementCreatorOptions {
/**
* Fonts that should be used for styling the element
* @see https://stripe.com/docs/stripe-js/reference#stripe-elements
*/
fonts?: FontCSSElement[] | FontConfigElement[];
/**
* The translation that should be used for the element text
* `auto` defaults to the browser language
*
* NOTE: Only use the `string` option in combination with
* @see isLanguageTag
*
* @default 'auto'
*/
locale?: 'auto' | 'da' | 'de' | 'en' | 'es' | 'fi' | 'fr' | 'it' | 'ja' | 'no' | 'nl' | 'sv' | 'zh' | string;
/**
* Whether or not the locale is written in a language code
* This can be used in combination with localization libraries so that language names won't have to be formatted
* @example `en-US`
*
* @since 0.1.0
*/
isIETFLocaleTag?: boolean;
}
export interface FontCSSElement {
/**
* A relative or absolute URL pointing to a CSS file with `@font-face` definitions
* @example 'https://fonts.googleapis.com/css?family=Open+Sans'
*/
cssSrc: string;
}
export interface FontConfigElement {
/**
* The name of the font family
* @example 'Times New Roman'
*/
family?: string;
/**
* A src value pointing to your custom font file.
* @example
* 'url(https://somewebsite.com/path/to/font.woff)'
* 'url(path/to/font.woff)'
*/
src?: string;
/**
* The style of the text
* @default 'normal'
*/
style?: 'normal' | 'italic' | 'oblique';
/**
* A unicode range for the font that should be used
* @see https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/unicode-range
*/
unicodeRange?: string;
/**
* The weight of the font
* NOTE: This cannot be a number!
*/
weight?: 'initial' | 'inherit' | 'bold' | 'bolder' | 'lighter' | 'normal' | 'revert' | 'unset';
}
// --- ELEMENT --- //
export interface Element {
/**
* Mount the element to the DOM
* @see https://stripe.com/docs/stripe-js/reference#element-mount
*
* @param element - A HTML DOM element or a CSS selector
*
* @example ```
* <label for="card-element">Card</label>
* <div id="card-element"></div>
*
* cardElement.mount('#card-element');
* ```
*/
mount(element: HTMLElement | string): void;
/**
* Watch for changes on the element
* @see https://stripe.com/docs/stripe-js/reference#element-on
*
* @param event - What event to listen to
* @param handler - The handler function that is called when the event fires
*/
on(event: 'blur' | 'focus' | 'ready', handler: () => void): void;
on(event: 'click', handler: (event: { preventDefault: () => void }) => void): void;
on(event: 'change', handler: (event: OnChange) => void): void;
/**
* Blur the element
* @see https://stripe.com/docs/stripe-js/reference#other-methods
*/
blur(): void;
/**
* Clear the value of the element
*/
clear(): void;
/**
* Removes the Element from the DOM and destroys it
* NOTE: a destroyed element can not be re-activated or re-mounted to the DOM
*/
destroy(): void;
/**
* Give focus to the element
*/
focus(): void;
/**
* Unmounts the Element from the DOM
* Call `element.mount()` to re-attach it to the DOM
* @see mount
*/
unmount(): void;
/**
* Updates the options the Element was initialized with
* NOTE: Updates are merged into the existing configuration
* @param options - The options that should be used to update the element
*/
update(options: CardElementOptions | IBANElementOptions | IdealBankOptions | PaymentButtonOptions): void;
}
/**
* The type of element that can be created by the ElementCreator
* @see ElementCreator
*/
export type ElementType = 'card' | 'cardNumber' | 'cardExpiry' | 'cardCvc' | 'postalCode';
// --- ELEMENT EVENTS --- //
export interface OnChange {
/**
* true if the value is empty
*/
empty: boolean;
/**
* true if the value is well-formed and potentially complete
*/
complete: boolean;
/**
* The current validation error if any
*/
error: StripeError;
/**
* The value of the element
* @see CardElementOptions.value for more information
* NOTE: This is only filled is the element is of a Card type
*
* -----
*
* The selected bank. Can be one of the banks listed in the
* @see https://stripe.com/docs/sources/ideal#optional-specifying-the-customers-bank
* NOTE: This is also filled when the element is of IdealBank type
*/
value?: any;
/**
* The type of card that was used
* @example 'visa'
* NOTE: This is only available when the element is of Card or Cardnumber type
*/
brand?: string;
/**
* The country code of the entered IBAN
* NOTE: This is only available when the element is of IBAN type
*/
country?: string;
/**
* The financial institution that services the account whose IBAN was entered into the Element.
* NOTE: This is only available when the element is of IBAN type
*/
bankName: string;
}
// --- CARD ELEMENT --- //
export interface CardElementOptions extends BaseOptions {
/**
* A pre-filled value
* NOTE: Sensitive card information (card number, CVC, and expiration date) cannot be pre-filled
* @see placeholder
*
* @example {postalCode: '94110'}
*/
value?: any;
/**
* Whether or not to hide the postal code
* NOTE: If you are already collecting a full billing address or postal code elsewhere, set this to `true`
* @default false
*/
hidePostalCode?: boolean;
/**
* Appearance of the icon in the Element
*/
iconStyle?: 'solid' | 'default';
/**
* A placeholder text
* NOTE: This is only available for `cardNumber`, `cardExpiry` & `cardCvc` elements
*/
placeholder?: string;
}
// --- IBAN ELEMENT --- //
export interface IBANElementOptions extends BaseOptions {
/**
* Specify the list of countries or country-groups whose IBANs you want to allow
*/
supportedCountries?: string[];
/**
* Customize the country and format of the placeholder IBAN
* @default 'DE"
*/
placeholderCountry?: string;
/**
* Appearance of the icon in the Element
*/
iconStyle?: 'solid' | 'default';
}
// --- IDEAL ELEMENT --- //
export interface IdealBankOptions extends BaseOptions {
/**
* A pre-filled value for the Element. Can be one of the banks listed in the
* @see https://stripe.com/docs/sources/ideal#optional-specifying-the-customers-bank
*
* @example 'abn_amro'
*/
value?: string;
}
// --- PAYMENT BUTTON ELEMENT --- //
export interface PaymentButtonOptions {
paymentRequest: any;
/**
* Set custom class names on the container DOM element when the Stripe Element is in a
* particular state.
*/
classes?: {
base?: string; /** @default StripeElement */
complete?: string; /** @default StripeElement--complete */
focus: string; /** @default StripeElement--focus */
invalid: string; /** @default StripeElement--invalid */
};
style?: {
base?: PaymentRequestButtonStyle;
complete?: PaymentRequestButtonStyle;
empty?: PaymentRequestButtonStyle;
invalid?: PaymentRequestButtonStyle;
};
}
export interface PaymentRequestButtonStyle {
/**
* The type of button that should be shown
* @default 'default'
*/
type?: 'default' | 'donate' | 'buy';
/**
* The theme of the button that should be used
* @default 'dark'
*/
theme?: 'dark' | 'light' | 'light-outline';
/**
* The height of the button
* @example '25px'
*/
height?: string;
}
// --- BASE OPTIONS FOR ELEMENTS --- //
/**
* @deprecated Do not use this interface. This is only here to minimize code duplication
*/
export interface BaseOptions {
/**
* Set custom class names on the container DOM element when the Stripe Element is in a
* particular state.
*/
classes?: {
base?: string; /** @default StripeElement */
complete?: string; /** @default StripeElement--complete */
empty?: string; /** @default StripeElement--empty */
focus?: string; /** @default StripeElement--focus */
invalid?: string; /** @default StripeElement--invalid */
webkitAutofill?: string; /** @default StripeElement--webkit-autofill */
};
/**
* Customize appearance using CSS properties
*/
style?: {
base?: StyleAttributes;
complete?: StyleAttributes;
empty?: StyleAttributes;
invalid?: StyleAttributes;
};
/**
* Whether or not the icon should be hidden
* @default false
*/
hideIcon?: boolean;
/**
* Whether or not the input is disabled
* @default false
*/
disabled?: boolean;
}
/**
* Styling settings for a Stripe Element
*/
export interface StyleAttributes {
color?: string;
fontFamily?: string;
fontSize?: string;
fontSmoothing?: string;
fontStyle?: string;
fontVariant?: any;
iconColor?: string;
lineHeight?: string;
letterSpacing?: string;
/**
* Align text inside the element
* NOTE: Only available for the `cardNumber`, `cardExpiry`, and `cardCvc` Elements
*/
textAlign?: string;
'::-ms-clear'?: MSClearAttributes;
/**
* Add padding to the element
* NOTE: Only available for the `idealBank` Element
*/
padding?: string;
textDecoration?: string;
textShadow?: string;
textTransform?: string;
':hover'?: StyleAttributes;
':focus'?: StyleAttributes;
'::placeholder'?: StyleAttributes;
'::selection'?: StyleAttributes;
':-webkit-autofill'?: StyleAttributes;
':disabled'?: StyleAttributes;
}
export interface MSClearAttributes extends StyleAttributes {
display?: string;
}
types/stripejs/index.d.ts
Vendored
+147
View File
@@ -0,0 +1,147 @@
// Type definitions for stripe.js 3.0
// Project: https://stripe.com/
// Definitions by: Robin van Tienhoven <https://github.com/RobinvanTienhoven>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1
import { ElementCreatorOptions, ElementFactory } from './element';
import { StripePaymentOptions, StripePaymentRequest } from './payment';
import { BankTokenData, PiiTokenData, TokenData, IBANTokenData, TokenResult } from './token';
import { SourceData, SourceResult } from './source';
export interface StripeJS {
/**
* The currently used key
*/
_apiKey: string;
/**
* The mode in which the requests are currently done
* @example 'test'
*/
_keyMode: string;
/**
* Initialization function for StripeJS
* @see https://stripe.com/docs/stripe-js/reference#including-stripejs
*
* @param key - The public key of the user
* @param [options] - Any options to configure StripeJS
*
* @return StripeJS instance
*/
(key: string, options?: StripeConfigOptions): StripeJS;
/**
* Create an instance of elements which can be used to manage a group of StripeJS elements
* @see https://stripe.com/docs/stripe-js/reference#stripe-elements
*
* @param [options] - Configuration options for the elements object
*
* @return an instance of `Elements` to manage a group of elements
*/
elements(options?: ElementCreatorOptions): ElementFactory;
/**
* Creates a new payment request based on the given options
* @see https://stripe.com/docs/stripe-js/reference#stripe-payment-request
*
* @param options - Options that should be used to configure the payment request
*/
paymentRequest(options: StripePaymentOptions): StripePaymentRequest;
/**
* to convert information collected by Elements into a single-use token that you safely pass to your server
* to use in an API call
* @see https://stripe.com/docs/stripe-js/reference#stripe-create-token
*
* @param element - The element from which the data should be extracted
* @param [data] - an object containing additional payment information you might have collected
*
* @return an object containing the generated token or an error
*/
createToken(element: Element, data?: TokenData | IBANTokenData): Promise<TokenResult>;
createToken(type: 'bank_account', data: BankTokenData): Promise<TokenResult>;
createToken(type: 'pii', data: PiiTokenData): Promise<TokenResult>;
/**
* convert payment information collected by Elements into a Source object that you safely pass
* to your server to use in an API call
* @see https://stripe.com/docs/stripe-js/reference#stripe-create-source
*
* @param element - The element from which information should be extracted
* @param data - An object containing the type of Source you want to create and any additional payment source information
* NOTE: You cannot pass raw card information without an `Element`!
*
* @return an object containing the generated Source or an error
*/
createSource(element: Element, data: SourceData): Promise<SourceResult>;
createSource(data: SourceData): Promise<SourceResult>;
/**
* Retrieve a Source using its unique ID and client secret
* NOTE: The parameters are always available in any source object fetched with StripeJS
*
* @param id - Unique identifier of the source
* @param client_secret - A secret available to the web client that created the Source
*
* @return an object containing the generated Source or an error
*/
retrieveSource({id, client_secret}: { id: string, client_secret: string }): Promise<SourceResult>;
}
export interface StripeConfigOptions {
stripeAccount: string;
}
/**
* @see https://stripe.com/docs/api#errors
*/
export interface StripeError {
/**
* The type of error that has occurred
*/
type: errorType;
/**
* For card errors, the ID of the failed charge
*/
charge?: string;
/**
* For some errors that could be handled programmatically,
* a short string indicating the error code reported
*/
code?: string;
/**
* For card errors resulting from a card issuer decline,
* a short string indicating the card issuer’s reason for the decline if they provide one
*/
decline_code?: string;
/**
* A URL to more information about the error code reported
*/
doc_url?: string;
/**
* A human-readable message providing more details about the error.
* NOTE: For card errors, these messages can be shown to your users
*/
message?: string;
/**
* If the error is parameter-specific, the parameter related to the error
*/
param?: string;
}
export type errorType =
'api_connection_error' |
'api_error' |
'authentication_error' |
'card_error' |
'idempotency_error' |
'invalid_request_error' |
'rate_limit_error';
types/stripejs/payment.d.ts
Vendored
+235
View File
@@ -0,0 +1,235 @@
import { ShippingAddress, ShippingOption } from "./shipping";
/**
* The Payment request object that can be used to make payments
* @see https://stripe.com/docs/stripe-js/reference#the-payment-request-object
*/
export interface StripePaymentRequest {
/**
* Whether or not a payment can be made
* NOTE: When no API is available it resolves with `null`
*
* @see https://stripe.com/docs/stripe-js/reference#payment-request-can-make-payment
*/
canMakePayment(): Promise<CanMakePaymentResult | null>;
/**
* Shows the browser’s payment UI
* NOTE: When using the paymentRequestButton Element, this is called for you under the hood
* NOTE: This method must be called as the result of a user interaction (for example, in a click handler)
*
* @see https://stripe.com/docs/stripe-js/reference#payment-request-show
*/
show(): void;
/**
* Updates the payment information
* NOTE: can only be called when the browser payment UI is not showing
*
* @param options - Payment information that should be used by Stripe
*
* @see https://stripe.com/docs/stripe-js/reference#payment-request-update
*/
update(options: UpdateOptions): void;
/**
* Register your event listener
* @see https://stripe.com/docs/stripe-js/reference#payment-request-on
*/
on(event: 'cancel', handler: () => void): void;
on(event: 'token' | 'source', handler: (event: StripePaymentResponse) => void): void;
on(event: 'shippingaddresschange', handler: (event: NewShippingAddress) => void): void;
on(event: 'shippingoptionchange', handler: (event: NewShippingOptions) => void): void;
}
export interface CanMakePaymentResult {
/**
* true if the browser payment API supports Apple Pay.
* NOTE: using the paymentRequestButton Element is automatically cross-browser.
* If you use this PaymentRequest object to create a paymentRequestButton Element, you don‘t need to check applePay yourself
*/
readonly applePay: boolean;
}
/**
* @see https://stripe.com/docs/stripe-js/reference#payment-request-on
*/
export interface NewShippingAddress {
/**
* Calling this function with an UpdateDetails object merges your updates into the
* current PaymentRequest object.
*/
updateWith: (dataToUpdate: UpdateOptions) => void;
/**
* The customer's selected ShippingAddress.
*/
shippingAddress: ShippingAddress;
}
export interface NewShippingOptions {
/**
* Calling this function with an UpdateDetails object merges your updates into the
* current PaymentRequest object.
*/
updateWith: (dataToUpdate: UpdateOptions) => void;
/**
* The selected shipping option
*/
shippingOption: ShippingOption;
}
/**
* Payment options that can be set when updating the payment request
* @see https://stripe.com/docs/stripe-js/reference#payment-request-update
*/
export interface UpdateOptions {
/**
* The currency in which the customer should be charged
* @example 'usd'
*/
currency: string;
/**
* The total amount the customer has to pay
* NOTE: This object is shown to the customer in the browser‘s payment UI
*/
total: PaymentItem;
/**
* An array of payment item objects
* NOTE: The sum of the line item amounts does not need to add up to the total amount above
* @see total
*
* @default []
*/
displayItems?: PaymentItem[];
/**
* An array of possible shipping options
* NOTE: This first one in the array will be listed as the default option
*
* @default []
*/
shippingOptions?: ShippingOption[];
}
/**
* Configuration options for creating a payment request
* @see https://stripe.com/docs/stripe-js/reference#stripe-payment-request
*/
export interface StripePaymentOptions extends UpdateOptions {
/**
* The two letter code representing your country
* @example 'US'
*/
country: string;
/**
* Whether or not the form should ask for the payer's name
* @default false
*/
requestPayerName?: boolean;
/**
* Whether or not the form should ask for the payer's email address
* @default false
*/
requestPayerEmail?: boolean;
/**
* Whether or not the form should ask for the payer's phone number
* @default false
*/
requestPayerPhone?: boolean;
/**
* Whether or not a shipping address should be requested
* NOTE: Setting this to true requires `shippingOptions` to be set with at least one option!
* @see shippingOptions
*/
requestShipping?: boolean;
}
export interface PaymentItem {
/**
* The amount the user has to pay in the given currency
* @see StripePaymentOptions.currency
*/
amount: number;
/**
* A text that should be shown to the user
*/
label: string;
/**
* Whether or not the payment should be executed immediately
* If you might change this amount later (for example, after you have calculated shipping costs), set this to `true`
*/
pending?: boolean;
}
// --- PAYMENT RESPONSE FROM STRIPE --- //
/**
* @see https://stripe.com/docs/stripe-js/reference#payment-response-object
*/
export interface StripePaymentResponse {
/**
* NOTE: Only available when the event type 'token' was used
*/
readonly token?: any;
/**
* NOTE: Only available when the event type 'source' was used
*/
readonly source?: any;
/**
* A function to complete the payment and give feedback to the user
* Call this when you have processed the token data provided by the API
*
* @param status - The status that should be shown to the user
*/
complete: (status: completeStatus) => void;
/**
* Information about the payer
* NOTE: This is only set if the corresponding field was set to `true` in the `PaymentOptions`
*
* @see PaymentOptions.requestPayerName
* @see PaymentOptions.requestPayerEmail
* @see PaymentOptions.requestPayerPhone
*/
readonly payerName?: string;
readonly payerEmail?: string;
readonly payerPhone?: string;
/**
* The shipping address the payer selected
*/
readonly shippingAddress: ShippingAddress;
/**
* The shipping option the payer selected
*/
readonly shippingOption: ShippingOption;
/**
* The unique name of the payment handler the customer chose to authorize payment
* @example 'basic-card'
*/
readonly methodName: string;
}
export type completeStatus =
'success' |
'fail' |
'invalid_payer_name' |
'invalid_payer_phone' |
'invalid_payer_email' |
'invalid_shipping_address';
types/stripejs/shipping.d.ts
Vendored
+90
View File
@@ -0,0 +1,90 @@
/**
* @see https://stripe.com/docs/stripe-js/reference#shipping-address-object
*/
export interface ShippingAddress {
/**
* Two-letter country code, capitalized
* NOTE: The codes are specified by the ISO3166 alpha-2
*/
country: string;
/**
* An array of address line items
* @example ['185 Berry St.', 'Suite 500', 'P.O. Box 12345']
*/
addressLine: string[];
/**
* The most coarse subdivision of a country
* NOTE: Depending on the country, this might correspond to a state, a province, an oblast, a prefecture,
* or something else along these lines.
*/
region: string;
/**
* The name of a city, town, village, etc
*/
city: string;
/**
* The postal code or ZIP code
* NOTE: This is known as the PIN code in India
*/
postalCode: string;
/**
* The name of the recipient.
* NOTE: This might be a person, a business name, or contain “care of” (c/o) instructions
*/
recipient: string;
/**
* The phone number of the recipient
* NOTE: This is only filled if `requestPayerPhone` was set to `true`
*
* @see PaymentOptions.requestPayerPhone
*/
phone: string;
/**
* The sorting code as used in, for example, France
* NOTE: Not present on Apple platforms
*/
sortingCode: string;
/**
* A logical subdivision of a city
* NOTE: Not present on Apple platforms
*/
dependentLocality: string;
}
// --- SHIPPING OPTION --- //
/**
* Settings for a shipping location
* @see https://stripe.com/docs/stripe-js/reference#shipping-option-object
*/
export interface ShippingOption {
/**
* A unique ID you create to keep track of this shipping option.
* NOTE: You‘ll be told the ID of the selected option on changes and on completion.
*/
id: string;
/**
* A short “title” for this shipping option.
*/
label: string;
/**
* A longer description of this shipping option.
*/
detail: string;
/**
* The shipping costs for this option
* NOTE: If the cost of this shipping option depends on the shipping address the customer enters,
* listen for the `shippingaddresschange` event.
*/
amount: number;
}
types/stripejs/source.d.ts
Vendored
+316
View File
@@ -0,0 +1,316 @@
import { StripeError } from "./index";
import { Customer } from "./customer";
import { Token } from "./token";
/**
* @see https://stripe.com/docs/api#sources
*/
export interface Source {
/**
* Unique identifier for the object
*/
id: string;
object: 'source';
/**
* A positive integer in the smallest currency unit (that is, 100 cents for $1.00,
* or 1 for ¥1, Japanese Yen being a zero-decimal currency) representing the total
* amount associated with the source
*/
amount: number;
/**
* The client secret of the source.
* Used for client-side retrieval using a publishable key.
*/
client_secret: string;
/**
* Information related to the code verification flow
* Present if the source is authenticated by a verification code
*/
code_verification?: CodeVerification;
/**
* Time at which the object was created.
* Measured in seconds since the Unix epoch.
* (Timestamp)
*/
created: number;
/**
* Three-letter ISO code for the currency associated with the source
*/
currency: string;
/**
* The authentication flow of the source
*/
flow: 'redirect' | 'receiver' | 'code_verification' | 'none';
/**
* LIVE MODE = true
* TEST MODE = false
*/
livemode: boolean;
/**
* Your own saved information with this bank account
*/
metadata: { [key: string]: string };
/**
* Information about the owner of the payment instrument that may be used or
* required by particular source types.
*/
owner: Customer;
/**
* Information related to the receiver flow.
* Present if the source is a receiver
*/
receiver?: Receiver;
/**
* Information related to the redirect flow.
* Present if the source is authenticated by a redirect
*/
redirect?: Redirect;
/**
* Extra information about a source
* NOTE: This will appear on your customer’s statement every time you charge the source
*/
statement_descriptor: string;
/**
* The status of the source
* NOTE: Only `chargeable` sources can be used to create a charge
*/
status: 'pending' | 'canceled' | 'failed' | 'consumed' | 'chargeable';
/**
* The type of the source.
* NOTE: The type is a payment method
*/
type: paymentOptions;
/**
* A matching name to the type with extra information about the payment method
* @see type
*/
[key: string]: any;
/**
* Whether this source should be reusable or not
*/
usage: 'reusable' | 'reusable';
}
export type paymentOptions =
'ach_credit_transfer' |
'ach_debit' |
'alipay' |
'bancontact' |
'card' |
'card_present' |
'eps' |
'giropay' |
'ideal' |
'multibanco' |
'p24' |
'paper_check' |
'sepa_credit_transfer' |
'sepa_debit' |
'sofort' |
'three_d_secure';
// --- CODE VERIFICATION --- //
export interface CodeVerification {
/**
* The number of attempts remaining to authenticate the
* source object with a verification code
*/
attempts_remaining: number;
/**
* The status of the code verification
*/
status: 'pending' | 'attempts_remaining' | 'succeeded' | 'failed' | 'attempts_remaining';
}
// --- REDIRECT INFORMATION --- //
export interface Redirect {
/**
* The failure reason for the redirect
* Present only if the redirect status is `'failed'`
*/
failure_reason?: 'user_abort' | 'declined' | 'processing_error';
/**
* The URL you provide to redirect the customer to after they authenticated their payment
*/
return_url: string;
/**
* The status of the redirect
* - Pending: ready to be used by your customer to authenticate the transaction
* - succeeded: succesful authentication, cannot be reused
* - not_required: redirect should not be used
* - failed: failed authentication, cannot be reused
*/
status: 'pending' | 'succeeded' | 'not_required' | 'failed';
/**
* The URL provided to you to redirect a customer to as part of a redirect
* authentication flow
*/
url: string;
}
// --- RECEIVER INFORMATION --- //
export interface Receiver {
/**
* The address of the receiver source
* NOTE: This is the value that should be communicated to the customer to send their funds to
*/
address: string;
/**
* The total amount that was charged by you
* NOTE: The amount charged is expressed in the source’s currency
*/
amount_charged: number;
/**
* The total amount received by the receiver source
*/
amount_received: number;
/**
* The total amount that was returned to the customer
* NOTE: The amount charged is expressed in the source’s currency
*/
amount_returned: number;
}
// --- DATA TO CREATE A SOURCE --- //
/**
* @see https://stripe.com/docs/api#create_source
*/
export interface SourceData {
/**
* The type of the source to create
*/
type: paymentOptions;
/**
* This is the amount for which the source will be chargeable once ready
*/
amount: number;
/**
* Three-letter ISO code for the currency associated with the source
*/
currency: string;
/**
* The authentication flow of the source
*/
flow: 'redirect' | 'receiver' | 'code_verification' | 'none';
/**
* Whether this source should be reusable or not
*/
usage: 'reusable' | 'single_use';
/**
* Information about a mandate possiblity attached to a source object
* (generally for bank debits) as well as its acceptance status
*/
mandate?: Mandate;
/**
* Extra data you want to add to the source object
*/
metadata?: { [key: string]: string };
/**
* Information about the owner of the payment instrument that may be used or
* required by particular source types.
*/
owner?: Customer;
/**
* Can be set only if the source is a receiver
*/
receiver?: Receiver;
/**
* Required if the source is authenticated by a redirect
*/
redirect?: Redirect;
/**
* An arbitrary string to be displayed on your customer’s statement
* @example if your website is RunClub and the item you’re charging for is a race ticket,
* you may want to specify a statement_descriptor of RunClub 5K race ticket.
*/
statement_descriptor?: string;
three_d_secure_2_eap?: any;
/**
* When passed, token properties will override source parameters
*/
token?: Token;
}
export interface Mandate {
acceptance?: Acceptance;
/**
* The method Stripe should use to notify the customer
* - email: an email is sent directly to the customer
* - manual: a source.mandate_notification event is sent to your webhooks endpoint and you should handle the notification
* - none: the underlying debit network does not require any notification
*/
notification_method?: 'email' | 'manual' | 'none';
}
export interface Acceptance {
/**
* The unix timestamp the mandate was accepted or refused at by the customer.
*/
date: number;
/**
* The unix timestamp the mandate was accepted or refused at by the customer.
*/
ip: string;
/**
* The status of the mandate acceptance
*/
status: 'accepted' | 'refused';
/**
* The user agent of the browser from which the mandate was accepted or refused by the customer
* NOTE: This can be unset by updating the value to `null` and then saving
*/
user_agent: string;
}
// --- RESPONSE FROM STRIPE WHEN CREATING OR FETCHING A SOURCE --- //
export interface SourceResult {
/**
* The identifier of the source to be retrieved
*/
source: Source;
/**
* There was an error. This includes client-side validation errors.
*/
error?: StripeError;
}
types/stripejs/stripejs-tests.ts
+101
View File
@@ -0,0 +1,101 @@
import { StripeJS } from "stripejs";
import { CanMakePaymentResult, StripePaymentResponse } from "stripejs/payment";
import { BankTokenData, IBANTokenData, TokenData, TokenResult } from "stripejs/token";
import { SourceData, SourceResult } from "stripejs/source";
declare function describe(desc: string, fn: () => void): void;
declare function it(desc: string, fn: () => void): void;
describe('StripeJS', () => {
const stripe: StripeJS = {} as any;
it('Should be able to initialize', () => {
stripe('test');
stripe('test', {stripeAccount: 'test123'});
});
it('Should be possible to get information from stripe', () => {
stripe._apiKey;
stripe._keyMode;
});
it('Should be possible to create and modify elements', () => {
const creator = stripe.elements();
stripe.elements({fonts: [], locale: 'nl'});
stripe.elements({fonts: [], locale: 'nl', isIETFLocaleTag: true});
const element = creator.create("cardCvc", {value: {postalCode: '94110'}});
element.blur();
element.focus();
element.clear();
element.on('focus', () => null);
element.on('click', (event: { preventDefault: () => void }) => event.preventDefault());
element.mount('#card-element');
element.mount(new HTMLElement());
element.unmount();
element.update({value: {postalCode: '123'}});
element.destroy();
});
it('Should be possible to create a payment request', () => {
const data = {country: 'NL', currency: 'eur', total: {amount: 100, label: 'hello world'}};
const request = stripe.paymentRequest(data);
request.canMakePayment().then((result: CanMakePaymentResult | null) => null);
request.on('token', ((event: StripePaymentResponse) => {
const token: any = event.token ? event.token : null;
event.complete("fail");
const name: string = event.payerName ? event.payerName : '';
}));
request.show();
request.update(data);
});
it('Should be possible to create a token', () => {
const element: Element = {} as any;
const data: TokenData = {
name: '',
currency: 'eur',
address_city: '',
address_country: 'NL',
address_line1: '',
address_line2: '',
address_state: '',
address_zip: '',
};
stripe.createToken(element, data).then((result: TokenResult) => result.token);
const iban: IBANTokenData = {
currency: 'eur',
account_holder_name: '',
account_holder_type: 'company',
};
stripe.createToken(element, iban).then((result: TokenResult) => result.token);
const bankData = {
country: 'NL',
account_number: '12345'
};
const bank: BankTokenData = {...iban, ...bankData};
stripe.createToken('bank_account', bank).then((result: TokenResult) => result.token);
stripe.createToken('pii', {personal_id_number: ''}).then((result: TokenResult) => result.error);
});
it('Should be possible to create a source object', () => {
const element: Element = {} as any;
const data: SourceData = {
type: 'alipay',
flow: 'none',
amount: 1000,
currency: 'eur',
usage: 'single_use'
};
stripe.createSource(element, data).then((result: SourceResult) => result.source);
stripe.createSource(data).then((result: SourceResult) => result.error);
});
it('Should be possible to fetch a source object', () => {
stripe.retrieveSource({id: '', client_secret: ''}).then((result: SourceResult) => result.source);
});
});
types/stripejs/token.d.ts
Vendored
+138
View File
@@ -0,0 +1,138 @@
import { StripeError } from "./index";
import { BankAccount, Card } from "./customer";
/**
* @see https://stripe.com/docs/api#token_object
*/
export interface Token {
/**
* The unique identifier for the token
*/
id: string;
object: 'token';
/**
* Hash describing the bank account
*/
bank_account?: BankAccount;
/**
* Hash describing the card used to make the charge
*/
card?: Card;
/**
* IP address of the client that generated the token
*/
client_ip: string;
/**
* Time at which the object was created. Measured in seconds since the Unix epoch
*/
created: string;
/**
* LIVE MODE = `true`
* TEST MODE = `false`
*/
livemode: boolean;
/**
* Type of the token
*/
type: 'account' | 'bank_account' | 'card' | 'pii';
/**
* Whether this token has already been used (tokens can be used only once)
*/
used: boolean;
}
// --- DATA TO CREATE A TOKEN --- //
export interface TokenData {
/**
* The Cardholder name
*/
name: string;
/**
* Fields for billing address information.
*/
address_line1: string;
address_line2: string;
address_city: string;
address_state: string;
address_zip: string;
/**
* A two character country code identifying the country
* @example 'US'
*/
address_country: string;
/**
* Used to add a card to an account
* NOTE: Currently, the only supported currency for debit card payouts is 'usd'
*/
currency?: string;
}
// --- RESPONSE FROM STRIPE WHEN CREATING OR FETCHING A TOKEN --- //
export interface TokenResult {
/**
* The generated string that can be used for communication with the backend
*/
token?: Token;
/**
* There was an error. This includes client-side validation errors.
*/
error?: StripeError;
}
// --- DATA TO CREATE A PERSONAL TOKEN --- //
export interface PiiTokenData {
/**
* The personal ID number
*/
personal_id_number: string;
}
// --- DATA TO CREATE A TOKEN BASED ON BANK INFORMATION --- //
export interface IBANTokenData {
/**
* Three-letter ISO code for the currency paid out to the bank account
* @example 'usd'
*/
currency: string;
/**
* The name of the person or business that owns the bank account.
*/
account_holder_name: string;
/**
* The type of entity that holds the account.
*/
account_holder_type: 'individual' | 'company';
}
export interface BankTokenData extends IBANTokenData {
/**
* The 2-digit country ISO code
* @example 'US'
*/
country: string;
/**
* The bank account number
*/
account_number: string;
/**
* The routing transit number for the bank account
* NOTE: This is optional if the {@link BankTokenData.currency} is 'eur'
*/
routing_number?: string;
}
types/stripejs/tsconfig.json
+31
View File
@@ -0,0 +1,31 @@
{
"compilerOptions": {
"module": "commonjs",
"lib": [
"es6",
"dom"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": true,
"strictFunctionTypes": true,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"customer.d.ts",
"element.d.ts",
"payment.d.ts",
"shipping.d.ts",
"source.d.ts",
"token.d.ts",
"stripejs-tests.ts"
]
}
types/stripejs/tslint.json
+7
View File
@@ -0,0 +1,7 @@
{
"extends": "dtslint/dt.json",
"rules": {
// IBAN is written with an 'I' for example
"interface-name": false
}
}