• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

stripe / stripe-java / #16517

08 Oct 2024 06:27PM UTC coverage: 12.74% (-0.2%) from 12.899%
#16517

push

github

web-flow
Merge pull request #1872 from stripe/latest-codegen-beta

Update generated code for beta

53 of 2404 new or added lines in 50 files covered. (2.2%)

91 existing lines in 27 files now uncovered.

18753 of 147196 relevant lines covered (12.74%)

0.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

41.41
/src/main/java/com/stripe/model/PaymentIntent.java
1
// File generated from our OpenAPI spec
2
package com.stripe.model;
3

4
import com.google.gson.annotations.SerializedName;
5
import com.stripe.exception.StripeException;
6
import com.stripe.net.ApiRequest;
7
import com.stripe.net.ApiRequestParams;
8
import com.stripe.net.ApiResource;
9
import com.stripe.net.BaseAddress;
10
import com.stripe.net.RequestOptions;
11
import com.stripe.net.StripeResponseGetter;
12
import com.stripe.param.PaymentIntentApplyCustomerBalanceParams;
13
import com.stripe.param.PaymentIntentCancelParams;
14
import com.stripe.param.PaymentIntentCaptureParams;
15
import com.stripe.param.PaymentIntentConfirmParams;
16
import com.stripe.param.PaymentIntentCreateParams;
17
import com.stripe.param.PaymentIntentDecrementAuthorizationParams;
18
import com.stripe.param.PaymentIntentIncrementAuthorizationParams;
19
import com.stripe.param.PaymentIntentListParams;
20
import com.stripe.param.PaymentIntentRetrieveParams;
21
import com.stripe.param.PaymentIntentSearchParams;
22
import com.stripe.param.PaymentIntentUpdateParams;
23
import com.stripe.param.PaymentIntentVerifyMicrodepositsParams;
24
import java.util.List;
25
import java.util.Map;
26
import lombok.EqualsAndHashCode;
27
import lombok.Getter;
28
import lombok.Setter;
29

30
/**
31
 * A PaymentIntent guides you through the process of collecting a payment from your customer. We
32
 * recommend that you create exactly one PaymentIntent for each order or customer session in your
33
 * system. You can reference the PaymentIntent later to see the history of payment attempts for a
34
 * particular session.
35
 *
36
 * <p>A PaymentIntent transitions through <a
37
 * href="https://stripe.com/docs/payments/intents#intent-statuses">multiple statuses</a> throughout
38
 * its lifetime as it interfaces with Stripe.js to perform authentication flows and ultimately
39
 * creates at most one successful charge.
40
 *
41
 * <p>Related guide: <a href="https://stripe.com/docs/payments/payment-intents">Payment Intents
42
 * API</a>
43
 */
44
@Getter
45
@Setter
46
@EqualsAndHashCode(callSuper = false)
47
public class PaymentIntent extends ApiResource implements HasId, MetadataStore<PaymentIntent> {
1✔
48
  /**
49
   * Amount intended to be collected by this PaymentIntent. A positive integer representing how much
50
   * to charge in the <a href="https://stripe.com/docs/currencies#zero-decimal">smallest currency
51
   * unit</a> (e.g., 100 cents to charge $1.00 or 100 to charge ¥100, a zero-decimal currency). The
52
   * minimum amount is $0.50 US or <a
53
   * href="https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts">equivalent in
54
   * charge currency</a>. The amount value supports up to eight digits (e.g., a value of 99999999
55
   * for a USD charge of $999,999.99).
56
   */
57
  @SerializedName("amount")
58
  Long amount;
59

60
  /** Amount that can be captured from this PaymentIntent. */
61
  @SerializedName("amount_capturable")
62
  Long amountCapturable;
63

64
  @SerializedName("amount_details")
65
  AmountDetails amountDetails;
66

67
  /** Amount that this PaymentIntent collects. */
68
  @SerializedName("amount_received")
69
  Long amountReceived;
70

71
  /** ID of the Connect application that created the PaymentIntent. */
72
  @SerializedName("application")
73
  @Getter(lombok.AccessLevel.NONE)
74
  @Setter(lombok.AccessLevel.NONE)
75
  ExpandableField<Application> application;
76

77
  /**
78
   * The amount of the application fee (if any) that will be requested to be applied to the payment
79
   * and transferred to the application owner's Stripe account. The amount of the application fee
80
   * collected will be capped at the total payment amount. For more information, see the
81
   * PaymentIntents <a href="https://stripe.com/docs/payments/connected-accounts">use case for
82
   * connected accounts</a>.
83
   */
84
  @SerializedName("application_fee_amount")
85
  Long applicationFeeAmount;
86

87
  @SerializedName("async_workflows")
88
  AsyncWorkflows asyncWorkflows;
89

90
  /**
91
   * Settings to configure compatible payment methods from the <a
92
   * href="https://dashboard.stripe.com/settings/payment_methods">Stripe Dashboard.</a>
93
   */
94
  @SerializedName("automatic_payment_methods")
95
  AutomaticPaymentMethods automaticPaymentMethods;
96

97
  /**
98
   * Populated when {@code status} is {@code canceled}, this is the time at which the PaymentIntent
99
   * was canceled. Measured in seconds since the Unix epoch.
100
   */
101
  @SerializedName("canceled_at")
102
  Long canceledAt;
103

104
  /**
105
   * Reason for cancellation of this PaymentIntent, either user-provided ({@code duplicate}, {@code
106
   * fraudulent}, {@code requested_by_customer}, or {@code abandoned}) or generated by Stripe
107
   * internally ({@code failed_invoice}, {@code void_invoice}, or {@code automatic}).
108
   *
109
   * <p>One of {@code abandoned}, {@code automatic}, {@code duplicate}, {@code failed_invoice},
110
   * {@code fraudulent}, {@code requested_by_customer}, or {@code void_invoice}.
111
   */
112
  @SerializedName("cancellation_reason")
113
  String cancellationReason;
114

115
  /**
116
   * Controls when the funds will be captured from the customer's account.
117
   *
118
   * <p>One of {@code automatic}, {@code automatic_async}, or {@code manual}.
119
   */
120
  @SerializedName("capture_method")
121
  String captureMethod;
122

123
  /**
124
   * The client secret of this PaymentIntent. Used for client-side retrieval using a publishable
125
   * key.
126
   *
127
   * <p>The client secret can be used to complete a payment from your frontend. It should not be
128
   * stored, logged, or exposed to anyone other than the customer. Make sure that you have TLS
129
   * enabled on any page that includes the client secret.
130
   *
131
   * <p>Refer to our docs to <a
132
   * href="https://stripe.com/docs/payments/accept-a-payment?ui=elements">accept a payment</a> and
133
   * learn about how {@code client_secret} should be handled.
134
   */
135
  @SerializedName("client_secret")
136
  String clientSecret;
137

138
  /**
139
   * Describes whether we can confirm this PaymentIntent automatically, or if it requires customer
140
   * action to confirm the payment.
141
   *
142
   * <p>One of {@code automatic}, or {@code manual}.
143
   */
144
  @SerializedName("confirmation_method")
145
  String confirmationMethod;
146

147
  /** Time at which the object was created. Measured in seconds since the Unix epoch. */
148
  @SerializedName("created")
149
  Long created;
150

151
  /**
152
   * Three-letter <a href="https://www.iso.org/iso-4217-currency-codes.html">ISO currency code</a>,
153
   * in lowercase. Must be a <a href="https://stripe.com/docs/currencies">supported currency</a>.
154
   */
155
  @SerializedName("currency")
156
  String currency;
157

158
  /**
159
   * ID of the Customer this PaymentIntent belongs to, if one exists.
160
   *
161
   * <p>Payment methods attached to other Customers cannot be used with this PaymentIntent.
162
   *
163
   * <p>If <a
164
   * href="https://stripe.com/docs/api#payment_intent_object-setup_future_usage">setup_future_usage</a>
165
   * is set and this PaymentIntent's payment method is not {@code card_present}, then the payment
166
   * method attaches to the Customer after the PaymentIntent has been confirmed and any required
167
   * actions from the user are complete. If the payment method is {@code card_present} and isn't a
168
   * digital wallet, then a <a
169
   * href="https://docs.stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
170
   * payment method representing the card is created and attached to the Customer instead.
171
   */
172
  @SerializedName("customer")
173
  @Getter(lombok.AccessLevel.NONE)
174
  @Setter(lombok.AccessLevel.NONE)
175
  ExpandableField<Customer> customer;
176

177
  /** An arbitrary string attached to the object. Often useful for displaying to users. */
178
  @SerializedName("description")
179
  String description;
180

181
  /** Unique identifier for the object. */
182
  @Getter(onMethod_ = {@Override})
183
  @SerializedName("id")
184
  String id;
185

186
  /** ID of the invoice that created this PaymentIntent, if it exists. */
187
  @SerializedName("invoice")
188
  @Getter(lombok.AccessLevel.NONE)
189
  @Setter(lombok.AccessLevel.NONE)
190
  ExpandableField<Invoice> invoice;
191

192
  /**
193
   * The payment error encountered in the previous PaymentIntent confirmation. It will be cleared if
194
   * the PaymentIntent is later updated for any reason.
195
   */
196
  @SerializedName("last_payment_error")
197
  StripeError lastPaymentError;
198

199
  /**
200
   * ID of the latest <a href="https://stripe.com/docs/api/charges">Charge object</a> created by
201
   * this PaymentIntent. This property is {@code null} until PaymentIntent confirmation is
202
   * attempted.
203
   */
204
  @SerializedName("latest_charge")
205
  @Getter(lombok.AccessLevel.NONE)
206
  @Setter(lombok.AccessLevel.NONE)
207
  ExpandableField<Charge> latestCharge;
208

209
  /**
210
   * Has the value {@code true} if the object exists in live mode or the value {@code false} if the
211
   * object exists in test mode.
212
   */
213
  @SerializedName("livemode")
214
  Boolean livemode;
215

216
  /**
217
   * Set of <a href="https://stripe.com/docs/api/metadata">key-value pairs</a> that you can attach
218
   * to an object. This can be useful for storing additional information about the object in a
219
   * structured format. Learn more about <a
220
   * href="https://stripe.com/docs/payments/payment-intents/creating-payment-intents#storing-information-in-metadata">storing
221
   * information in metadata</a>.
222
   */
223
  @Getter(onMethod_ = {@Override})
224
  @SerializedName("metadata")
225
  Map<String, String> metadata;
226

227
  /**
228
   * If present, this property tells you what actions you need to take in order for your customer to
229
   * fulfill a payment using the provided source.
230
   */
231
  @SerializedName("next_action")
232
  NextAction nextAction;
233

234
  /**
235
   * String representing the object's type. Objects of the same type share the same value.
236
   *
237
   * <p>Equal to {@code payment_intent}.
238
   */
239
  @SerializedName("object")
240
  String object;
241

242
  /**
243
   * The account (if any) for which the funds of the PaymentIntent are intended. See the
244
   * PaymentIntents <a href="https://stripe.com/docs/payments/connected-accounts">use case for
245
   * connected accounts</a> for details.
246
   */
247
  @SerializedName("on_behalf_of")
248
  @Getter(lombok.AccessLevel.NONE)
249
  @Setter(lombok.AccessLevel.NONE)
250
  ExpandableField<Account> onBehalfOf;
251

252
  @SerializedName("payment_details")
253
  PaymentDetails paymentDetails;
254

255
  /** ID of the payment method used in this PaymentIntent. */
256
  @SerializedName("payment_method")
257
  @Getter(lombok.AccessLevel.NONE)
258
  @Setter(lombok.AccessLevel.NONE)
259
  ExpandableField<PaymentMethod> paymentMethod;
260

261
  /** Information about the payment method configuration used for this PaymentIntent. */
262
  @SerializedName("payment_method_configuration_details")
263
  PaymentMethodConfigurationDetails paymentMethodConfigurationDetails;
264

265
  /** Payment-method-specific configuration for this PaymentIntent. */
266
  @SerializedName("payment_method_options")
267
  PaymentMethodOptions paymentMethodOptions;
268

269
  /** The list of payment method types (e.g. card) that this PaymentIntent is allowed to use. */
270
  @SerializedName("payment_method_types")
271
  List<String> paymentMethodTypes;
272

273
  /** If present, this property tells you about the processing state of the payment. */
274
  @SerializedName("processing")
275
  Processing processing;
276

277
  /**
278
   * Email address that the receipt for the resulting payment will be sent to. If {@code
279
   * receipt_email} is specified for a payment in live mode, a receipt will be sent regardless of
280
   * your <a href="https://dashboard.stripe.com/account/emails">email settings</a>.
281
   */
282
  @SerializedName("receipt_email")
283
  String receiptEmail;
284

285
  /** ID of the review associated with this PaymentIntent, if any. */
286
  @SerializedName("review")
287
  @Getter(lombok.AccessLevel.NONE)
288
  @Setter(lombok.AccessLevel.NONE)
289
  ExpandableField<Review> review;
290

291
  /**
292
   * Indicates whether confirmation for this PaymentIntent using a secret key is {@code required} or
293
   * {@code optional}.
294
   *
295
   * <p>One of {@code optional}, or {@code required}.
296
   */
297
  @SerializedName("secret_key_confirmation")
298
  String secretKeyConfirmation;
299

300
  /**
301
   * Indicates that you intend to make future payments with this PaymentIntent's payment method.
302
   *
303
   * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
304
   * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
305
   * Customer after the PaymentIntent is confirmed and the customer completes any required actions.
306
   * If you don't provide a Customer, you can still <a
307
   * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
308
   * Customer after the transaction completes.
309
   *
310
   * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates and
311
   * attaches a <a
312
   * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
313
   * payment method representing the card to the Customer instead.
314
   *
315
   * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
316
   * with regional legislation and network rules, such as <a
317
   * href="https://stripe.com/strong-customer-authentication">SCA</a>.
318
   *
319
   * <p>One of {@code off_session}, or {@code on_session}.
320
   */
321
  @SerializedName("setup_future_usage")
322
  String setupFutureUsage;
323

324
  /** Shipping information for this PaymentIntent. */
325
  @SerializedName("shipping")
326
  ShippingDetails shipping;
327

328
  /**
329
   * This is a legacy field that will be removed in the future. It is the ID of the Source object
330
   * that is associated with this PaymentIntent, if one was supplied.
331
   */
332
  @SerializedName("source")
333
  @Getter(lombok.AccessLevel.NONE)
334
  @Setter(lombok.AccessLevel.NONE)
335
  ExpandableField<PaymentSource> source;
336

337
  /**
338
   * Text that appears on the customer's statement as the statement descriptor for a non-card
339
   * charge. This value overrides the account's default statement descriptor. For information about
340
   * requirements, including the 22-character limit, see <a
341
   * href="https://docs.stripe.com/get-started/account/statement-descriptors">the Statement
342
   * Descriptor docs</a>.
343
   *
344
   * <p>Setting this value for a card charge returns an error. For card charges, set the <a
345
   * href="https://docs.stripe.com/get-started/account/statement-descriptors#dynamic">statement_descriptor_suffix</a>
346
   * instead.
347
   */
348
  @SerializedName("statement_descriptor")
349
  String statementDescriptor;
350

351
  /**
352
   * Provides information about a card charge. Concatenated to the account's <a
353
   * href="https://docs.stripe.com/get-started/account/statement-descriptors#static">statement
354
   * descriptor prefix</a> to form the complete statement descriptor that appears on the customer's
355
   * statement.
356
   */
357
  @SerializedName("statement_descriptor_suffix")
358
  String statementDescriptorSuffix;
359

360
  /**
361
   * Status of this PaymentIntent, one of {@code requires_payment_method}, {@code
362
   * requires_confirmation}, {@code requires_action}, {@code processing}, {@code requires_capture},
363
   * {@code canceled}, or {@code succeeded}. Read more about each PaymentIntent <a
364
   * href="https://stripe.com/docs/payments/intents#intent-statuses">status</a>.
365
   */
366
  @SerializedName("status")
367
  String status;
368

369
  /**
370
   * The data that automatically creates a Transfer after the payment finalizes. Learn more about
371
   * the <a href="https://stripe.com/docs/payments/connected-accounts">use case for connected
372
   * accounts</a>.
373
   */
374
  @SerializedName("transfer_data")
375
  TransferData transferData;
376

377
  /**
378
   * A string that identifies the resulting payment as part of a group. Learn more about the <a
379
   * href="https://stripe.com/docs/connect/separate-charges-and-transfers">use case for connected
380
   * accounts</a>.
381
   */
382
  @SerializedName("transfer_group")
383
  String transferGroup;
384

385
  /** Get ID of expandable {@code application} object. */
386
  public String getApplication() {
387
    return (this.application != null) ? this.application.getId() : null;
1✔
388
  }
389

390
  public void setApplication(String id) {
391
    this.application = ApiResource.setExpandableFieldId(id, this.application);
×
392
  }
×
393

394
  /** Get expanded {@code application}. */
395
  public Application getApplicationObject() {
396
    return (this.application != null) ? this.application.getExpanded() : null;
1✔
397
  }
398

399
  public void setApplicationObject(Application expandableObject) {
400
    this.application = new ExpandableField<Application>(expandableObject.getId(), expandableObject);
×
401
  }
×
402

403
  /** Get ID of expandable {@code customer} object. */
404
  public String getCustomer() {
405
    return (this.customer != null) ? this.customer.getId() : null;
1✔
406
  }
407

408
  public void setCustomer(String id) {
409
    this.customer = ApiResource.setExpandableFieldId(id, this.customer);
×
410
  }
×
411

412
  /** Get expanded {@code customer}. */
413
  public Customer getCustomerObject() {
414
    return (this.customer != null) ? this.customer.getExpanded() : null;
1✔
415
  }
416

417
  public void setCustomerObject(Customer expandableObject) {
418
    this.customer = new ExpandableField<Customer>(expandableObject.getId(), expandableObject);
×
419
  }
×
420

421
  /** Get ID of expandable {@code invoice} object. */
422
  public String getInvoice() {
423
    return (this.invoice != null) ? this.invoice.getId() : null;
1✔
424
  }
425

426
  public void setInvoice(String id) {
427
    this.invoice = ApiResource.setExpandableFieldId(id, this.invoice);
×
428
  }
×
429

430
  /** Get expanded {@code invoice}. */
431
  public Invoice getInvoiceObject() {
432
    return (this.invoice != null) ? this.invoice.getExpanded() : null;
1✔
433
  }
434

435
  public void setInvoiceObject(Invoice expandableObject) {
436
    this.invoice = new ExpandableField<Invoice>(expandableObject.getId(), expandableObject);
×
437
  }
×
438

439
  /** Get ID of expandable {@code latestCharge} object. */
440
  public String getLatestCharge() {
441
    return (this.latestCharge != null) ? this.latestCharge.getId() : null;
×
442
  }
443

444
  public void setLatestCharge(String id) {
445
    this.latestCharge = ApiResource.setExpandableFieldId(id, this.latestCharge);
×
446
  }
×
447

448
  /** Get expanded {@code latestCharge}. */
449
  public Charge getLatestChargeObject() {
450
    return (this.latestCharge != null) ? this.latestCharge.getExpanded() : null;
×
451
  }
452

453
  public void setLatestChargeObject(Charge expandableObject) {
454
    this.latestCharge = new ExpandableField<Charge>(expandableObject.getId(), expandableObject);
×
455
  }
×
456

457
  /** Get ID of expandable {@code onBehalfOf} object. */
458
  public String getOnBehalfOf() {
459
    return (this.onBehalfOf != null) ? this.onBehalfOf.getId() : null;
1✔
460
  }
461

462
  public void setOnBehalfOf(String id) {
463
    this.onBehalfOf = ApiResource.setExpandableFieldId(id, this.onBehalfOf);
×
464
  }
×
465

466
  /** Get expanded {@code onBehalfOf}. */
467
  public Account getOnBehalfOfObject() {
468
    return (this.onBehalfOf != null) ? this.onBehalfOf.getExpanded() : null;
1✔
469
  }
470

471
  public void setOnBehalfOfObject(Account expandableObject) {
472
    this.onBehalfOf = new ExpandableField<Account>(expandableObject.getId(), expandableObject);
×
473
  }
×
474

475
  /** Get ID of expandable {@code paymentMethod} object. */
476
  public String getPaymentMethod() {
477
    return (this.paymentMethod != null) ? this.paymentMethod.getId() : null;
1✔
478
  }
479

480
  public void setPaymentMethod(String id) {
481
    this.paymentMethod = ApiResource.setExpandableFieldId(id, this.paymentMethod);
×
482
  }
×
483

484
  /** Get expanded {@code paymentMethod}. */
485
  public PaymentMethod getPaymentMethodObject() {
486
    return (this.paymentMethod != null) ? this.paymentMethod.getExpanded() : null;
1✔
487
  }
488

489
  public void setPaymentMethodObject(PaymentMethod expandableObject) {
490
    this.paymentMethod =
×
491
        new ExpandableField<PaymentMethod>(expandableObject.getId(), expandableObject);
×
492
  }
×
493

494
  /** Get ID of expandable {@code review} object. */
495
  public String getReview() {
496
    return (this.review != null) ? this.review.getId() : null;
1✔
497
  }
498

499
  public void setReview(String id) {
500
    this.review = ApiResource.setExpandableFieldId(id, this.review);
×
501
  }
×
502

503
  /** Get expanded {@code review}. */
504
  public Review getReviewObject() {
505
    return (this.review != null) ? this.review.getExpanded() : null;
1✔
506
  }
507

508
  public void setReviewObject(Review expandableObject) {
509
    this.review = new ExpandableField<Review>(expandableObject.getId(), expandableObject);
×
510
  }
×
511

512
  /** Get ID of expandable {@code source} object. */
513
  public String getSource() {
514
    return (this.source != null) ? this.source.getId() : null;
×
515
  }
516

517
  public void setSource(String id) {
518
    this.source = ApiResource.setExpandableFieldId(id, this.source);
×
519
  }
×
520

521
  /** Get expanded {@code source}. */
522
  public PaymentSource getSourceObject() {
523
    return (this.source != null) ? this.source.getExpanded() : null;
×
524
  }
525

526
  public void setSourceObject(PaymentSource expandableObject) {
527
    this.source = new ExpandableField<PaymentSource>(expandableObject.getId(), expandableObject);
×
528
  }
×
529

530
  /** Manually reconcile the remaining amount for a {@code customer_balance} PaymentIntent. */
531
  public PaymentIntent applyCustomerBalance() throws StripeException {
532
    return applyCustomerBalance((Map<String, Object>) null, (RequestOptions) null);
×
533
  }
534

535
  /** Manually reconcile the remaining amount for a {@code customer_balance} PaymentIntent. */
536
  public PaymentIntent applyCustomerBalance(RequestOptions options) throws StripeException {
537
    return applyCustomerBalance((Map<String, Object>) null, options);
×
538
  }
539

540
  /** Manually reconcile the remaining amount for a {@code customer_balance} PaymentIntent. */
541
  public PaymentIntent applyCustomerBalance(Map<String, Object> params) throws StripeException {
542
    return applyCustomerBalance(params, (RequestOptions) null);
×
543
  }
544

545
  /** Manually reconcile the remaining amount for a {@code customer_balance} PaymentIntent. */
546
  public PaymentIntent applyCustomerBalance(Map<String, Object> params, RequestOptions options)
547
      throws StripeException {
548
    String path =
×
549
        String.format(
×
550
            "/v1/payment_intents/%s/apply_customer_balance", ApiResource.urlEncodeId(this.getId()));
×
551
    ApiRequest request =
×
552
        new ApiRequest(BaseAddress.API, ApiResource.RequestMethod.POST, path, params, options);
553
    return getResponseGetter().request(request, PaymentIntent.class);
×
554
  }
555

556
  /** Manually reconcile the remaining amount for a {@code customer_balance} PaymentIntent. */
557
  public PaymentIntent applyCustomerBalance(PaymentIntentApplyCustomerBalanceParams params)
558
      throws StripeException {
559
    return applyCustomerBalance(params, (RequestOptions) null);
1✔
560
  }
561

562
  /** Manually reconcile the remaining amount for a {@code customer_balance} PaymentIntent. */
563
  public PaymentIntent applyCustomerBalance(
564
      PaymentIntentApplyCustomerBalanceParams params, RequestOptions options)
565
      throws StripeException {
566
    String path =
1✔
567
        String.format(
1✔
568
            "/v1/payment_intents/%s/apply_customer_balance", ApiResource.urlEncodeId(this.getId()));
1✔
569
    ApiResource.checkNullTypedParams(path, params);
1✔
570
    ApiRequest request =
1✔
571
        new ApiRequest(
572
            BaseAddress.API,
573
            ApiResource.RequestMethod.POST,
574
            path,
575
            ApiRequestParams.paramsToMap(params),
1✔
576
            options);
577
    return getResponseGetter().request(request, PaymentIntent.class);
1✔
578
  }
579

580
  /**
581
   * You can cancel a PaymentIntent object when it’s in one of these statuses: {@code
582
   * requires_payment_method}, {@code requires_capture}, {@code requires_confirmation}, {@code
583
   * requires_action} or, <a href="https://stripe.com/docs/payments/intents">in rare cases</a>,
584
   * {@code processing}.
585
   *
586
   * <p>After it’s canceled, no additional charges are made by the PaymentIntent and any operations
587
   * on the PaymentIntent fail with an error. For PaymentIntents with a {@code status} of {@code
588
   * requires_capture}, the remaining {@code amount_capturable} is automatically refunded.
589
   *
590
   * <p>You can’t cancel the PaymentIntent for a Checkout Session. <a
591
   * href="https://stripe.com/docs/api/checkout/sessions/expire">Expire the Checkout Session</a>
592
   * instead.
593
   */
594
  public PaymentIntent cancel() throws StripeException {
595
    return cancel((Map<String, Object>) null, (RequestOptions) null);
1✔
596
  }
597

598
  /**
599
   * You can cancel a PaymentIntent object when it’s in one of these statuses: {@code
600
   * requires_payment_method}, {@code requires_capture}, {@code requires_confirmation}, {@code
601
   * requires_action} or, <a href="https://stripe.com/docs/payments/intents">in rare cases</a>,
602
   * {@code processing}.
603
   *
604
   * <p>After it’s canceled, no additional charges are made by the PaymentIntent and any operations
605
   * on the PaymentIntent fail with an error. For PaymentIntents with a {@code status} of {@code
606
   * requires_capture}, the remaining {@code amount_capturable} is automatically refunded.
607
   *
608
   * <p>You can’t cancel the PaymentIntent for a Checkout Session. <a
609
   * href="https://stripe.com/docs/api/checkout/sessions/expire">Expire the Checkout Session</a>
610
   * instead.
611
   */
612
  public PaymentIntent cancel(RequestOptions options) throws StripeException {
613
    return cancel((Map<String, Object>) null, options);
×
614
  }
615

616
  /**
617
   * You can cancel a PaymentIntent object when it’s in one of these statuses: {@code
618
   * requires_payment_method}, {@code requires_capture}, {@code requires_confirmation}, {@code
619
   * requires_action} or, <a href="https://stripe.com/docs/payments/intents">in rare cases</a>,
620
   * {@code processing}.
621
   *
622
   * <p>After it’s canceled, no additional charges are made by the PaymentIntent and any operations
623
   * on the PaymentIntent fail with an error. For PaymentIntents with a {@code status} of {@code
624
   * requires_capture}, the remaining {@code amount_capturable} is automatically refunded.
625
   *
626
   * <p>You can’t cancel the PaymentIntent for a Checkout Session. <a
627
   * href="https://stripe.com/docs/api/checkout/sessions/expire">Expire the Checkout Session</a>
628
   * instead.
629
   */
630
  public PaymentIntent cancel(Map<String, Object> params) throws StripeException {
631
    return cancel(params, (RequestOptions) null);
×
632
  }
633

634
  /**
635
   * You can cancel a PaymentIntent object when it’s in one of these statuses: {@code
636
   * requires_payment_method}, {@code requires_capture}, {@code requires_confirmation}, {@code
637
   * requires_action} or, <a href="https://stripe.com/docs/payments/intents">in rare cases</a>,
638
   * {@code processing}.
639
   *
640
   * <p>After it’s canceled, no additional charges are made by the PaymentIntent and any operations
641
   * on the PaymentIntent fail with an error. For PaymentIntents with a {@code status} of {@code
642
   * requires_capture}, the remaining {@code amount_capturable} is automatically refunded.
643
   *
644
   * <p>You can’t cancel the PaymentIntent for a Checkout Session. <a
645
   * href="https://stripe.com/docs/api/checkout/sessions/expire">Expire the Checkout Session</a>
646
   * instead.
647
   */
648
  public PaymentIntent cancel(Map<String, Object> params, RequestOptions options)
649
      throws StripeException {
650
    String path =
1✔
651
        String.format("/v1/payment_intents/%s/cancel", ApiResource.urlEncodeId(this.getId()));
1✔
652
    ApiRequest request =
1✔
653
        new ApiRequest(BaseAddress.API, ApiResource.RequestMethod.POST, path, params, options);
654
    return getResponseGetter().request(request, PaymentIntent.class);
1✔
655
  }
656

657
  /**
658
   * You can cancel a PaymentIntent object when it’s in one of these statuses: {@code
659
   * requires_payment_method}, {@code requires_capture}, {@code requires_confirmation}, {@code
660
   * requires_action} or, <a href="https://stripe.com/docs/payments/intents">in rare cases</a>,
661
   * {@code processing}.
662
   *
663
   * <p>After it’s canceled, no additional charges are made by the PaymentIntent and any operations
664
   * on the PaymentIntent fail with an error. For PaymentIntents with a {@code status} of {@code
665
   * requires_capture}, the remaining {@code amount_capturable} is automatically refunded.
666
   *
667
   * <p>You can’t cancel the PaymentIntent for a Checkout Session. <a
668
   * href="https://stripe.com/docs/api/checkout/sessions/expire">Expire the Checkout Session</a>
669
   * instead.
670
   */
671
  public PaymentIntent cancel(PaymentIntentCancelParams params) throws StripeException {
672
    return cancel(params, (RequestOptions) null);
1✔
673
  }
674

675
  /**
676
   * You can cancel a PaymentIntent object when it’s in one of these statuses: {@code
677
   * requires_payment_method}, {@code requires_capture}, {@code requires_confirmation}, {@code
678
   * requires_action} or, <a href="https://stripe.com/docs/payments/intents">in rare cases</a>,
679
   * {@code processing}.
680
   *
681
   * <p>After it’s canceled, no additional charges are made by the PaymentIntent and any operations
682
   * on the PaymentIntent fail with an error. For PaymentIntents with a {@code status} of {@code
683
   * requires_capture}, the remaining {@code amount_capturable} is automatically refunded.
684
   *
685
   * <p>You can’t cancel the PaymentIntent for a Checkout Session. <a
686
   * href="https://stripe.com/docs/api/checkout/sessions/expire">Expire the Checkout Session</a>
687
   * instead.
688
   */
689
  public PaymentIntent cancel(PaymentIntentCancelParams params, RequestOptions options)
690
      throws StripeException {
691
    String path =
1✔
692
        String.format("/v1/payment_intents/%s/cancel", ApiResource.urlEncodeId(this.getId()));
1✔
693
    ApiResource.checkNullTypedParams(path, params);
1✔
694
    ApiRequest request =
1✔
695
        new ApiRequest(
696
            BaseAddress.API,
697
            ApiResource.RequestMethod.POST,
698
            path,
699
            ApiRequestParams.paramsToMap(params),
1✔
700
            options);
701
    return getResponseGetter().request(request, PaymentIntent.class);
1✔
702
  }
703

704
  /**
705
   * Capture the funds of an existing uncaptured PaymentIntent when its status is {@code
706
   * requires_capture}.
707
   *
708
   * <p>Uncaptured PaymentIntents are cancelled a set number of days (7 by default) after their
709
   * creation.
710
   *
711
   * <p>Learn more about <a href="https://stripe.com/docs/payments/capture-later">separate
712
   * authorization and capture</a>.
713
   */
714
  public PaymentIntent capture() throws StripeException {
715
    return capture((Map<String, Object>) null, (RequestOptions) null);
1✔
716
  }
717

718
  /**
719
   * Capture the funds of an existing uncaptured PaymentIntent when its status is {@code
720
   * requires_capture}.
721
   *
722
   * <p>Uncaptured PaymentIntents are cancelled a set number of days (7 by default) after their
723
   * creation.
724
   *
725
   * <p>Learn more about <a href="https://stripe.com/docs/payments/capture-later">separate
726
   * authorization and capture</a>.
727
   */
728
  public PaymentIntent capture(RequestOptions options) throws StripeException {
729
    return capture((Map<String, Object>) null, options);
×
730
  }
731

732
  /**
733
   * Capture the funds of an existing uncaptured PaymentIntent when its status is {@code
734
   * requires_capture}.
735
   *
736
   * <p>Uncaptured PaymentIntents are cancelled a set number of days (7 by default) after their
737
   * creation.
738
   *
739
   * <p>Learn more about <a href="https://stripe.com/docs/payments/capture-later">separate
740
   * authorization and capture</a>.
741
   */
742
  public PaymentIntent capture(Map<String, Object> params) throws StripeException {
743
    return capture(params, (RequestOptions) null);
×
744
  }
745

746
  /**
747
   * Capture the funds of an existing uncaptured PaymentIntent when its status is {@code
748
   * requires_capture}.
749
   *
750
   * <p>Uncaptured PaymentIntents are cancelled a set number of days (7 by default) after their
751
   * creation.
752
   *
753
   * <p>Learn more about <a href="https://stripe.com/docs/payments/capture-later">separate
754
   * authorization and capture</a>.
755
   */
756
  public PaymentIntent capture(Map<String, Object> params, RequestOptions options)
757
      throws StripeException {
758
    String path =
1✔
759
        String.format("/v1/payment_intents/%s/capture", ApiResource.urlEncodeId(this.getId()));
1✔
760
    ApiRequest request =
1✔
761
        new ApiRequest(BaseAddress.API, ApiResource.RequestMethod.POST, path, params, options);
762
    return getResponseGetter().request(request, PaymentIntent.class);
1✔
763
  }
764

765
  /**
766
   * Capture the funds of an existing uncaptured PaymentIntent when its status is {@code
767
   * requires_capture}.
768
   *
769
   * <p>Uncaptured PaymentIntents are cancelled a set number of days (7 by default) after their
770
   * creation.
771
   *
772
   * <p>Learn more about <a href="https://stripe.com/docs/payments/capture-later">separate
773
   * authorization and capture</a>.
774
   */
775
  public PaymentIntent capture(PaymentIntentCaptureParams params) throws StripeException {
776
    return capture(params, (RequestOptions) null);
1✔
777
  }
778

779
  /**
780
   * Capture the funds of an existing uncaptured PaymentIntent when its status is {@code
781
   * requires_capture}.
782
   *
783
   * <p>Uncaptured PaymentIntents are cancelled a set number of days (7 by default) after their
784
   * creation.
785
   *
786
   * <p>Learn more about <a href="https://stripe.com/docs/payments/capture-later">separate
787
   * authorization and capture</a>.
788
   */
789
  public PaymentIntent capture(PaymentIntentCaptureParams params, RequestOptions options)
790
      throws StripeException {
791
    String path =
1✔
792
        String.format("/v1/payment_intents/%s/capture", ApiResource.urlEncodeId(this.getId()));
1✔
793
    ApiResource.checkNullTypedParams(path, params);
1✔
794
    ApiRequest request =
1✔
795
        new ApiRequest(
796
            BaseAddress.API,
797
            ApiResource.RequestMethod.POST,
798
            path,
799
            ApiRequestParams.paramsToMap(params),
1✔
800
            options);
801
    return getResponseGetter().request(request, PaymentIntent.class);
1✔
802
  }
803

804
  /**
805
   * Confirm that your customer intends to pay with current or provided payment method. Upon
806
   * confirmation, the PaymentIntent will attempt to initiate a payment. If the selected payment
807
   * method requires additional authentication steps, the PaymentIntent will transition to the
808
   * {@code requires_action} status and suggest additional actions via {@code next_action}. If
809
   * payment fails, the PaymentIntent transitions to the {@code requires_payment_method} status or
810
   * the {@code canceled} status if the confirmation limit is reached. If payment succeeds, the
811
   * PaymentIntent will transition to the {@code succeeded} status (or {@code requires_capture}, if
812
   * {@code capture_method} is set to {@code manual}). If the {@code confirmation_method} is {@code
813
   * automatic}, payment may be attempted using our <a
814
   * href="https://stripe.com/docs/stripe-js/reference#stripe-handle-card-payment">client SDKs</a>
815
   * and the PaymentIntent’s <a
816
   * href="https://stripe.com/docs/api#payment_intent_object-client_secret">client_secret</a>. After
817
   * {@code next_action}s are handled by the client, no additional confirmation is required to
818
   * complete the payment. If the {@code confirmation_method} is {@code manual}, all payment
819
   * attempts must be initiated using a secret key. If any actions are required for the payment, the
820
   * PaymentIntent will return to the {@code requires_confirmation} state after those actions are
821
   * completed. Your server needs to then explicitly re-confirm the PaymentIntent to initiate the
822
   * next payment attempt. There is a variable upper limit on how many times a PaymentIntent can be
823
   * confirmed. After this limit is reached, any further calls to this endpoint will transition the
824
   * PaymentIntent to the {@code canceled} state.
825
   */
826
  public PaymentIntent confirm() throws StripeException {
827
    return confirm((Map<String, Object>) null, (RequestOptions) null);
1✔
828
  }
829

830
  /**
831
   * Confirm that your customer intends to pay with current or provided payment method. Upon
832
   * confirmation, the PaymentIntent will attempt to initiate a payment. If the selected payment
833
   * method requires additional authentication steps, the PaymentIntent will transition to the
834
   * {@code requires_action} status and suggest additional actions via {@code next_action}. If
835
   * payment fails, the PaymentIntent transitions to the {@code requires_payment_method} status or
836
   * the {@code canceled} status if the confirmation limit is reached. If payment succeeds, the
837
   * PaymentIntent will transition to the {@code succeeded} status (or {@code requires_capture}, if
838
   * {@code capture_method} is set to {@code manual}). If the {@code confirmation_method} is {@code
839
   * automatic}, payment may be attempted using our <a
840
   * href="https://stripe.com/docs/stripe-js/reference#stripe-handle-card-payment">client SDKs</a>
841
   * and the PaymentIntent’s <a
842
   * href="https://stripe.com/docs/api#payment_intent_object-client_secret">client_secret</a>. After
843
   * {@code next_action}s are handled by the client, no additional confirmation is required to
844
   * complete the payment. If the {@code confirmation_method} is {@code manual}, all payment
845
   * attempts must be initiated using a secret key. If any actions are required for the payment, the
846
   * PaymentIntent will return to the {@code requires_confirmation} state after those actions are
847
   * completed. Your server needs to then explicitly re-confirm the PaymentIntent to initiate the
848
   * next payment attempt. There is a variable upper limit on how many times a PaymentIntent can be
849
   * confirmed. After this limit is reached, any further calls to this endpoint will transition the
850
   * PaymentIntent to the {@code canceled} state.
851
   */
852
  public PaymentIntent confirm(RequestOptions options) throws StripeException {
853
    return confirm((Map<String, Object>) null, options);
×
854
  }
855

856
  /**
857
   * Confirm that your customer intends to pay with current or provided payment method. Upon
858
   * confirmation, the PaymentIntent will attempt to initiate a payment. If the selected payment
859
   * method requires additional authentication steps, the PaymentIntent will transition to the
860
   * {@code requires_action} status and suggest additional actions via {@code next_action}. If
861
   * payment fails, the PaymentIntent transitions to the {@code requires_payment_method} status or
862
   * the {@code canceled} status if the confirmation limit is reached. If payment succeeds, the
863
   * PaymentIntent will transition to the {@code succeeded} status (or {@code requires_capture}, if
864
   * {@code capture_method} is set to {@code manual}). If the {@code confirmation_method} is {@code
865
   * automatic}, payment may be attempted using our <a
866
   * href="https://stripe.com/docs/stripe-js/reference#stripe-handle-card-payment">client SDKs</a>
867
   * and the PaymentIntent’s <a
868
   * href="https://stripe.com/docs/api#payment_intent_object-client_secret">client_secret</a>. After
869
   * {@code next_action}s are handled by the client, no additional confirmation is required to
870
   * complete the payment. If the {@code confirmation_method} is {@code manual}, all payment
871
   * attempts must be initiated using a secret key. If any actions are required for the payment, the
872
   * PaymentIntent will return to the {@code requires_confirmation} state after those actions are
873
   * completed. Your server needs to then explicitly re-confirm the PaymentIntent to initiate the
874
   * next payment attempt. There is a variable upper limit on how many times a PaymentIntent can be
875
   * confirmed. After this limit is reached, any further calls to this endpoint will transition the
876
   * PaymentIntent to the {@code canceled} state.
877
   */
878
  public PaymentIntent confirm(Map<String, Object> params) throws StripeException {
879
    return confirm(params, (RequestOptions) null);
×
880
  }
881

882
  /**
883
   * Confirm that your customer intends to pay with current or provided payment method. Upon
884
   * confirmation, the PaymentIntent will attempt to initiate a payment. If the selected payment
885
   * method requires additional authentication steps, the PaymentIntent will transition to the
886
   * {@code requires_action} status and suggest additional actions via {@code next_action}. If
887
   * payment fails, the PaymentIntent transitions to the {@code requires_payment_method} status or
888
   * the {@code canceled} status if the confirmation limit is reached. If payment succeeds, the
889
   * PaymentIntent will transition to the {@code succeeded} status (or {@code requires_capture}, if
890
   * {@code capture_method} is set to {@code manual}). If the {@code confirmation_method} is {@code
891
   * automatic}, payment may be attempted using our <a
892
   * href="https://stripe.com/docs/stripe-js/reference#stripe-handle-card-payment">client SDKs</a>
893
   * and the PaymentIntent’s <a
894
   * href="https://stripe.com/docs/api#payment_intent_object-client_secret">client_secret</a>. After
895
   * {@code next_action}s are handled by the client, no additional confirmation is required to
896
   * complete the payment. If the {@code confirmation_method} is {@code manual}, all payment
897
   * attempts must be initiated using a secret key. If any actions are required for the payment, the
898
   * PaymentIntent will return to the {@code requires_confirmation} state after those actions are
899
   * completed. Your server needs to then explicitly re-confirm the PaymentIntent to initiate the
900
   * next payment attempt. There is a variable upper limit on how many times a PaymentIntent can be
901
   * confirmed. After this limit is reached, any further calls to this endpoint will transition the
902
   * PaymentIntent to the {@code canceled} state.
903
   */
904
  public PaymentIntent confirm(Map<String, Object> params, RequestOptions options)
905
      throws StripeException {
906
    String path =
1✔
907
        String.format("/v1/payment_intents/%s/confirm", ApiResource.urlEncodeId(this.getId()));
1✔
908
    ApiRequest request =
1✔
909
        new ApiRequest(BaseAddress.API, ApiResource.RequestMethod.POST, path, params, options);
910
    return getResponseGetter().request(request, PaymentIntent.class);
1✔
911
  }
912

913
  /**
914
   * Confirm that your customer intends to pay with current or provided payment method. Upon
915
   * confirmation, the PaymentIntent will attempt to initiate a payment. If the selected payment
916
   * method requires additional authentication steps, the PaymentIntent will transition to the
917
   * {@code requires_action} status and suggest additional actions via {@code next_action}. If
918
   * payment fails, the PaymentIntent transitions to the {@code requires_payment_method} status or
919
   * the {@code canceled} status if the confirmation limit is reached. If payment succeeds, the
920
   * PaymentIntent will transition to the {@code succeeded} status (or {@code requires_capture}, if
921
   * {@code capture_method} is set to {@code manual}). If the {@code confirmation_method} is {@code
922
   * automatic}, payment may be attempted using our <a
923
   * href="https://stripe.com/docs/stripe-js/reference#stripe-handle-card-payment">client SDKs</a>
924
   * and the PaymentIntent’s <a
925
   * href="https://stripe.com/docs/api#payment_intent_object-client_secret">client_secret</a>. After
926
   * {@code next_action}s are handled by the client, no additional confirmation is required to
927
   * complete the payment. If the {@code confirmation_method} is {@code manual}, all payment
928
   * attempts must be initiated using a secret key. If any actions are required for the payment, the
929
   * PaymentIntent will return to the {@code requires_confirmation} state after those actions are
930
   * completed. Your server needs to then explicitly re-confirm the PaymentIntent to initiate the
931
   * next payment attempt. There is a variable upper limit on how many times a PaymentIntent can be
932
   * confirmed. After this limit is reached, any further calls to this endpoint will transition the
933
   * PaymentIntent to the {@code canceled} state.
934
   */
935
  public PaymentIntent confirm(PaymentIntentConfirmParams params) throws StripeException {
936
    return confirm(params, (RequestOptions) null);
1✔
937
  }
938

939
  /**
940
   * Confirm that your customer intends to pay with current or provided payment method. Upon
941
   * confirmation, the PaymentIntent will attempt to initiate a payment. If the selected payment
942
   * method requires additional authentication steps, the PaymentIntent will transition to the
943
   * {@code requires_action} status and suggest additional actions via {@code next_action}. If
944
   * payment fails, the PaymentIntent transitions to the {@code requires_payment_method} status or
945
   * the {@code canceled} status if the confirmation limit is reached. If payment succeeds, the
946
   * PaymentIntent will transition to the {@code succeeded} status (or {@code requires_capture}, if
947
   * {@code capture_method} is set to {@code manual}). If the {@code confirmation_method} is {@code
948
   * automatic}, payment may be attempted using our <a
949
   * href="https://stripe.com/docs/stripe-js/reference#stripe-handle-card-payment">client SDKs</a>
950
   * and the PaymentIntent’s <a
951
   * href="https://stripe.com/docs/api#payment_intent_object-client_secret">client_secret</a>. After
952
   * {@code next_action}s are handled by the client, no additional confirmation is required to
953
   * complete the payment. If the {@code confirmation_method} is {@code manual}, all payment
954
   * attempts must be initiated using a secret key. If any actions are required for the payment, the
955
   * PaymentIntent will return to the {@code requires_confirmation} state after those actions are
956
   * completed. Your server needs to then explicitly re-confirm the PaymentIntent to initiate the
957
   * next payment attempt. There is a variable upper limit on how many times a PaymentIntent can be
958
   * confirmed. After this limit is reached, any further calls to this endpoint will transition the
959
   * PaymentIntent to the {@code canceled} state.
960
   */
961
  public PaymentIntent confirm(PaymentIntentConfirmParams params, RequestOptions options)
962
      throws StripeException {
963
    String path =
1✔
964
        String.format("/v1/payment_intents/%s/confirm", ApiResource.urlEncodeId(this.getId()));
1✔
965
    ApiResource.checkNullTypedParams(path, params);
1✔
966
    ApiRequest request =
1✔
967
        new ApiRequest(
968
            BaseAddress.API,
969
            ApiResource.RequestMethod.POST,
970
            path,
971
            ApiRequestParams.paramsToMap(params),
1✔
972
            options);
973
    return getResponseGetter().request(request, PaymentIntent.class);
1✔
974
  }
975

976
  /**
977
   * Creates a PaymentIntent object.
978
   *
979
   * <p>After the PaymentIntent is created, attach a payment method and <a
980
   * href="https://stripe.com/docs/api/payment_intents/confirm">confirm</a> to continue the payment.
981
   * Learn more about <a href="https://stripe.com/docs/payments/payment-intents">the available
982
   * payment flows with the Payment Intents API</a>.
983
   *
984
   * <p>When you use {@code confirm=true} during creation, it’s equivalent to creating and
985
   * confirming the PaymentIntent in the same call. You can use any parameters available in the <a
986
   * href="https://stripe.com/docs/api/payment_intents/confirm">confirm API</a> when you supply
987
   * {@code confirm=true}.
988
   */
989
  public static PaymentIntent create(Map<String, Object> params) throws StripeException {
990
    return create(params, (RequestOptions) null);
1✔
991
  }
992

993
  /**
994
   * Creates a PaymentIntent object.
995
   *
996
   * <p>After the PaymentIntent is created, attach a payment method and <a
997
   * href="https://stripe.com/docs/api/payment_intents/confirm">confirm</a> to continue the payment.
998
   * Learn more about <a href="https://stripe.com/docs/payments/payment-intents">the available
999
   * payment flows with the Payment Intents API</a>.
1000
   *
1001
   * <p>When you use {@code confirm=true} during creation, it’s equivalent to creating and
1002
   * confirming the PaymentIntent in the same call. You can use any parameters available in the <a
1003
   * href="https://stripe.com/docs/api/payment_intents/confirm">confirm API</a> when you supply
1004
   * {@code confirm=true}.
1005
   */
1006
  public static PaymentIntent create(Map<String, Object> params, RequestOptions options)
1007
      throws StripeException {
1008
    String path = "/v1/payment_intents";
1✔
1009
    ApiRequest request =
1✔
1010
        new ApiRequest(BaseAddress.API, ApiResource.RequestMethod.POST, path, params, options);
1011
    return getGlobalResponseGetter().request(request, PaymentIntent.class);
1✔
1012
  }
1013

1014
  /**
1015
   * Creates a PaymentIntent object.
1016
   *
1017
   * <p>After the PaymentIntent is created, attach a payment method and <a
1018
   * href="https://stripe.com/docs/api/payment_intents/confirm">confirm</a> to continue the payment.
1019
   * Learn more about <a href="https://stripe.com/docs/payments/payment-intents">the available
1020
   * payment flows with the Payment Intents API</a>.
1021
   *
1022
   * <p>When you use {@code confirm=true} during creation, it’s equivalent to creating and
1023
   * confirming the PaymentIntent in the same call. You can use any parameters available in the <a
1024
   * href="https://stripe.com/docs/api/payment_intents/confirm">confirm API</a> when you supply
1025
   * {@code confirm=true}.
1026
   */
1027
  public static PaymentIntent create(PaymentIntentCreateParams params) throws StripeException {
1028
    return create(params, (RequestOptions) null);
1✔
1029
  }
1030

1031
  /**
1032
   * Creates a PaymentIntent object.
1033
   *
1034
   * <p>After the PaymentIntent is created, attach a payment method and <a
1035
   * href="https://stripe.com/docs/api/payment_intents/confirm">confirm</a> to continue the payment.
1036
   * Learn more about <a href="https://stripe.com/docs/payments/payment-intents">the available
1037
   * payment flows with the Payment Intents API</a>.
1038
   *
1039
   * <p>When you use {@code confirm=true} during creation, it’s equivalent to creating and
1040
   * confirming the PaymentIntent in the same call. You can use any parameters available in the <a
1041
   * href="https://stripe.com/docs/api/payment_intents/confirm">confirm API</a> when you supply
1042
   * {@code confirm=true}.
1043
   */
1044
  public static PaymentIntent create(PaymentIntentCreateParams params, RequestOptions options)
1045
      throws StripeException {
1046
    String path = "/v1/payment_intents";
1✔
1047
    ApiResource.checkNullTypedParams(path, params);
1✔
1048
    ApiRequest request =
1✔
1049
        new ApiRequest(
1050
            BaseAddress.API,
1051
            ApiResource.RequestMethod.POST,
1052
            path,
1053
            ApiRequestParams.paramsToMap(params),
1✔
1054
            options);
1055
    return getGlobalResponseGetter().request(request, PaymentIntent.class);
1✔
1056
  }
1057

1058
  /**
1059
   * Perform a decremental authorization on an eligible <a
1060
   * href="https://stripe.com/docs/api/payment_intents/object">PaymentIntent</a>. To be eligible,
1061
   * the PaymentIntent’s status must be {@code requires_capture} and <a
1062
   * href="https://stripe.com/docs/api/charges/object#charge_object-payment_method_details-card-decremental_authorization">decremental_authorization.status</a>
1063
   * must be {@code available}.
1064
   *
1065
   * <p>Decremental authorizations decrease the authorized amount on your customer’s card to the
1066
   * new, lower {@code amount} provided. A single PaymentIntent can call this endpoint multiple
1067
   * times to further decrease the authorized amount.
1068
   *
1069
   * <p>After decrement, the PaymentIntent object returns with the updated <a
1070
   * href="https://stripe.com/docs/api/payment_intents/object#payment_intent_object-amount">amount</a>.
1071
   * The PaymentIntent will now be capturable up to the new authorized amount.
1072
   *
1073
   * <p>Each PaymentIntent can have a maximum of 10 decremental or incremental authorization
1074
   * attempts, including declines. After it’s fully captured, a PaymentIntent can no longer be
1075
   * decremented.
1076
   */
1077
  public PaymentIntent decrementAuthorization(Map<String, Object> params) throws StripeException {
1078
    return decrementAuthorization(params, (RequestOptions) null);
×
1079
  }
1080

1081
  /**
1082
   * Perform a decremental authorization on an eligible <a
1083
   * href="https://stripe.com/docs/api/payment_intents/object">PaymentIntent</a>. To be eligible,
1084
   * the PaymentIntent’s status must be {@code requires_capture} and <a
1085
   * href="https://stripe.com/docs/api/charges/object#charge_object-payment_method_details-card-decremental_authorization">decremental_authorization.status</a>
1086
   * must be {@code available}.
1087
   *
1088
   * <p>Decremental authorizations decrease the authorized amount on your customer’s card to the
1089
   * new, lower {@code amount} provided. A single PaymentIntent can call this endpoint multiple
1090
   * times to further decrease the authorized amount.
1091
   *
1092
   * <p>After decrement, the PaymentIntent object returns with the updated <a
1093
   * href="https://stripe.com/docs/api/payment_intents/object#payment_intent_object-amount">amount</a>.
1094
   * The PaymentIntent will now be capturable up to the new authorized amount.
1095
   *
1096
   * <p>Each PaymentIntent can have a maximum of 10 decremental or incremental authorization
1097
   * attempts, including declines. After it’s fully captured, a PaymentIntent can no longer be
1098
   * decremented.
1099
   */
1100
  public PaymentIntent decrementAuthorization(Map<String, Object> params, RequestOptions options)
1101
      throws StripeException {
1102
    String path =
×
1103
        String.format(
×
1104
            "/v1/payment_intents/%s/decrement_authorization",
1105
            ApiResource.urlEncodeId(this.getId()));
×
1106
    ApiRequest request =
×
1107
        new ApiRequest(BaseAddress.API, ApiResource.RequestMethod.POST, path, params, options);
1108
    return getResponseGetter().request(request, PaymentIntent.class);
×
1109
  }
1110

1111
  /**
1112
   * Perform a decremental authorization on an eligible <a
1113
   * href="https://stripe.com/docs/api/payment_intents/object">PaymentIntent</a>. To be eligible,
1114
   * the PaymentIntent’s status must be {@code requires_capture} and <a
1115
   * href="https://stripe.com/docs/api/charges/object#charge_object-payment_method_details-card-decremental_authorization">decremental_authorization.status</a>
1116
   * must be {@code available}.
1117
   *
1118
   * <p>Decremental authorizations decrease the authorized amount on your customer’s card to the
1119
   * new, lower {@code amount} provided. A single PaymentIntent can call this endpoint multiple
1120
   * times to further decrease the authorized amount.
1121
   *
1122
   * <p>After decrement, the PaymentIntent object returns with the updated <a
1123
   * href="https://stripe.com/docs/api/payment_intents/object#payment_intent_object-amount">amount</a>.
1124
   * The PaymentIntent will now be capturable up to the new authorized amount.
1125
   *
1126
   * <p>Each PaymentIntent can have a maximum of 10 decremental or incremental authorization
1127
   * attempts, including declines. After it’s fully captured, a PaymentIntent can no longer be
1128
   * decremented.
1129
   */
1130
  public PaymentIntent decrementAuthorization(PaymentIntentDecrementAuthorizationParams params)
1131
      throws StripeException {
1132
    return decrementAuthorization(params, (RequestOptions) null);
×
1133
  }
1134

1135
  /**
1136
   * Perform a decremental authorization on an eligible <a
1137
   * href="https://stripe.com/docs/api/payment_intents/object">PaymentIntent</a>. To be eligible,
1138
   * the PaymentIntent’s status must be {@code requires_capture} and <a
1139
   * href="https://stripe.com/docs/api/charges/object#charge_object-payment_method_details-card-decremental_authorization">decremental_authorization.status</a>
1140
   * must be {@code available}.
1141
   *
1142
   * <p>Decremental authorizations decrease the authorized amount on your customer’s card to the
1143
   * new, lower {@code amount} provided. A single PaymentIntent can call this endpoint multiple
1144
   * times to further decrease the authorized amount.
1145
   *
1146
   * <p>After decrement, the PaymentIntent object returns with the updated <a
1147
   * href="https://stripe.com/docs/api/payment_intents/object#payment_intent_object-amount">amount</a>.
1148
   * The PaymentIntent will now be capturable up to the new authorized amount.
1149
   *
1150
   * <p>Each PaymentIntent can have a maximum of 10 decremental or incremental authorization
1151
   * attempts, including declines. After it’s fully captured, a PaymentIntent can no longer be
1152
   * decremented.
1153
   */
1154
  public PaymentIntent decrementAuthorization(
1155
      PaymentIntentDecrementAuthorizationParams params, RequestOptions options)
1156
      throws StripeException {
1157
    String path =
×
1158
        String.format(
×
1159
            "/v1/payment_intents/%s/decrement_authorization",
1160
            ApiResource.urlEncodeId(this.getId()));
×
1161
    ApiResource.checkNullTypedParams(path, params);
×
1162
    ApiRequest request =
×
1163
        new ApiRequest(
1164
            BaseAddress.API,
1165
            ApiResource.RequestMethod.POST,
1166
            path,
1167
            ApiRequestParams.paramsToMap(params),
×
1168
            options);
1169
    return getResponseGetter().request(request, PaymentIntent.class);
×
1170
  }
1171

1172
  /**
1173
   * Perform an incremental authorization on an eligible <a
1174
   * href="https://stripe.com/docs/api/payment_intents/object">PaymentIntent</a>. To be eligible,
1175
   * the PaymentIntent’s status must be {@code requires_capture} and <a
1176
   * href="https://stripe.com/docs/api/charges/object#charge_object-payment_method_details-card_present-incremental_authorization_supported">incremental_authorization_supported</a>
1177
   * must be {@code true}.
1178
   *
1179
   * <p>Incremental authorizations attempt to increase the authorized amount on your customer’s card
1180
   * to the new, higher {@code amount} provided. Similar to the initial authorization, incremental
1181
   * authorizations can be declined. A single PaymentIntent can call this endpoint multiple times to
1182
   * further increase the authorized amount.
1183
   *
1184
   * <p>If the incremental authorization succeeds, the PaymentIntent object returns with the updated
1185
   * <a
1186
   * href="https://stripe.com/docs/api/payment_intents/object#payment_intent_object-amount">amount</a>.
1187
   * If the incremental authorization fails, a <a
1188
   * href="https://stripe.com/docs/error-codes#card-declined">card_declined</a> error returns, and
1189
   * no other fields on the PaymentIntent or Charge update. The PaymentIntent object remains
1190
   * capturable for the previously authorized amount.
1191
   *
1192
   * <p>Each PaymentIntent can have a maximum of 10 incremental authorization attempts, including
1193
   * declines. After it’s captured, a PaymentIntent can no longer be incremented.
1194
   *
1195
   * <p>Learn more about <a
1196
   * href="https://stripe.com/docs/terminal/features/incremental-authorizations">incremental
1197
   * authorizations</a>.
1198
   */
1199
  public PaymentIntent incrementAuthorization(Map<String, Object> params) throws StripeException {
1200
    return incrementAuthorization(params, (RequestOptions) null);
×
1201
  }
1202

1203
  /**
1204
   * Perform an incremental authorization on an eligible <a
1205
   * href="https://stripe.com/docs/api/payment_intents/object">PaymentIntent</a>. To be eligible,
1206
   * the PaymentIntent’s status must be {@code requires_capture} and <a
1207
   * href="https://stripe.com/docs/api/charges/object#charge_object-payment_method_details-card_present-incremental_authorization_supported">incremental_authorization_supported</a>
1208
   * must be {@code true}.
1209
   *
1210
   * <p>Incremental authorizations attempt to increase the authorized amount on your customer’s card
1211
   * to the new, higher {@code amount} provided. Similar to the initial authorization, incremental
1212
   * authorizations can be declined. A single PaymentIntent can call this endpoint multiple times to
1213
   * further increase the authorized amount.
1214
   *
1215
   * <p>If the incremental authorization succeeds, the PaymentIntent object returns with the updated
1216
   * <a
1217
   * href="https://stripe.com/docs/api/payment_intents/object#payment_intent_object-amount">amount</a>.
1218
   * If the incremental authorization fails, a <a
1219
   * href="https://stripe.com/docs/error-codes#card-declined">card_declined</a> error returns, and
1220
   * no other fields on the PaymentIntent or Charge update. The PaymentIntent object remains
1221
   * capturable for the previously authorized amount.
1222
   *
1223
   * <p>Each PaymentIntent can have a maximum of 10 incremental authorization attempts, including
1224
   * declines. After it’s captured, a PaymentIntent can no longer be incremented.
1225
   *
1226
   * <p>Learn more about <a
1227
   * href="https://stripe.com/docs/terminal/features/incremental-authorizations">incremental
1228
   * authorizations</a>.
1229
   */
1230
  public PaymentIntent incrementAuthorization(Map<String, Object> params, RequestOptions options)
1231
      throws StripeException {
1232
    String path =
×
1233
        String.format(
×
1234
            "/v1/payment_intents/%s/increment_authorization",
1235
            ApiResource.urlEncodeId(this.getId()));
×
1236
    ApiRequest request =
×
1237
        new ApiRequest(BaseAddress.API, ApiResource.RequestMethod.POST, path, params, options);
1238
    return getResponseGetter().request(request, PaymentIntent.class);
×
1239
  }
1240

1241
  /**
1242
   * Perform an incremental authorization on an eligible <a
1243
   * href="https://stripe.com/docs/api/payment_intents/object">PaymentIntent</a>. To be eligible,
1244
   * the PaymentIntent’s status must be {@code requires_capture} and <a
1245
   * href="https://stripe.com/docs/api/charges/object#charge_object-payment_method_details-card_present-incremental_authorization_supported">incremental_authorization_supported</a>
1246
   * must be {@code true}.
1247
   *
1248
   * <p>Incremental authorizations attempt to increase the authorized amount on your customer’s card
1249
   * to the new, higher {@code amount} provided. Similar to the initial authorization, incremental
1250
   * authorizations can be declined. A single PaymentIntent can call this endpoint multiple times to
1251
   * further increase the authorized amount.
1252
   *
1253
   * <p>If the incremental authorization succeeds, the PaymentIntent object returns with the updated
1254
   * <a
1255
   * href="https://stripe.com/docs/api/payment_intents/object#payment_intent_object-amount">amount</a>.
1256
   * If the incremental authorization fails, a <a
1257
   * href="https://stripe.com/docs/error-codes#card-declined">card_declined</a> error returns, and
1258
   * no other fields on the PaymentIntent or Charge update. The PaymentIntent object remains
1259
   * capturable for the previously authorized amount.
1260
   *
1261
   * <p>Each PaymentIntent can have a maximum of 10 incremental authorization attempts, including
1262
   * declines. After it’s captured, a PaymentIntent can no longer be incremented.
1263
   *
1264
   * <p>Learn more about <a
1265
   * href="https://stripe.com/docs/terminal/features/incremental-authorizations">incremental
1266
   * authorizations</a>.
1267
   */
1268
  public PaymentIntent incrementAuthorization(PaymentIntentIncrementAuthorizationParams params)
1269
      throws StripeException {
1270
    return incrementAuthorization(params, (RequestOptions) null);
1✔
1271
  }
1272

1273
  /**
1274
   * Perform an incremental authorization on an eligible <a
1275
   * href="https://stripe.com/docs/api/payment_intents/object">PaymentIntent</a>. To be eligible,
1276
   * the PaymentIntent’s status must be {@code requires_capture} and <a
1277
   * href="https://stripe.com/docs/api/charges/object#charge_object-payment_method_details-card_present-incremental_authorization_supported">incremental_authorization_supported</a>
1278
   * must be {@code true}.
1279
   *
1280
   * <p>Incremental authorizations attempt to increase the authorized amount on your customer’s card
1281
   * to the new, higher {@code amount} provided. Similar to the initial authorization, incremental
1282
   * authorizations can be declined. A single PaymentIntent can call this endpoint multiple times to
1283
   * further increase the authorized amount.
1284
   *
1285
   * <p>If the incremental authorization succeeds, the PaymentIntent object returns with the updated
1286
   * <a
1287
   * href="https://stripe.com/docs/api/payment_intents/object#payment_intent_object-amount">amount</a>.
1288
   * If the incremental authorization fails, a <a
1289
   * href="https://stripe.com/docs/error-codes#card-declined">card_declined</a> error returns, and
1290
   * no other fields on the PaymentIntent or Charge update. The PaymentIntent object remains
1291
   * capturable for the previously authorized amount.
1292
   *
1293
   * <p>Each PaymentIntent can have a maximum of 10 incremental authorization attempts, including
1294
   * declines. After it’s captured, a PaymentIntent can no longer be incremented.
1295
   *
1296
   * <p>Learn more about <a
1297
   * href="https://stripe.com/docs/terminal/features/incremental-authorizations">incremental
1298
   * authorizations</a>.
1299
   */
1300
  public PaymentIntent incrementAuthorization(
1301
      PaymentIntentIncrementAuthorizationParams params, RequestOptions options)
1302
      throws StripeException {
1303
    String path =
1✔
1304
        String.format(
1✔
1305
            "/v1/payment_intents/%s/increment_authorization",
1306
            ApiResource.urlEncodeId(this.getId()));
1✔
1307
    ApiResource.checkNullTypedParams(path, params);
1✔
1308
    ApiRequest request =
1✔
1309
        new ApiRequest(
1310
            BaseAddress.API,
1311
            ApiResource.RequestMethod.POST,
1312
            path,
1313
            ApiRequestParams.paramsToMap(params),
1✔
1314
            options);
1315
    return getResponseGetter().request(request, PaymentIntent.class);
1✔
1316
  }
1317

1318
  /** Returns a list of PaymentIntents. */
1319
  public static PaymentIntentCollection list(Map<String, Object> params) throws StripeException {
1320
    return list(params, (RequestOptions) null);
1✔
1321
  }
1322

1323
  /** Returns a list of PaymentIntents. */
1324
  public static PaymentIntentCollection list(Map<String, Object> params, RequestOptions options)
1325
      throws StripeException {
1326
    String path = "/v1/payment_intents";
1✔
1327
    ApiRequest request =
1✔
1328
        new ApiRequest(BaseAddress.API, ApiResource.RequestMethod.GET, path, params, options);
1329
    return getGlobalResponseGetter().request(request, PaymentIntentCollection.class);
1✔
1330
  }
1331

1332
  /** Returns a list of PaymentIntents. */
1333
  public static PaymentIntentCollection list(PaymentIntentListParams params)
1334
      throws StripeException {
1335
    return list(params, (RequestOptions) null);
1✔
1336
  }
1337

1338
  /** Returns a list of PaymentIntents. */
1339
  public static PaymentIntentCollection list(PaymentIntentListParams params, RequestOptions options)
1340
      throws StripeException {
1341
    String path = "/v1/payment_intents";
1✔
1342
    ApiResource.checkNullTypedParams(path, params);
1✔
1343
    ApiRequest request =
1✔
1344
        new ApiRequest(
1345
            BaseAddress.API,
1346
            ApiResource.RequestMethod.GET,
1347
            path,
1348
            ApiRequestParams.paramsToMap(params),
1✔
1349
            options);
1350
    return getGlobalResponseGetter().request(request, PaymentIntentCollection.class);
1✔
1351
  }
1352

1353
  /**
1354
   * Retrieves the details of a PaymentIntent that has previously been created.
1355
   *
1356
   * <p>You can retrieve a PaymentIntent client-side using a publishable key when the {@code
1357
   * client_secret} is in the query string.
1358
   *
1359
   * <p>If you retrieve a PaymentIntent with a publishable key, it only returns a subset of
1360
   * properties. Refer to the <a href="https://stripe.com/docs/api#payment_intent_object">payment
1361
   * intent</a> object reference for more details.
1362
   */
1363
  public static PaymentIntent retrieve(String intent) throws StripeException {
1364
    return retrieve(intent, (Map<String, Object>) null, (RequestOptions) null);
1✔
1365
  }
1366

1367
  /**
1368
   * Retrieves the details of a PaymentIntent that has previously been created.
1369
   *
1370
   * <p>You can retrieve a PaymentIntent client-side using a publishable key when the {@code
1371
   * client_secret} is in the query string.
1372
   *
1373
   * <p>If you retrieve a PaymentIntent with a publishable key, it only returns a subset of
1374
   * properties. Refer to the <a href="https://stripe.com/docs/api#payment_intent_object">payment
1375
   * intent</a> object reference for more details.
1376
   */
1377
  public static PaymentIntent retrieve(String intent, RequestOptions options)
1378
      throws StripeException {
1379
    return retrieve(intent, (Map<String, Object>) null, options);
×
1380
  }
1381

1382
  /**
1383
   * Retrieves the details of a PaymentIntent that has previously been created.
1384
   *
1385
   * <p>You can retrieve a PaymentIntent client-side using a publishable key when the {@code
1386
   * client_secret} is in the query string.
1387
   *
1388
   * <p>If you retrieve a PaymentIntent with a publishable key, it only returns a subset of
1389
   * properties. Refer to the <a href="https://stripe.com/docs/api#payment_intent_object">payment
1390
   * intent</a> object reference for more details.
1391
   */
1392
  public static PaymentIntent retrieve(
1393
      String intent, Map<String, Object> params, RequestOptions options) throws StripeException {
1394
    String path = String.format("/v1/payment_intents/%s", ApiResource.urlEncodeId(intent));
1✔
1395
    ApiRequest request =
1✔
1396
        new ApiRequest(BaseAddress.API, ApiResource.RequestMethod.GET, path, params, options);
1397
    return getGlobalResponseGetter().request(request, PaymentIntent.class);
1✔
1398
  }
1399

1400
  /**
1401
   * Retrieves the details of a PaymentIntent that has previously been created.
1402
   *
1403
   * <p>You can retrieve a PaymentIntent client-side using a publishable key when the {@code
1404
   * client_secret} is in the query string.
1405
   *
1406
   * <p>If you retrieve a PaymentIntent with a publishable key, it only returns a subset of
1407
   * properties. Refer to the <a href="https://stripe.com/docs/api#payment_intent_object">payment
1408
   * intent</a> object reference for more details.
1409
   */
1410
  public static PaymentIntent retrieve(
1411
      String intent, PaymentIntentRetrieveParams params, RequestOptions options)
1412
      throws StripeException {
1413
    String path = String.format("/v1/payment_intents/%s", ApiResource.urlEncodeId(intent));
1✔
1414
    ApiResource.checkNullTypedParams(path, params);
1✔
1415
    ApiRequest request =
1✔
1416
        new ApiRequest(
1417
            BaseAddress.API,
1418
            ApiResource.RequestMethod.GET,
1419
            path,
1420
            ApiRequestParams.paramsToMap(params),
1✔
1421
            options);
1422
    return getGlobalResponseGetter().request(request, PaymentIntent.class);
1✔
1423
  }
1424

1425
  /**
1426
   * Search for PaymentIntents you’ve previously created using Stripe’s <a
1427
   * href="https://stripe.com/docs/search#search-query-language">Search Query Language</a>. Don’t
1428
   * use search in read-after-write flows where strict consistency is necessary. Under normal
1429
   * operating conditions, data is searchable in less than a minute. Occasionally, propagation of
1430
   * new or updated data can be up to an hour behind during outages. Search functionality is not
1431
   * available to merchants in India.
1432
   */
1433
  public static PaymentIntentSearchResult search(Map<String, Object> params)
1434
      throws StripeException {
1435
    return search(params, (RequestOptions) null);
×
1436
  }
1437

1438
  /**
1439
   * Search for PaymentIntents you’ve previously created using Stripe’s <a
1440
   * href="https://stripe.com/docs/search#search-query-language">Search Query Language</a>. Don’t
1441
   * use search in read-after-write flows where strict consistency is necessary. Under normal
1442
   * operating conditions, data is searchable in less than a minute. Occasionally, propagation of
1443
   * new or updated data can be up to an hour behind during outages. Search functionality is not
1444
   * available to merchants in India.
1445
   */
1446
  public static PaymentIntentSearchResult search(Map<String, Object> params, RequestOptions options)
1447
      throws StripeException {
1448
    String path = "/v1/payment_intents/search";
×
1449
    ApiRequest request =
×
1450
        new ApiRequest(BaseAddress.API, ApiResource.RequestMethod.GET, path, params, options);
1451
    return getGlobalResponseGetter().request(request, PaymentIntentSearchResult.class);
×
1452
  }
1453

1454
  /**
1455
   * Search for PaymentIntents you’ve previously created using Stripe’s <a
1456
   * href="https://stripe.com/docs/search#search-query-language">Search Query Language</a>. Don’t
1457
   * use search in read-after-write flows where strict consistency is necessary. Under normal
1458
   * operating conditions, data is searchable in less than a minute. Occasionally, propagation of
1459
   * new or updated data can be up to an hour behind during outages. Search functionality is not
1460
   * available to merchants in India.
1461
   */
1462
  public static PaymentIntentSearchResult search(PaymentIntentSearchParams params)
1463
      throws StripeException {
1464
    return search(params, (RequestOptions) null);
1✔
1465
  }
1466

1467
  /**
1468
   * Search for PaymentIntents you’ve previously created using Stripe’s <a
1469
   * href="https://stripe.com/docs/search#search-query-language">Search Query Language</a>. Don’t
1470
   * use search in read-after-write flows where strict consistency is necessary. Under normal
1471
   * operating conditions, data is searchable in less than a minute. Occasionally, propagation of
1472
   * new or updated data can be up to an hour behind during outages. Search functionality is not
1473
   * available to merchants in India.
1474
   */
1475
  public static PaymentIntentSearchResult search(
1476
      PaymentIntentSearchParams params, RequestOptions options) throws StripeException {
1477
    String path = "/v1/payment_intents/search";
1✔
1478
    ApiResource.checkNullTypedParams(path, params);
1✔
1479
    ApiRequest request =
1✔
1480
        new ApiRequest(
1481
            BaseAddress.API,
1482
            ApiResource.RequestMethod.GET,
1483
            path,
1484
            ApiRequestParams.paramsToMap(params),
1✔
1485
            options);
1486
    return getGlobalResponseGetter().request(request, PaymentIntentSearchResult.class);
1✔
1487
  }
1488

1489
  /**
1490
   * Updates properties on a PaymentIntent object without confirming.
1491
   *
1492
   * <p>Depending on which properties you update, you might need to confirm the PaymentIntent again.
1493
   * For example, updating the {@code payment_method} always requires you to confirm the
1494
   * PaymentIntent again. If you prefer to update and confirm at the same time, we recommend
1495
   * updating properties through the <a
1496
   * href="https://stripe.com/docs/api/payment_intents/confirm">confirm API</a> instead.
1497
   */
1498
  @Override
1499
  public PaymentIntent update(Map<String, Object> params) throws StripeException {
1500
    return update(params, (RequestOptions) null);
1✔
1501
  }
1502

1503
  /**
1504
   * Updates properties on a PaymentIntent object without confirming.
1505
   *
1506
   * <p>Depending on which properties you update, you might need to confirm the PaymentIntent again.
1507
   * For example, updating the {@code payment_method} always requires you to confirm the
1508
   * PaymentIntent again. If you prefer to update and confirm at the same time, we recommend
1509
   * updating properties through the <a
1510
   * href="https://stripe.com/docs/api/payment_intents/confirm">confirm API</a> instead.
1511
   */
1512
  @Override
1513
  public PaymentIntent update(Map<String, Object> params, RequestOptions options)
1514
      throws StripeException {
1515
    String path = String.format("/v1/payment_intents/%s", ApiResource.urlEncodeId(this.getId()));
1✔
1516
    ApiRequest request =
1✔
1517
        new ApiRequest(BaseAddress.API, ApiResource.RequestMethod.POST, path, params, options);
1518
    return getResponseGetter().request(request, PaymentIntent.class);
1✔
1519
  }
1520

1521
  /**
1522
   * Updates properties on a PaymentIntent object without confirming.
1523
   *
1524
   * <p>Depending on which properties you update, you might need to confirm the PaymentIntent again.
1525
   * For example, updating the {@code payment_method} always requires you to confirm the
1526
   * PaymentIntent again. If you prefer to update and confirm at the same time, we recommend
1527
   * updating properties through the <a
1528
   * href="https://stripe.com/docs/api/payment_intents/confirm">confirm API</a> instead.
1529
   */
1530
  public PaymentIntent update(PaymentIntentUpdateParams params) throws StripeException {
1531
    return update(params, (RequestOptions) null);
1✔
1532
  }
1533

1534
  /**
1535
   * Updates properties on a PaymentIntent object without confirming.
1536
   *
1537
   * <p>Depending on which properties you update, you might need to confirm the PaymentIntent again.
1538
   * For example, updating the {@code payment_method} always requires you to confirm the
1539
   * PaymentIntent again. If you prefer to update and confirm at the same time, we recommend
1540
   * updating properties through the <a
1541
   * href="https://stripe.com/docs/api/payment_intents/confirm">confirm API</a> instead.
1542
   */
1543
  public PaymentIntent update(PaymentIntentUpdateParams params, RequestOptions options)
1544
      throws StripeException {
1545
    String path = String.format("/v1/payment_intents/%s", ApiResource.urlEncodeId(this.getId()));
1✔
1546
    ApiResource.checkNullTypedParams(path, params);
1✔
1547
    ApiRequest request =
1✔
1548
        new ApiRequest(
1549
            BaseAddress.API,
1550
            ApiResource.RequestMethod.POST,
1551
            path,
1552
            ApiRequestParams.paramsToMap(params),
1✔
1553
            options);
1554
    return getResponseGetter().request(request, PaymentIntent.class);
1✔
1555
  }
1556

1557
  /** Verifies microdeposits on a PaymentIntent object. */
1558
  public PaymentIntent verifyMicrodeposits() throws StripeException {
1559
    return verifyMicrodeposits((Map<String, Object>) null, (RequestOptions) null);
×
1560
  }
1561

1562
  /** Verifies microdeposits on a PaymentIntent object. */
1563
  public PaymentIntent verifyMicrodeposits(RequestOptions options) throws StripeException {
1564
    return verifyMicrodeposits((Map<String, Object>) null, options);
×
1565
  }
1566

1567
  /** Verifies microdeposits on a PaymentIntent object. */
1568
  public PaymentIntent verifyMicrodeposits(Map<String, Object> params) throws StripeException {
1569
    return verifyMicrodeposits(params, (RequestOptions) null);
×
1570
  }
1571

1572
  /** Verifies microdeposits on a PaymentIntent object. */
1573
  public PaymentIntent verifyMicrodeposits(Map<String, Object> params, RequestOptions options)
1574
      throws StripeException {
1575
    String path =
×
1576
        String.format(
×
1577
            "/v1/payment_intents/%s/verify_microdeposits", ApiResource.urlEncodeId(this.getId()));
×
1578
    ApiRequest request =
×
1579
        new ApiRequest(BaseAddress.API, ApiResource.RequestMethod.POST, path, params, options);
1580
    return getResponseGetter().request(request, PaymentIntent.class);
×
1581
  }
1582

1583
  /** Verifies microdeposits on a PaymentIntent object. */
1584
  public PaymentIntent verifyMicrodeposits(PaymentIntentVerifyMicrodepositsParams params)
1585
      throws StripeException {
1586
    return verifyMicrodeposits(params, (RequestOptions) null);
1✔
1587
  }
1588

1589
  /** Verifies microdeposits on a PaymentIntent object. */
1590
  public PaymentIntent verifyMicrodeposits(
1591
      PaymentIntentVerifyMicrodepositsParams params, RequestOptions options)
1592
      throws StripeException {
1593
    String path =
1✔
1594
        String.format(
1✔
1595
            "/v1/payment_intents/%s/verify_microdeposits", ApiResource.urlEncodeId(this.getId()));
1✔
1596
    ApiResource.checkNullTypedParams(path, params);
1✔
1597
    ApiRequest request =
1✔
1598
        new ApiRequest(
1599
            BaseAddress.API,
1600
            ApiResource.RequestMethod.POST,
1601
            path,
1602
            ApiRequestParams.paramsToMap(params),
1✔
1603
            options);
1604
    return getResponseGetter().request(request, PaymentIntent.class);
1✔
1605
  }
1606

1607
  @Getter
1608
  @Setter
1609
  @EqualsAndHashCode(callSuper = false)
1610
  public static class AmountDetails extends StripeObject {
1✔
1611
    @SerializedName("tip")
1612
    Tip tip;
1613

1614
    @Getter
1615
    @Setter
1616
    @EqualsAndHashCode(callSuper = false)
1617
    public static class Tip extends StripeObject {
1✔
1618
      /** Portion of the amount that corresponds to a tip. */
1619
      @SerializedName("amount")
1620
      Long amount;
1621
    }
1622
  }
1623

1624
  @Getter
1625
  @Setter
1626
  @EqualsAndHashCode(callSuper = false)
1627
  public static class AsyncWorkflows extends StripeObject {
×
1628
    @SerializedName("inputs")
1629
    Inputs inputs;
1630

1631
    @Getter
1632
    @Setter
1633
    @EqualsAndHashCode(callSuper = false)
1634
    public static class Inputs extends StripeObject {
×
1635
      @SerializedName("tax")
1636
      Tax tax;
1637

1638
      @Getter
1639
      @Setter
1640
      @EqualsAndHashCode(callSuper = false)
1641
      public static class Tax extends StripeObject {
×
1642
        /** The <a href="https://stripe.com/docs/api/tax/calculations">TaxCalculation</a> id */
1643
        @SerializedName("calculation")
1644
        String calculation;
1645
      }
1646
    }
1647
  }
1648

1649
  @Getter
1650
  @Setter
1651
  @EqualsAndHashCode(callSuper = false)
1652
  public static class AutomaticPaymentMethods extends StripeObject {
×
1653
    /**
1654
     * Controls whether this PaymentIntent will accept redirect-based payment methods.
1655
     *
1656
     * <p>Redirect-based payment methods may require your customer to be redirected to a payment
1657
     * method's app or site for authentication or additional steps. To <a
1658
     * href="https://stripe.com/docs/api/payment_intents/confirm">confirm</a> this PaymentIntent,
1659
     * you may be required to provide a {@code return_url} to redirect customers back to your site
1660
     * after they authenticate or complete the payment.
1661
     *
1662
     * <p>One of {@code always}, or {@code never}.
1663
     */
1664
    @SerializedName("allow_redirects")
1665
    String allowRedirects;
1666

1667
    /** Automatically calculates compatible payment methods. */
1668
    @SerializedName("enabled")
1669
    Boolean enabled;
1670
  }
1671

1672
  @Getter
1673
  @Setter
1674
  @EqualsAndHashCode(callSuper = false)
1675
  public static class NextAction extends StripeObject {
1✔
1676
    @SerializedName("alipay_handle_redirect")
1677
    AlipayHandleRedirect alipayHandleRedirect;
1678

1679
    @SerializedName("boleto_display_details")
1680
    BoletoDisplayDetails boletoDisplayDetails;
1681

1682
    @SerializedName("card_await_notification")
1683
    CardAwaitNotification cardAwaitNotification;
1684

1685
    @SerializedName("cashapp_handle_redirect_or_display_qr_code")
1686
    CashappHandleRedirectOrDisplayQrCode cashappHandleRedirectOrDisplayQrCode;
1687

1688
    @SerializedName("display_bank_transfer_instructions")
1689
    DisplayBankTransferInstructions displayBankTransferInstructions;
1690

1691
    @SerializedName("konbini_display_details")
1692
    KonbiniDisplayDetails konbiniDisplayDetails;
1693

1694
    @SerializedName("multibanco_display_details")
1695
    MultibancoDisplayDetails multibancoDisplayDetails;
1696

1697
    @SerializedName("oxxo_display_details")
1698
    OxxoDisplayDetails oxxoDisplayDetails;
1699

1700
    @SerializedName("paynow_display_qr_code")
1701
    PaynowDisplayQrCode paynowDisplayQrCode;
1702

1703
    @SerializedName("pix_display_qr_code")
1704
    PixDisplayQrCode pixDisplayQrCode;
1705

1706
    @SerializedName("promptpay_display_qr_code")
1707
    PromptpayDisplayQrCode promptpayDisplayQrCode;
1708

1709
    @SerializedName("redirect_to_url")
1710
    RedirectToUrl redirectToUrl;
1711

1712
    @SerializedName("swish_handle_redirect_or_display_qr_code")
1713
    SwishHandleRedirectOrDisplayQrCode swishHandleRedirectOrDisplayQrCode;
1714

1715
    /**
1716
     * Type of the next action to perform, one of {@code redirect_to_url}, {@code use_stripe_sdk},
1717
     * {@code alipay_handle_redirect}, {@code oxxo_display_details}, or {@code
1718
     * verify_with_microdeposits}.
1719
     */
1720
    @SerializedName("type")
1721
    String type;
1722

1723
    /**
1724
     * When confirming a PaymentIntent with Stripe.js, Stripe.js depends on the contents of this
1725
     * dictionary to invoke authentication flows. The shape of the contents is subject to change and
1726
     * is only intended to be used by Stripe.js.
1727
     */
1728
    @SerializedName("use_stripe_sdk")
1729
    Map<String, Object> useStripeSdk;
1730

1731
    @SerializedName("verify_with_microdeposits")
1732
    VerifyWithMicrodeposits verifyWithMicrodeposits;
1733

1734
    @SerializedName("wechat_pay_display_qr_code")
1735
    WechatPayDisplayQrCode wechatPayDisplayQrCode;
1736

1737
    @SerializedName("wechat_pay_redirect_to_android_app")
1738
    WechatPayRedirectToAndroidApp wechatPayRedirectToAndroidApp;
1739

1740
    @SerializedName("wechat_pay_redirect_to_ios_app")
1741
    WechatPayRedirectToIosApp wechatPayRedirectToIosApp;
1742

1743
    @Getter
1744
    @Setter
1745
    @EqualsAndHashCode(callSuper = false)
1746
    public static class AlipayHandleRedirect extends StripeObject {
×
1747
      /**
1748
       * The native data to be used with Alipay SDK you must redirect your customer to in order to
1749
       * authenticate the payment in an Android App.
1750
       */
1751
      @SerializedName("native_data")
1752
      String nativeData;
1753

1754
      /**
1755
       * The native URL you must redirect your customer to in order to authenticate the payment in
1756
       * an iOS App.
1757
       */
1758
      @SerializedName("native_url")
1759
      String nativeUrl;
1760

1761
      /**
1762
       * If the customer does not exit their browser while authenticating, they will be redirected
1763
       * to this specified URL after completion.
1764
       */
1765
      @SerializedName("return_url")
1766
      String returnUrl;
1767

1768
      /** The URL you must redirect your customer to in order to authenticate the payment. */
1769
      @SerializedName("url")
1770
      String url;
1771
    }
1772

1773
    @Getter
1774
    @Setter
1775
    @EqualsAndHashCode(callSuper = false)
1776
    public static class BoletoDisplayDetails extends StripeObject {
×
1777
      /** The timestamp after which the boleto expires. */
1778
      @SerializedName("expires_at")
1779
      Long expiresAt;
1780

1781
      /**
1782
       * The URL to the hosted boleto voucher page, which allows customers to view the boleto
1783
       * voucher.
1784
       */
1785
      @SerializedName("hosted_voucher_url")
1786
      String hostedVoucherUrl;
1787

1788
      /** The boleto number. */
1789
      @SerializedName("number")
1790
      String number;
1791

1792
      /** The URL to the downloadable boleto voucher PDF. */
1793
      @SerializedName("pdf")
1794
      String pdf;
1795
    }
1796

1797
    @Getter
1798
    @Setter
1799
    @EqualsAndHashCode(callSuper = false)
1800
    public static class CardAwaitNotification extends StripeObject {
×
1801
      /**
1802
       * The time that payment will be attempted. If customer approval is required, they need to
1803
       * provide approval before this time.
1804
       */
1805
      @SerializedName("charge_attempt_at")
1806
      Long chargeAttemptAt;
1807

1808
      /**
1809
       * For payments greater than INR 15000, the customer must provide explicit approval of the
1810
       * payment with their bank. For payments of lower amount, no customer action is required.
1811
       */
1812
      @SerializedName("customer_approval_required")
1813
      Boolean customerApprovalRequired;
1814
    }
1815

1816
    @Getter
1817
    @Setter
1818
    @EqualsAndHashCode(callSuper = false)
1819
    public static class CashappHandleRedirectOrDisplayQrCode extends StripeObject {
×
1820
      /**
1821
       * The URL to the hosted Cash App Pay instructions page, which allows customers to view the QR
1822
       * code, and supports QR code refreshing on expiration.
1823
       */
1824
      @SerializedName("hosted_instructions_url")
1825
      String hostedInstructionsUrl;
1826

1827
      /** The url for mobile redirect based auth. */
1828
      @SerializedName("mobile_auth_url")
1829
      String mobileAuthUrl;
1830

1831
      @SerializedName("qr_code")
1832
      QrCode qrCode;
1833

1834
      @Getter
1835
      @Setter
1836
      @EqualsAndHashCode(callSuper = false)
1837
      public static class QrCode extends StripeObject {
×
1838
        /** The date (unix timestamp) when the QR code expires. */
1839
        @SerializedName("expires_at")
1840
        Long expiresAt;
1841

1842
        /** The image_url_png string used to render QR code. */
1843
        @SerializedName("image_url_png")
1844
        String imageUrlPng;
1845

1846
        /** The image_url_svg string used to render QR code. */
1847
        @SerializedName("image_url_svg")
1848
        String imageUrlSvg;
1849
      }
1850
    }
1851

1852
    @Getter
1853
    @Setter
1854
    @EqualsAndHashCode(callSuper = false)
1855
    public static class DisplayBankTransferInstructions extends StripeObject {
×
1856
      /** The remaining amount that needs to be transferred to complete the payment. */
1857
      @SerializedName("amount_remaining")
1858
      Long amountRemaining;
1859

1860
      /**
1861
       * Three-letter <a href="https://www.iso.org/iso-4217-currency-codes.html">ISO currency
1862
       * code</a>, in lowercase. Must be a <a href="https://stripe.com/docs/currencies">supported
1863
       * currency</a>.
1864
       */
1865
      @SerializedName("currency")
1866
      String currency;
1867

1868
      /** A list of financial addresses that can be used to fund the customer balance. */
1869
      @SerializedName("financial_addresses")
1870
      List<PaymentIntent.NextAction.DisplayBankTransferInstructions.FinancialAddress>
1871
          financialAddresses;
1872

1873
      /** A link to a hosted page that guides your customer through completing the transfer. */
1874
      @SerializedName("hosted_instructions_url")
1875
      String hostedInstructionsUrl;
1876

1877
      /**
1878
       * A string identifying this payment. Instruct your customer to include this code in the
1879
       * reference or memo field of their bank transfer.
1880
       */
1881
      @SerializedName("reference")
1882
      String reference;
1883

1884
      /**
1885
       * Type of bank transfer
1886
       *
1887
       * <p>One of {@code eu_bank_transfer}, {@code gb_bank_transfer}, {@code jp_bank_transfer},
1888
       * {@code mx_bank_transfer}, or {@code us_bank_transfer}.
1889
       */
1890
      @SerializedName("type")
1891
      String type;
1892

1893
      /** FinancialAddresses contain identifying information that resolves to a FinancialAccount. */
1894
      @Getter
1895
      @Setter
1896
      @EqualsAndHashCode(callSuper = false)
1897
      public static class FinancialAddress extends StripeObject {
×
1898
        /** ABA Records contain U.S. bank account details per the ABA format. */
1899
        @SerializedName("aba")
1900
        Aba aba;
1901

1902
        /** Iban Records contain E.U. bank account details per the SEPA format. */
1903
        @SerializedName("iban")
1904
        Iban iban;
1905

1906
        /** Sort Code Records contain U.K. bank account details per the sort code format. */
1907
        @SerializedName("sort_code")
1908
        SortCode sortCode;
1909

1910
        /** SPEI Records contain Mexico bank account details per the SPEI format. */
1911
        @SerializedName("spei")
1912
        Spei spei;
1913

1914
        /** The payment networks supported by this FinancialAddress. */
1915
        @SerializedName("supported_networks")
1916
        List<String> supportedNetworks;
1917

1918
        /** SWIFT Records contain U.S. bank account details per the SWIFT format. */
1919
        @SerializedName("swift")
1920
        Swift swift;
1921

1922
        /**
1923
         * The type of financial address
1924
         *
1925
         * <p>One of {@code aba}, {@code iban}, {@code sort_code}, {@code spei}, {@code swift}, or
1926
         * {@code zengin}.
1927
         */
1928
        @SerializedName("type")
1929
        String type;
1930

1931
        /** Zengin Records contain Japan bank account details per the Zengin format. */
1932
        @SerializedName("zengin")
1933
        Zengin zengin;
1934

1935
        /** ABA Records contain U.S. bank account details per the ABA format. */
1936
        @Getter
1937
        @Setter
1938
        @EqualsAndHashCode(callSuper = false)
1939
        public static class Aba extends StripeObject {
×
1940
          /** The ABA account number. */
1941
          @SerializedName("account_number")
1942
          String accountNumber;
1943

1944
          /** The bank name. */
1945
          @SerializedName("bank_name")
1946
          String bankName;
1947

1948
          /** The ABA routing number. */
1949
          @SerializedName("routing_number")
1950
          String routingNumber;
1951
        }
1952

1953
        /** Iban Records contain E.U. bank account details per the SEPA format. */
1954
        @Getter
1955
        @Setter
1956
        @EqualsAndHashCode(callSuper = false)
1957
        public static class Iban extends StripeObject {
×
1958
          /** The name of the person or business that owns the bank account. */
1959
          @SerializedName("account_holder_name")
1960
          String accountHolderName;
1961

1962
          /** The BIC/SWIFT code of the account. */
1963
          @SerializedName("bic")
1964
          String bic;
1965

1966
          /**
1967
           * Two-letter country code (<a href="https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2">ISO
1968
           * 3166-1 alpha-2</a>).
1969
           */
1970
          @SerializedName("country")
1971
          String country;
1972

1973
          /** The IBAN of the account. */
1974
          @SerializedName("iban")
1975
          String iban;
1976
        }
1977

1978
        /** Sort Code Records contain U.K. bank account details per the sort code format. */
1979
        @Getter
1980
        @Setter
1981
        @EqualsAndHashCode(callSuper = false)
1982
        public static class SortCode extends StripeObject {
×
1983
          /** The name of the person or business that owns the bank account. */
1984
          @SerializedName("account_holder_name")
1985
          String accountHolderName;
1986

1987
          /** The account number. */
1988
          @SerializedName("account_number")
1989
          String accountNumber;
1990

1991
          /** The six-digit sort code. */
1992
          @SerializedName("sort_code")
1993
          String sortCode;
1994
        }
1995

1996
        /** SPEI Records contain Mexico bank account details per the SPEI format. */
1997
        @Getter
1998
        @Setter
1999
        @EqualsAndHashCode(callSuper = false)
2000
        public static class Spei extends StripeObject {
×
2001
          /** The three-digit bank code. */
2002
          @SerializedName("bank_code")
2003
          String bankCode;
2004

2005
          /** The short banking institution name. */
2006
          @SerializedName("bank_name")
2007
          String bankName;
2008

2009
          /** The CLABE number. */
2010
          @SerializedName("clabe")
2011
          String clabe;
2012
        }
2013

2014
        /** SWIFT Records contain U.S. bank account details per the SWIFT format. */
2015
        @Getter
2016
        @Setter
2017
        @EqualsAndHashCode(callSuper = false)
2018
        public static class Swift extends StripeObject {
×
2019
          /** The account number. */
2020
          @SerializedName("account_number")
2021
          String accountNumber;
2022

2023
          /** The bank name. */
2024
          @SerializedName("bank_name")
2025
          String bankName;
2026

2027
          /** The SWIFT code. */
2028
          @SerializedName("swift_code")
2029
          String swiftCode;
2030
        }
2031

2032
        /** Zengin Records contain Japan bank account details per the Zengin format. */
2033
        @Getter
2034
        @Setter
2035
        @EqualsAndHashCode(callSuper = false)
2036
        public static class Zengin extends StripeObject {
×
2037
          /** The account holder name. */
2038
          @SerializedName("account_holder_name")
2039
          String accountHolderName;
2040

2041
          /** The account number. */
2042
          @SerializedName("account_number")
2043
          String accountNumber;
2044

2045
          /** The bank account type. In Japan, this can only be {@code futsu} or {@code toza}. */
2046
          @SerializedName("account_type")
2047
          String accountType;
2048

2049
          /** The bank code of the account. */
2050
          @SerializedName("bank_code")
2051
          String bankCode;
2052

2053
          /** The bank name of the account. */
2054
          @SerializedName("bank_name")
2055
          String bankName;
2056

2057
          /** The branch code of the account. */
2058
          @SerializedName("branch_code")
2059
          String branchCode;
2060

2061
          /** The branch name of the account. */
2062
          @SerializedName("branch_name")
2063
          String branchName;
2064
        }
2065
      }
2066
    }
2067

2068
    @Getter
2069
    @Setter
2070
    @EqualsAndHashCode(callSuper = false)
2071
    public static class KonbiniDisplayDetails extends StripeObject {
×
2072
      /** The timestamp at which the pending Konbini payment expires. */
2073
      @SerializedName("expires_at")
2074
      Long expiresAt;
2075

2076
      /**
2077
       * The URL for the Konbini payment instructions page, which allows customers to view and print
2078
       * a Konbini voucher.
2079
       */
2080
      @SerializedName("hosted_voucher_url")
2081
      String hostedVoucherUrl;
2082

2083
      @SerializedName("stores")
2084
      Stores stores;
2085

2086
      @Getter
2087
      @Setter
2088
      @EqualsAndHashCode(callSuper = false)
2089
      public static class Stores extends StripeObject {
×
2090
        /** FamilyMart instruction details. */
2091
        @SerializedName("familymart")
2092
        Familymart familymart;
2093

2094
        /** Lawson instruction details. */
2095
        @SerializedName("lawson")
2096
        Lawson lawson;
2097

2098
        /** Ministop instruction details. */
2099
        @SerializedName("ministop")
2100
        Ministop ministop;
2101

2102
        /** Seicomart instruction details. */
2103
        @SerializedName("seicomart")
2104
        Seicomart seicomart;
2105

2106
        @Getter
2107
        @Setter
2108
        @EqualsAndHashCode(callSuper = false)
2109
        public static class Familymart extends StripeObject {
×
2110
          /** The confirmation number. */
2111
          @SerializedName("confirmation_number")
2112
          String confirmationNumber;
2113

2114
          /** The payment code. */
2115
          @SerializedName("payment_code")
2116
          String paymentCode;
2117
        }
2118

2119
        @Getter
2120
        @Setter
2121
        @EqualsAndHashCode(callSuper = false)
2122
        public static class Lawson extends StripeObject {
×
2123
          /** The confirmation number. */
2124
          @SerializedName("confirmation_number")
2125
          String confirmationNumber;
2126

2127
          /** The payment code. */
2128
          @SerializedName("payment_code")
2129
          String paymentCode;
2130
        }
2131

2132
        @Getter
2133
        @Setter
2134
        @EqualsAndHashCode(callSuper = false)
2135
        public static class Ministop extends StripeObject {
×
2136
          /** The confirmation number. */
2137
          @SerializedName("confirmation_number")
2138
          String confirmationNumber;
2139

2140
          /** The payment code. */
2141
          @SerializedName("payment_code")
2142
          String paymentCode;
2143
        }
2144

2145
        @Getter
2146
        @Setter
2147
        @EqualsAndHashCode(callSuper = false)
2148
        public static class Seicomart extends StripeObject {
×
2149
          /** The confirmation number. */
2150
          @SerializedName("confirmation_number")
2151
          String confirmationNumber;
2152

2153
          /** The payment code. */
2154
          @SerializedName("payment_code")
2155
          String paymentCode;
2156
        }
2157
      }
2158
    }
2159

2160
    @Getter
2161
    @Setter
2162
    @EqualsAndHashCode(callSuper = false)
2163
    public static class MultibancoDisplayDetails extends StripeObject {
×
2164
      /** Entity number associated with this Multibanco payment. */
2165
      @SerializedName("entity")
2166
      String entity;
2167

2168
      /** The timestamp at which the Multibanco voucher expires. */
2169
      @SerializedName("expires_at")
2170
      Long expiresAt;
2171

2172
      /**
2173
       * The URL for the hosted Multibanco voucher page, which allows customers to view a Multibanco
2174
       * voucher.
2175
       */
2176
      @SerializedName("hosted_voucher_url")
2177
      String hostedVoucherUrl;
2178

2179
      /** Reference number associated with this Multibanco payment. */
2180
      @SerializedName("reference")
2181
      String reference;
2182
    }
2183

2184
    @Getter
2185
    @Setter
2186
    @EqualsAndHashCode(callSuper = false)
2187
    public static class OxxoDisplayDetails extends StripeObject {
×
2188
      /** The timestamp after which the OXXO voucher expires. */
2189
      @SerializedName("expires_after")
2190
      Long expiresAfter;
2191

2192
      /**
2193
       * The URL for the hosted OXXO voucher page, which allows customers to view and print an OXXO
2194
       * voucher.
2195
       */
2196
      @SerializedName("hosted_voucher_url")
2197
      String hostedVoucherUrl;
2198

2199
      /** OXXO reference number. */
2200
      @SerializedName("number")
2201
      String number;
2202
    }
2203

2204
    @Getter
2205
    @Setter
2206
    @EqualsAndHashCode(callSuper = false)
2207
    public static class PaynowDisplayQrCode extends StripeObject {
×
2208
      /**
2209
       * The raw data string used to generate QR code, it should be used together with QR code
2210
       * library.
2211
       */
2212
      @SerializedName("data")
2213
      String data;
2214

2215
      /**
2216
       * The URL to the hosted PayNow instructions page, which allows customers to view the PayNow
2217
       * QR code.
2218
       */
2219
      @SerializedName("hosted_instructions_url")
2220
      String hostedInstructionsUrl;
2221

2222
      /** The image_url_png string used to render QR code. */
2223
      @SerializedName("image_url_png")
2224
      String imageUrlPng;
2225

2226
      /** The image_url_svg string used to render QR code. */
2227
      @SerializedName("image_url_svg")
2228
      String imageUrlSvg;
2229
    }
2230

2231
    @Getter
2232
    @Setter
2233
    @EqualsAndHashCode(callSuper = false)
2234
    public static class PixDisplayQrCode extends StripeObject {
×
2235
      /**
2236
       * The raw data string used to generate QR code, it should be used together with QR code
2237
       * library.
2238
       */
2239
      @SerializedName("data")
2240
      String data;
2241

2242
      /** The date (unix timestamp) when the PIX expires. */
2243
      @SerializedName("expires_at")
2244
      Long expiresAt;
2245

2246
      /**
2247
       * The URL to the hosted pix instructions page, which allows customers to view the pix QR
2248
       * code.
2249
       */
2250
      @SerializedName("hosted_instructions_url")
2251
      String hostedInstructionsUrl;
2252

2253
      /** The image_url_png string used to render png QR code. */
2254
      @SerializedName("image_url_png")
2255
      String imageUrlPng;
2256

2257
      /** The image_url_svg string used to render svg QR code. */
2258
      @SerializedName("image_url_svg")
2259
      String imageUrlSvg;
2260
    }
2261

2262
    @Getter
2263
    @Setter
2264
    @EqualsAndHashCode(callSuper = false)
2265
    public static class PromptpayDisplayQrCode extends StripeObject {
×
2266
      /**
2267
       * The raw data string used to generate QR code, it should be used together with QR code
2268
       * library.
2269
       */
2270
      @SerializedName("data")
2271
      String data;
2272

2273
      /**
2274
       * The URL to the hosted PromptPay instructions page, which allows customers to view the
2275
       * PromptPay QR code.
2276
       */
2277
      @SerializedName("hosted_instructions_url")
2278
      String hostedInstructionsUrl;
2279

2280
      /** The PNG path used to render the QR code, can be used as the source in an HTML img tag. */
2281
      @SerializedName("image_url_png")
2282
      String imageUrlPng;
2283

2284
      /** The SVG path used to render the QR code, can be used as the source in an HTML img tag. */
2285
      @SerializedName("image_url_svg")
2286
      String imageUrlSvg;
2287
    }
2288

2289
    @Getter
2290
    @Setter
2291
    @EqualsAndHashCode(callSuper = false)
2292
    public static class RedirectToUrl extends StripeObject {
1✔
2293
      /**
2294
       * If the customer does not exit their browser while authenticating, they will be redirected
2295
       * to this specified URL after completion.
2296
       */
2297
      @SerializedName("return_url")
2298
      String returnUrl;
2299

2300
      /** The URL you must redirect your customer to in order to authenticate the payment. */
2301
      @SerializedName("url")
2302
      String url;
2303
    }
2304

2305
    @Getter
2306
    @Setter
2307
    @EqualsAndHashCode(callSuper = false)
2308
    public static class SwishHandleRedirectOrDisplayQrCode extends StripeObject {
×
2309
      /**
2310
       * The URL to the hosted Swish instructions page, which allows customers to view the QR code.
2311
       */
2312
      @SerializedName("hosted_instructions_url")
2313
      String hostedInstructionsUrl;
2314

2315
      /**
2316
       * The url for mobile redirect based auth (for internal use only and not typically available
2317
       * in standard API requests).
2318
       */
2319
      @SerializedName("mobile_auth_url")
2320
      String mobileAuthUrl;
2321

2322
      @SerializedName("qr_code")
2323
      QrCode qrCode;
2324

2325
      @Getter
2326
      @Setter
2327
      @EqualsAndHashCode(callSuper = false)
2328
      public static class QrCode extends StripeObject {
×
2329
        /**
2330
         * The raw data string used to generate QR code, it should be used together with QR code
2331
         * library.
2332
         */
2333
        @SerializedName("data")
2334
        String data;
2335

2336
        /** The image_url_png string used to render QR code. */
2337
        @SerializedName("image_url_png")
2338
        String imageUrlPng;
2339

2340
        /** The image_url_svg string used to render QR code. */
2341
        @SerializedName("image_url_svg")
2342
        String imageUrlSvg;
2343
      }
2344
    }
2345

2346
    @Getter
2347
    @Setter
2348
    @EqualsAndHashCode(callSuper = false)
2349
    public static class VerifyWithMicrodeposits extends StripeObject {
×
2350
      /** The timestamp when the microdeposits are expected to land. */
2351
      @SerializedName("arrival_date")
2352
      Long arrivalDate;
2353

2354
      /**
2355
       * The URL for the hosted verification page, which allows customers to verify their bank
2356
       * account.
2357
       */
2358
      @SerializedName("hosted_verification_url")
2359
      String hostedVerificationUrl;
2360

2361
      /**
2362
       * The type of the microdeposit sent to the customer. Used to distinguish between different
2363
       * verification methods.
2364
       *
2365
       * <p>One of {@code amounts}, or {@code descriptor_code}.
2366
       */
2367
      @SerializedName("microdeposit_type")
2368
      String microdepositType;
2369
    }
2370

2371
    @Getter
2372
    @Setter
2373
    @EqualsAndHashCode(callSuper = false)
2374
    public static class WechatPayDisplayQrCode extends StripeObject {
×
2375
      /** The data being used to generate QR code. */
2376
      @SerializedName("data")
2377
      String data;
2378

2379
      /**
2380
       * The URL to the hosted WeChat Pay instructions page, which allows customers to view the
2381
       * WeChat Pay QR code.
2382
       */
2383
      @SerializedName("hosted_instructions_url")
2384
      String hostedInstructionsUrl;
2385

2386
      /** The base64 image data for a pre-generated QR code. */
2387
      @SerializedName("image_data_url")
2388
      String imageDataUrl;
2389

2390
      /** The image_url_png string used to render QR code. */
2391
      @SerializedName("image_url_png")
2392
      String imageUrlPng;
2393

2394
      /** The image_url_svg string used to render QR code. */
2395
      @SerializedName("image_url_svg")
2396
      String imageUrlSvg;
2397
    }
2398

2399
    @Getter
2400
    @Setter
2401
    @EqualsAndHashCode(callSuper = false)
2402
    public static class WechatPayRedirectToAndroidApp extends StripeObject {
×
2403
      /** app_id is the APP ID registered on WeChat open platform. */
2404
      @SerializedName("app_id")
2405
      String appId;
2406

2407
      /** nonce_str is a random string. */
2408
      @SerializedName("nonce_str")
2409
      String nonceStr;
2410

2411
      /** an unique merchant ID assigned by WeChat Pay. */
2412
      @SerializedName("partner_id")
2413
      String partnerId;
2414

2415
      /** an unique trading ID assigned by WeChat Pay. */
2416
      @SerializedName("prepay_id")
2417
      String prepayId;
2418

2419
      /** A signature. */
2420
      @SerializedName("sign")
2421
      String sign;
2422

2423
      /** Specifies the current time in epoch format. */
2424
      @SerializedName("timestamp")
2425
      String timestamp;
2426

2427
      // package is a reserved word so we append an
2428
      // underscore to the private field and expose
2429
      // a custom getter and setter
2430
      @SerializedName("package")
2431
      String package_;
2432

2433
      public String getPackage() {
2434
        return this.package_;
×
2435
      }
2436

2437
      public void setPackage(String package_) {
2438
        this.package_ = package_;
×
2439
      }
×
2440
    }
2441

2442
    @Getter
2443
    @Setter
2444
    @EqualsAndHashCode(callSuper = false)
2445
    public static class WechatPayRedirectToIosApp extends StripeObject {
×
2446
      /** An universal link that redirect to WeChat Pay app. */
2447
      @SerializedName("native_url")
2448
      String nativeUrl;
2449
    }
2450
  }
2451

2452
  @Getter
2453
  @Setter
2454
  @EqualsAndHashCode(callSuper = false)
2455
  public static class PaymentDetails extends StripeObject {
×
2456
    @SerializedName("car_rental")
2457
    CarRental carRental;
2458

2459
    @SerializedName("event_details")
2460
    EventDetails eventDetails;
2461

2462
    @SerializedName("subscription")
2463
    Subscription subscription;
2464

2465
    @Getter
2466
    @Setter
2467
    @EqualsAndHashCode(callSuper = false)
2468
    public static class CarRental extends StripeObject {
×
2469
      @SerializedName("affiliate")
2470
      Affiliate affiliate;
2471

2472
      /** The booking number associated with the car rental. */
2473
      @SerializedName("booking_number")
2474
      String bookingNumber;
2475

2476
      /** Class code of the car. */
2477
      @SerializedName("car_class_code")
2478
      String carClassCode;
2479

2480
      /** Make of the car. */
2481
      @SerializedName("car_make")
2482
      String carMake;
2483

2484
      /** Model of the car. */
2485
      @SerializedName("car_model")
2486
      String carModel;
2487

2488
      /** The name of the rental car company. */
2489
      @SerializedName("company")
2490
      String company;
2491

2492
      /** The customer service phone number of the car rental company. */
2493
      @SerializedName("customer_service_phone_number")
2494
      String customerServicePhoneNumber;
2495

2496
      /** Number of days the car is being rented. */
2497
      @SerializedName("days_rented")
2498
      Long daysRented;
2499

2500
      @SerializedName("delivery")
2501
      Delivery delivery;
2502

2503
      /** The details of the drivers associated with the trip. */
2504
      @SerializedName("drivers")
2505
      List<PaymentIntent.PaymentDetails.CarRental.Driver> drivers;
2506

2507
      /** List of additional charges being billed. */
2508
      @SerializedName("extra_charges")
2509
      List<String> extraCharges;
2510

2511
      /** Indicates if the customer did not keep nor cancel their booking. */
2512
      @SerializedName("no_show")
2513
      Boolean noShow;
2514

2515
      @SerializedName("pickup_address")
2516
      com.stripe.model.Address pickupAddress;
2517

2518
      /** Car pick-up time. Measured in seconds since the Unix epoch. */
2519
      @SerializedName("pickup_at")
2520
      Long pickupAt;
2521

2522
      /** Rental rate. */
2523
      @SerializedName("rate_amount")
2524
      Long rateAmount;
2525

2526
      /**
2527
       * The frequency at which the rate amount is applied. One of {@code day}, {@code week} or
2528
       * {@code month}
2529
       */
2530
      @SerializedName("rate_interval")
2531
      String rateInterval;
2532

2533
      /** The full name of the person or entity renting the car. */
2534
      @SerializedName("renter_name")
2535
      String renterName;
2536

2537
      @SerializedName("return_address")
2538
      com.stripe.model.Address returnAddress;
2539

2540
      /** Car return time. Measured in seconds since the Unix epoch. */
2541
      @SerializedName("return_at")
2542
      Long returnAt;
2543

2544
      /** Indicates whether the goods or services are tax-exempt or tax is not collected. */
2545
      @SerializedName("tax_exempt")
2546
      Boolean taxExempt;
2547

2548
      @Getter
2549
      @Setter
2550
      @EqualsAndHashCode(callSuper = false)
2551
      public static class Affiliate extends StripeObject {
×
2552
        /** The name of the affiliate that originated the purchase. */
2553
        @SerializedName("name")
2554
        String name;
2555
      }
2556

2557
      @Getter
2558
      @Setter
2559
      @EqualsAndHashCode(callSuper = false)
2560
      public static class Delivery extends StripeObject {
×
2561
        /**
2562
         * The delivery method for the payment
2563
         *
2564
         * <p>One of {@code email}, {@code phone}, {@code pickup}, or {@code post}.
2565
         */
2566
        @SerializedName("mode")
2567
        String mode;
2568

2569
        @SerializedName("recipient")
2570
        Recipient recipient;
2571

2572
        @Getter
2573
        @Setter
2574
        @EqualsAndHashCode(callSuper = false)
2575
        public static class Recipient extends StripeObject {
×
2576
          /** The email of the recipient the ticket is delivered to. */
2577
          @SerializedName("email")
2578
          String email;
2579

2580
          /** The name of the recipient the ticket is delivered to. */
2581
          @SerializedName("name")
2582
          String name;
2583

2584
          /** The phone number of the recipient the ticket is delivered to. */
2585
          @SerializedName("phone")
2586
          String phone;
2587
        }
2588
      }
2589

2590
      @Getter
2591
      @Setter
2592
      @EqualsAndHashCode(callSuper = false)
2593
      public static class Driver extends StripeObject {
×
2594
        /** Full name of the driver on the reservation. */
2595
        @SerializedName("name")
2596
        String name;
2597
      }
2598
    }
2599

2600
    @Getter
2601
    @Setter
2602
    @EqualsAndHashCode(callSuper = false)
2603
    public static class EventDetails extends StripeObject {
×
2604
      /** Indicates if the tickets are digitally checked when entering the venue. */
2605
      @SerializedName("access_controlled_venue")
2606
      Boolean accessControlledVenue;
2607

2608
      @SerializedName("address")
2609
      com.stripe.model.Address address;
2610

2611
      @SerializedName("affiliate")
2612
      Affiliate affiliate;
2613

2614
      /** The name of the company. */
2615
      @SerializedName("company")
2616
      String company;
2617

2618
      @SerializedName("delivery")
2619
      Delivery delivery;
2620

2621
      /** Event end time. Measured in seconds since the Unix epoch. */
2622
      @SerializedName("ends_at")
2623
      Long endsAt;
2624

2625
      /** Type of the event entertainment (concert, sports event etc). */
2626
      @SerializedName("genre")
2627
      String genre;
2628

2629
      /** The name of the event. */
2630
      @SerializedName("name")
2631
      String name;
2632

2633
      /** Event start time. Measured in seconds since the Unix epoch. */
2634
      @SerializedName("starts_at")
2635
      Long startsAt;
2636

2637
      @Getter
2638
      @Setter
2639
      @EqualsAndHashCode(callSuper = false)
2640
      public static class Affiliate extends StripeObject {
×
2641
        /** The name of the affiliate that originated the purchase. */
2642
        @SerializedName("name")
2643
        String name;
2644
      }
2645

2646
      @Getter
2647
      @Setter
2648
      @EqualsAndHashCode(callSuper = false)
2649
      public static class Delivery extends StripeObject {
×
2650
        /**
2651
         * The delivery method for the payment
2652
         *
2653
         * <p>One of {@code email}, {@code phone}, {@code pickup}, or {@code post}.
2654
         */
2655
        @SerializedName("mode")
2656
        String mode;
2657

2658
        @SerializedName("recipient")
2659
        Recipient recipient;
2660

2661
        @Getter
2662
        @Setter
2663
        @EqualsAndHashCode(callSuper = false)
2664
        public static class Recipient extends StripeObject {
×
2665
          /** The email of the recipient the ticket is delivered to. */
2666
          @SerializedName("email")
2667
          String email;
2668

2669
          /** The name of the recipient the ticket is delivered to. */
2670
          @SerializedName("name")
2671
          String name;
2672

2673
          /** The phone number of the recipient the ticket is delivered to. */
2674
          @SerializedName("phone")
2675
          String phone;
2676
        }
2677
      }
2678
    }
2679

2680
    @Getter
2681
    @Setter
2682
    @EqualsAndHashCode(callSuper = false)
2683
    public static class Subscription extends StripeObject {
×
2684
      @SerializedName("affiliate")
2685
      Affiliate affiliate;
2686

2687
      /** Info whether the subscription will be auto renewed upon expiry. */
2688
      @SerializedName("auto_renewal")
2689
      Boolean autoRenewal;
2690

2691
      @SerializedName("billing_interval")
2692
      BillingInterval billingInterval;
2693

2694
      /** Subscription end time. Measured in seconds since the Unix epoch. */
2695
      @SerializedName("ends_at")
2696
      Long endsAt;
2697

2698
      /** Name of the product on subscription. e.g. Apple Music Subscription. */
2699
      @SerializedName("name")
2700
      String name;
2701

2702
      /** Subscription start time. Measured in seconds since the Unix epoch. */
2703
      @SerializedName("starts_at")
2704
      Long startsAt;
2705

2706
      @Getter
2707
      @Setter
2708
      @EqualsAndHashCode(callSuper = false)
2709
      public static class Affiliate extends StripeObject {
×
2710
        /** The name of the affiliate that originated the purchase. */
2711
        @SerializedName("name")
2712
        String name;
2713
      }
2714

2715
      @Getter
2716
      @Setter
2717
      @EqualsAndHashCode(callSuper = false)
2718
      public static class BillingInterval extends StripeObject {
×
2719
        /**
2720
         * The number of intervals, as an whole number greater than 0. Stripe multiplies this by the
2721
         * interval type to get the overall duration.
2722
         */
2723
        @SerializedName("count")
2724
        Long count;
2725

2726
        /**
2727
         * Specifies a type of interval unit. Either {@code day}, {@code week}, {@code month} or
2728
         * {@code year}.
2729
         *
2730
         * <p>One of {@code day}, {@code month}, {@code week}, or {@code year}.
2731
         */
2732
        @SerializedName("interval")
2733
        String interval;
2734
      }
2735
    }
2736
  }
2737

2738
  @Getter
2739
  @Setter
2740
  @EqualsAndHashCode(callSuper = false)
2741
  public static class PaymentMethodConfigurationDetails extends StripeObject implements HasId {
×
2742
    /** ID of the payment method configuration used. */
2743
    @Getter(onMethod_ = {@Override})
2744
    @SerializedName("id")
2745
    String id;
2746

2747
    /** ID of the parent payment method configuration used. */
2748
    @SerializedName("parent")
2749
    String parent;
2750
  }
2751

2752
  @Getter
2753
  @Setter
2754
  @EqualsAndHashCode(callSuper = false)
2755
  public static class PaymentMethodOptions extends StripeObject {
1✔
2756
    @SerializedName("acss_debit")
2757
    AcssDebit acssDebit;
2758

2759
    @SerializedName("affirm")
2760
    Affirm affirm;
2761

2762
    @SerializedName("afterpay_clearpay")
2763
    AfterpayClearpay afterpayClearpay;
2764

2765
    @SerializedName("alipay")
2766
    Alipay alipay;
2767

2768
    @SerializedName("amazon_pay")
2769
    AmazonPay amazonPay;
2770

2771
    @SerializedName("au_becs_debit")
2772
    AuBecsDebit auBecsDebit;
2773

2774
    @SerializedName("bacs_debit")
2775
    BacsDebit bacsDebit;
2776

2777
    @SerializedName("bancontact")
2778
    Bancontact bancontact;
2779

2780
    @SerializedName("blik")
2781
    Blik blik;
2782

2783
    @SerializedName("boleto")
2784
    Boleto boleto;
2785

2786
    @SerializedName("card")
2787
    Card card;
2788

2789
    @SerializedName("card_present")
2790
    CardPresent cardPresent;
2791

2792
    @SerializedName("cashapp")
2793
    Cashapp cashapp;
2794

2795
    @SerializedName("customer_balance")
2796
    CustomerBalance customerBalance;
2797

2798
    @SerializedName("eps")
2799
    Eps eps;
2800

2801
    @SerializedName("fpx")
2802
    Fpx fpx;
2803

2804
    @SerializedName("giropay")
2805
    Giropay giropay;
2806

2807
    @SerializedName("grabpay")
2808
    Grabpay grabpay;
2809

2810
    @SerializedName("ideal")
2811
    Ideal ideal;
2812

2813
    @SerializedName("interac_present")
2814
    InteracPresent interacPresent;
2815

2816
    @SerializedName("kakao_pay")
2817
    KakaoPay kakaoPay;
2818

2819
    @SerializedName("klarna")
2820
    Klarna klarna;
2821

2822
    @SerializedName("konbini")
2823
    Konbini konbini;
2824

2825
    @SerializedName("kr_card")
2826
    KrCard krCard;
2827

2828
    @SerializedName("link")
2829
    Link link;
2830

2831
    @SerializedName("mb_way")
2832
    MbWay mbWay;
2833

2834
    @SerializedName("mobilepay")
2835
    Mobilepay mobilepay;
2836

2837
    @SerializedName("multibanco")
2838
    Multibanco multibanco;
2839

2840
    @SerializedName("naver_pay")
2841
    NaverPay naverPay;
2842

2843
    @SerializedName("oxxo")
2844
    Oxxo oxxo;
2845

2846
    @SerializedName("p24")
2847
    P24 p24;
2848

2849
    @SerializedName("payco")
2850
    Payco payco;
2851

2852
    @SerializedName("paynow")
2853
    Paynow paynow;
2854

2855
    @SerializedName("paypal")
2856
    Paypal paypal;
2857

2858
    @SerializedName("payto")
2859
    Payto payto;
2860

2861
    @SerializedName("pix")
2862
    Pix pix;
2863

2864
    @SerializedName("promptpay")
2865
    Promptpay promptpay;
2866

2867
    @SerializedName("rechnung")
2868
    Rechnung rechnung;
2869

2870
    @SerializedName("revolut_pay")
2871
    RevolutPay revolutPay;
2872

2873
    @SerializedName("samsung_pay")
2874
    SamsungPay samsungPay;
2875

2876
    @SerializedName("sepa_debit")
2877
    SepaDebit sepaDebit;
2878

2879
    @SerializedName("sofort")
2880
    Sofort sofort;
2881

2882
    @SerializedName("swish")
2883
    Swish swish;
2884

2885
    @SerializedName("twint")
2886
    Twint twint;
2887

2888
    @SerializedName("us_bank_account")
2889
    UsBankAccount usBankAccount;
2890

2891
    @SerializedName("wechat_pay")
2892
    WechatPay wechatPay;
2893

2894
    @SerializedName("zip")
2895
    Zip zip;
2896

2897
    @Getter
2898
    @Setter
2899
    @EqualsAndHashCode(callSuper = false)
2900
    public static class AcssDebit extends StripeObject {
×
2901
      @SerializedName("mandate_options")
2902
      MandateOptions mandateOptions;
2903

2904
      /**
2905
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
2906
       *
2907
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
2908
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
2909
       * Customer after the PaymentIntent is confirmed and the customer completes any required
2910
       * actions. If you don't provide a Customer, you can still <a
2911
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
2912
       * Customer after the transaction completes.
2913
       *
2914
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
2915
       * and attaches a <a
2916
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
2917
       * payment method representing the card to the Customer instead.
2918
       *
2919
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
2920
       * with regional legislation and network rules, such as <a
2921
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
2922
       *
2923
       * <p>One of {@code none}, {@code off_session}, or {@code on_session}.
2924
       */
2925
      @SerializedName("setup_future_usage")
2926
      String setupFutureUsage;
2927

2928
      /**
2929
       * Bank account verification method.
2930
       *
2931
       * <p>One of {@code automatic}, {@code instant}, or {@code microdeposits}.
2932
       */
2933
      @SerializedName("verification_method")
2934
      String verificationMethod;
2935

2936
      @Getter
2937
      @Setter
2938
      @EqualsAndHashCode(callSuper = false)
2939
      public static class MandateOptions extends StripeObject {
×
2940
        /** A URL for custom mandate text. */
2941
        @SerializedName("custom_mandate_url")
2942
        String customMandateUrl;
2943

2944
        /**
2945
         * Description of the interval. Only required if the 'payment_schedule' parameter is
2946
         * 'interval' or 'combined'.
2947
         */
2948
        @SerializedName("interval_description")
2949
        String intervalDescription;
2950

2951
        /**
2952
         * Payment schedule for the mandate.
2953
         *
2954
         * <p>One of {@code combined}, {@code interval}, or {@code sporadic}.
2955
         */
2956
        @SerializedName("payment_schedule")
2957
        String paymentSchedule;
2958

2959
        /**
2960
         * Transaction type of the mandate.
2961
         *
2962
         * <p>One of {@code business}, or {@code personal}.
2963
         */
2964
        @SerializedName("transaction_type")
2965
        String transactionType;
2966
      }
2967
    }
2968

2969
    @Getter
2970
    @Setter
2971
    @EqualsAndHashCode(callSuper = false)
2972
    public static class Affirm extends StripeObject {
×
2973
      /**
2974
       * Controls when the funds will be captured from the customer's account.
2975
       *
2976
       * <p>Equal to {@code manual}.
2977
       */
2978
      @SerializedName("capture_method")
2979
      String captureMethod;
2980

2981
      /** Preferred language of the Affirm authorization page that the customer is redirected to. */
2982
      @SerializedName("preferred_locale")
2983
      String preferredLocale;
2984

2985
      /**
2986
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
2987
       *
2988
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
2989
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
2990
       * Customer after the PaymentIntent is confirmed and the customer completes any required
2991
       * actions. If you don't provide a Customer, you can still <a
2992
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
2993
       * Customer after the transaction completes.
2994
       *
2995
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
2996
       * and attaches a <a
2997
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
2998
       * payment method representing the card to the Customer instead.
2999
       *
3000
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3001
       * with regional legislation and network rules, such as <a
3002
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3003
       *
3004
       * <p>Equal to {@code none}.
3005
       */
3006
      @SerializedName("setup_future_usage")
3007
      String setupFutureUsage;
3008
    }
3009

3010
    @Getter
3011
    @Setter
3012
    @EqualsAndHashCode(callSuper = false)
3013
    public static class AfterpayClearpay extends StripeObject {
×
3014
      /**
3015
       * Controls when the funds will be captured from the customer's account.
3016
       *
3017
       * <p>Equal to {@code manual}.
3018
       */
3019
      @SerializedName("capture_method")
3020
      String captureMethod;
3021

3022
      /**
3023
       * An internal identifier or reference that this payment corresponds to. You must limit the
3024
       * identifier to 128 characters, and it can only contain letters, numbers, underscores,
3025
       * backslashes, and dashes. This field differs from the statement descriptor and item name.
3026
       */
3027
      @SerializedName("reference")
3028
      String reference;
3029

3030
      /**
3031
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3032
       *
3033
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3034
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3035
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3036
       * actions. If you don't provide a Customer, you can still <a
3037
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3038
       * Customer after the transaction completes.
3039
       *
3040
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3041
       * and attaches a <a
3042
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3043
       * payment method representing the card to the Customer instead.
3044
       *
3045
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3046
       * with regional legislation and network rules, such as <a
3047
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3048
       *
3049
       * <p>Equal to {@code none}.
3050
       */
3051
      @SerializedName("setup_future_usage")
3052
      String setupFutureUsage;
3053
    }
3054

3055
    @Getter
3056
    @Setter
3057
    @EqualsAndHashCode(callSuper = false)
3058
    public static class Alipay extends StripeObject {
×
3059
      /**
3060
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3061
       *
3062
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3063
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3064
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3065
       * actions. If you don't provide a Customer, you can still <a
3066
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3067
       * Customer after the transaction completes.
3068
       *
3069
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3070
       * and attaches a <a
3071
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3072
       * payment method representing the card to the Customer instead.
3073
       *
3074
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3075
       * with regional legislation and network rules, such as <a
3076
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3077
       *
3078
       * <p>One of {@code none}, or {@code off_session}.
3079
       */
3080
      @SerializedName("setup_future_usage")
3081
      String setupFutureUsage;
3082
    }
3083

3084
    @Getter
3085
    @Setter
3086
    @EqualsAndHashCode(callSuper = false)
3087
    public static class AmazonPay extends StripeObject {
×
3088
      /**
3089
       * Controls when the funds will be captured from the customer's account.
3090
       *
3091
       * <p>Equal to {@code manual}.
3092
       */
3093
      @SerializedName("capture_method")
3094
      String captureMethod;
3095

3096
      /**
3097
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3098
       *
3099
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3100
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3101
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3102
       * actions. If you don't provide a Customer, you can still <a
3103
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3104
       * Customer after the transaction completes.
3105
       *
3106
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3107
       * and attaches a <a
3108
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3109
       * payment method representing the card to the Customer instead.
3110
       *
3111
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3112
       * with regional legislation and network rules, such as <a
3113
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3114
       *
3115
       * <p>One of {@code none}, or {@code off_session}.
3116
       */
3117
      @SerializedName("setup_future_usage")
3118
      String setupFutureUsage;
3119
    }
3120

3121
    @Getter
3122
    @Setter
3123
    @EqualsAndHashCode(callSuper = false)
3124
    public static class AuBecsDebit extends StripeObject {
×
3125
      /**
3126
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3127
       *
3128
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3129
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3130
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3131
       * actions. If you don't provide a Customer, you can still <a
3132
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3133
       * Customer after the transaction completes.
3134
       *
3135
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3136
       * and attaches a <a
3137
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3138
       * payment method representing the card to the Customer instead.
3139
       *
3140
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3141
       * with regional legislation and network rules, such as <a
3142
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3143
       *
3144
       * <p>One of {@code none}, {@code off_session}, or {@code on_session}.
3145
       */
3146
      @SerializedName("setup_future_usage")
3147
      String setupFutureUsage;
3148
    }
3149

3150
    @Getter
3151
    @Setter
3152
    @EqualsAndHashCode(callSuper = false)
3153
    public static class BacsDebit extends StripeObject {
×
3154
      @SerializedName("mandate_options")
3155
      MandateOptions mandateOptions;
3156

3157
      /**
3158
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3159
       *
3160
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3161
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3162
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3163
       * actions. If you don't provide a Customer, you can still <a
3164
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3165
       * Customer after the transaction completes.
3166
       *
3167
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3168
       * and attaches a <a
3169
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3170
       * payment method representing the card to the Customer instead.
3171
       *
3172
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3173
       * with regional legislation and network rules, such as <a
3174
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3175
       *
3176
       * <p>One of {@code none}, {@code off_session}, or {@code on_session}.
3177
       */
3178
      @SerializedName("setup_future_usage")
3179
      String setupFutureUsage;
3180

3181
      @Getter
3182
      @Setter
3183
      @EqualsAndHashCode(callSuper = false)
3184
      public static class MandateOptions extends StripeObject {}
×
3185
    }
3186

3187
    @Getter
3188
    @Setter
3189
    @EqualsAndHashCode(callSuper = false)
3190
    public static class Bancontact extends StripeObject {
×
3191
      /**
3192
       * Preferred language of the Bancontact authorization page that the customer is redirected to.
3193
       *
3194
       * <p>One of {@code de}, {@code en}, {@code fr}, or {@code nl}.
3195
       */
3196
      @SerializedName("preferred_language")
3197
      String preferredLanguage;
3198

3199
      /**
3200
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3201
       *
3202
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3203
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3204
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3205
       * actions. If you don't provide a Customer, you can still <a
3206
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3207
       * Customer after the transaction completes.
3208
       *
3209
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3210
       * and attaches a <a
3211
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3212
       * payment method representing the card to the Customer instead.
3213
       *
3214
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3215
       * with regional legislation and network rules, such as <a
3216
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3217
       *
3218
       * <p>One of {@code none}, or {@code off_session}.
3219
       */
3220
      @SerializedName("setup_future_usage")
3221
      String setupFutureUsage;
3222
    }
3223

3224
    @Getter
3225
    @Setter
3226
    @EqualsAndHashCode(callSuper = false)
3227
    public static class Blik extends StripeObject {
×
3228
      /**
3229
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3230
       *
3231
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3232
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3233
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3234
       * actions. If you don't provide a Customer, you can still <a
3235
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3236
       * Customer after the transaction completes.
3237
       *
3238
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3239
       * and attaches a <a
3240
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3241
       * payment method representing the card to the Customer instead.
3242
       *
3243
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3244
       * with regional legislation and network rules, such as <a
3245
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3246
       *
3247
       * <p>Equal to {@code none}.
3248
       */
3249
      @SerializedName("setup_future_usage")
3250
      String setupFutureUsage;
3251
    }
3252

3253
    @Getter
3254
    @Setter
3255
    @EqualsAndHashCode(callSuper = false)
3256
    public static class Boleto extends StripeObject {
×
3257
      /**
3258
       * The number of calendar days before a Boleto voucher expires. For example, if you create a
3259
       * Boleto voucher on Monday and you set expires_after_days to 2, the Boleto voucher will
3260
       * expire on Wednesday at 23:59 America/Sao_Paulo time.
3261
       */
3262
      @SerializedName("expires_after_days")
3263
      Long expiresAfterDays;
3264

3265
      /**
3266
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3267
       *
3268
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3269
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3270
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3271
       * actions. If you don't provide a Customer, you can still <a
3272
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3273
       * Customer after the transaction completes.
3274
       *
3275
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3276
       * and attaches a <a
3277
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3278
       * payment method representing the card to the Customer instead.
3279
       *
3280
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3281
       * with regional legislation and network rules, such as <a
3282
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3283
       *
3284
       * <p>One of {@code none}, {@code off_session}, or {@code on_session}.
3285
       */
3286
      @SerializedName("setup_future_usage")
3287
      String setupFutureUsage;
3288
    }
3289

3290
    @Getter
3291
    @Setter
3292
    @EqualsAndHashCode(callSuper = false)
3293
    public static class Card extends StripeObject {
×
3294
      /**
3295
       * Controls when the funds will be captured from the customer's account.
3296
       *
3297
       * <p>Equal to {@code manual}.
3298
       */
3299
      @SerializedName("capture_method")
3300
      String captureMethod;
3301

3302
      /**
3303
       * Installment details for this payment (Mexico only).
3304
       *
3305
       * <p>For more information, see the <a
3306
       * href="https://stripe.com/docs/payments/installments">installments integration guide</a>.
3307
       */
3308
      @SerializedName("installments")
3309
      Installments installments;
3310

3311
      /** Configuration options for setting up an eMandate for cards issued in India. */
3312
      @SerializedName("mandate_options")
3313
      MandateOptions mandateOptions;
3314

3315
      /**
3316
       * Selected network to process this payment intent on. Depends on the available networks of
3317
       * the card attached to the payment intent. Can be only set confirm-time.
3318
       */
3319
      @SerializedName("network")
3320
      String network;
3321

3322
      /**
3323
       * Request ability to <a
3324
       * href="https://stripe.com/docs/payments/decremental-authorization">decrement the
3325
       * authorization</a> for this PaymentIntent.
3326
       *
3327
       * <p>One of {@code if_available}, or {@code never}.
3328
       */
3329
      @SerializedName("request_decremental_authorization")
3330
      String requestDecrementalAuthorization;
3331

3332
      /**
3333
       * Request ability to <a
3334
       * href="https://stripe.com/docs/payments/extended-authorization">capture beyond the standard
3335
       * authorization validity window</a> for this PaymentIntent.
3336
       *
3337
       * <p>One of {@code if_available}, or {@code never}.
3338
       */
3339
      @SerializedName("request_extended_authorization")
3340
      String requestExtendedAuthorization;
3341

3342
      /**
3343
       * Request ability to <a
3344
       * href="https://stripe.com/docs/payments/incremental-authorization">increment the
3345
       * authorization</a> for this PaymentIntent.
3346
       *
3347
       * <p>One of {@code if_available}, or {@code never}.
3348
       */
3349
      @SerializedName("request_incremental_authorization")
3350
      String requestIncrementalAuthorization;
3351

3352
      /**
3353
       * Request ability to make <a href="https://stripe.com/docs/payments/multicapture">multiple
3354
       * captures</a> for this PaymentIntent.
3355
       *
3356
       * <p>One of {@code if_available}, or {@code never}.
3357
       */
3358
      @SerializedName("request_multicapture")
3359
      String requestMulticapture;
3360

3361
      /**
3362
       * Request ability to <a href="https://stripe.com/docs/payments/overcapture">overcapture</a>
3363
       * for this PaymentIntent.
3364
       *
3365
       * <p>One of {@code if_available}, or {@code never}.
3366
       */
3367
      @SerializedName("request_overcapture")
3368
      String requestOvercapture;
3369

3370
      /**
3371
       * We strongly recommend that you rely on our SCA Engine to automatically prompt your
3372
       * customers for authentication based on risk level and <a
3373
       * href="https://stripe.com/docs/strong-customer-authentication">other requirements</a>.
3374
       * However, if you wish to request 3D Secure based on logic from your own fraud engine,
3375
       * provide this option. If not provided, this value defaults to {@code automatic}. Read our
3376
       * guide on <a
3377
       * href="https://stripe.com/docs/payments/3d-secure/authentication-flow#manual-three-ds">manually
3378
       * requesting 3D Secure</a> for more information on how this configuration interacts with
3379
       * Radar and our SCA Engine.
3380
       *
3381
       * <p>One of {@code any}, {@code automatic}, or {@code challenge}.
3382
       */
3383
      @SerializedName("request_three_d_secure")
3384
      String requestThreeDSecure;
3385

3386
      /**
3387
       * When enabled, using a card that is attached to a customer will require the CVC to be
3388
       * provided again (i.e. using the cvc_token parameter).
3389
       */
3390
      @SerializedName("require_cvc_recollection")
3391
      Boolean requireCvcRecollection;
3392

3393
      /**
3394
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3395
       *
3396
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3397
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3398
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3399
       * actions. If you don't provide a Customer, you can still <a
3400
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3401
       * Customer after the transaction completes.
3402
       *
3403
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3404
       * and attaches a <a
3405
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3406
       * payment method representing the card to the Customer instead.
3407
       *
3408
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3409
       * with regional legislation and network rules, such as <a
3410
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3411
       *
3412
       * <p>One of {@code none}, {@code off_session}, or {@code on_session}.
3413
       */
3414
      @SerializedName("setup_future_usage")
3415
      String setupFutureUsage;
3416

3417
      /**
3418
       * Provides information about a card payment that customers see on their statements.
3419
       * Concatenated with the Kana prefix (shortened Kana descriptor) or Kana statement descriptor
3420
       * that’s set on the account to form the complete statement descriptor. Maximum 22 characters.
3421
       * On card statements, the <em>concatenation</em> of both prefix and suffix (including
3422
       * separators) will appear truncated to 22 characters.
3423
       */
3424
      @SerializedName("statement_descriptor_suffix_kana")
3425
      String statementDescriptorSuffixKana;
3426

3427
      /**
3428
       * Provides information about a card payment that customers see on their statements.
3429
       * Concatenated with the Kanji prefix (shortened Kanji descriptor) or Kanji statement
3430
       * descriptor that’s set on the account to form the complete statement descriptor. Maximum 17
3431
       * characters. On card statements, the <em>concatenation</em> of both prefix and suffix
3432
       * (including separators) will appear truncated to 17 characters.
3433
       */
3434
      @SerializedName("statement_descriptor_suffix_kanji")
3435
      String statementDescriptorSuffixKanji;
3436

3437
      @SerializedName("statement_details")
3438
      StatementDetails statementDetails;
3439

3440
      @Getter
3441
      @Setter
3442
      @EqualsAndHashCode(callSuper = false)
3443
      public static class Installments extends StripeObject {
×
3444
        /** Installment plans that may be selected for this PaymentIntent. */
3445
        @SerializedName("available_plans")
3446
        List<PaymentIntent.PaymentMethodOptions.Card.Installments.AvailablePlan> availablePlans;
3447

3448
        /** Whether Installments are enabled for this PaymentIntent. */
3449
        @SerializedName("enabled")
3450
        Boolean enabled;
3451

3452
        /** Installment plan selected for this PaymentIntent. */
3453
        @SerializedName("plan")
3454
        Plan plan;
3455

3456
        @Getter
3457
        @Setter
3458
        @EqualsAndHashCode(callSuper = false)
3459
        public static class AvailablePlan extends StripeObject {
×
3460
          /**
3461
           * For {@code fixed_count} installment plans, this is the number of installment payments
3462
           * your customer will make to their credit card.
3463
           */
3464
          @SerializedName("count")
3465
          Long count;
3466

3467
          /**
3468
           * For {@code fixed_count} installment plans, this is the interval between installment
3469
           * payments your customer will make to their credit card. One of {@code month}.
3470
           */
3471
          @SerializedName("interval")
3472
          String interval;
3473

3474
          /** Type of installment plan, one of {@code fixed_count}. */
3475
          @SerializedName("type")
3476
          String type;
3477
        }
3478

3479
        @Getter
3480
        @Setter
3481
        @EqualsAndHashCode(callSuper = false)
3482
        public static class Plan extends StripeObject {
×
3483
          /**
3484
           * For {@code fixed_count} installment plans, this is the number of installment payments
3485
           * your customer will make to their credit card.
3486
           */
3487
          @SerializedName("count")
3488
          Long count;
3489

3490
          /**
3491
           * For {@code fixed_count} installment plans, this is the interval between installment
3492
           * payments your customer will make to their credit card. One of {@code month}.
3493
           */
3494
          @SerializedName("interval")
3495
          String interval;
3496

3497
          /** Type of installment plan, one of {@code fixed_count}. */
3498
          @SerializedName("type")
3499
          String type;
3500
        }
3501
      }
3502

3503
      @Getter
3504
      @Setter
3505
      @EqualsAndHashCode(callSuper = false)
3506
      public static class MandateOptions extends StripeObject {
×
3507
        /** Amount to be charged for future payments. */
3508
        @SerializedName("amount")
3509
        Long amount;
3510

3511
        /**
3512
         * One of {@code fixed} or {@code maximum}. If {@code fixed}, the {@code amount} param
3513
         * refers to the exact amount to be charged in future payments. If {@code maximum}, the
3514
         * amount charged can be up to the value passed for the {@code amount} param.
3515
         */
3516
        @SerializedName("amount_type")
3517
        String amountType;
3518

3519
        /**
3520
         * A description of the mandate or subscription that is meant to be displayed to the
3521
         * customer.
3522
         */
3523
        @SerializedName("description")
3524
        String description;
3525

3526
        /**
3527
         * End date of the mandate or subscription. If not provided, the mandate will be active
3528
         * until canceled. If provided, end date should be after start date.
3529
         */
3530
        @SerializedName("end_date")
3531
        Long endDate;
3532

3533
        /**
3534
         * Specifies payment frequency. One of {@code day}, {@code week}, {@code month}, {@code
3535
         * year}, or {@code sporadic}.
3536
         */
3537
        @SerializedName("interval")
3538
        String interval;
3539

3540
        /**
3541
         * The number of intervals between payments. For example, {@code interval=month} and {@code
3542
         * interval_count=3} indicates one payment every three months. Maximum of one year interval
3543
         * allowed (1 year, 12 months, or 52 weeks). This parameter is optional when {@code
3544
         * interval=sporadic}.
3545
         */
3546
        @SerializedName("interval_count")
3547
        Long intervalCount;
3548

3549
        /** Unique identifier for the mandate or subscription. */
3550
        @SerializedName("reference")
3551
        String reference;
3552

3553
        /**
3554
         * Start date of the mandate or subscription. Start date should not be lesser than
3555
         * yesterday.
3556
         */
3557
        @SerializedName("start_date")
3558
        Long startDate;
3559

3560
        /** Specifies the type of mandates supported. Possible values are {@code india}. */
3561
        @SerializedName("supported_types")
3562
        List<String> supportedTypes;
3563
      }
3564

3565
      @Getter
3566
      @Setter
3567
      @EqualsAndHashCode(callSuper = false)
3568
      public static class StatementDetails extends StripeObject {
×
3569
        @SerializedName("address")
3570
        com.stripe.model.PaymentIntent.PaymentMethodOptions.Card.StatementDetails.Address address;
3571

3572
        /** Phone number. */
3573
        @SerializedName("phone")
3574
        String phone;
3575

3576
        @Getter
3577
        @Setter
3578
        @EqualsAndHashCode(callSuper = false)
3579
        public static class Address extends StripeObject {
×
3580
          /** City, district, suburb, town, or village. */
3581
          @SerializedName("city")
3582
          String city;
3583

3584
          /**
3585
           * Two-letter country code (<a href="https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2">ISO
3586
           * 3166-1 alpha-2</a>).
3587
           */
3588
          @SerializedName("country")
3589
          String country;
3590

3591
          /** Address line 1 (e.g., street, PO Box, or company name). */
3592
          @SerializedName("line1")
3593
          String line1;
3594

3595
          /** Address line 2 (e.g., apartment, suite, unit, or building). */
3596
          @SerializedName("line2")
3597
          String line2;
3598

3599
          /** ZIP or postal code. */
3600
          @SerializedName("postal_code")
3601
          String postalCode;
3602

3603
          /** State, county, province, or region. */
3604
          @SerializedName("state")
3605
          String state;
3606
        }
3607
      }
3608
    }
3609

3610
    @Getter
3611
    @Setter
3612
    @EqualsAndHashCode(callSuper = false)
3613
    public static class CardPresent extends StripeObject {
×
3614
      /**
3615
       * Request ability to capture this payment beyond the standard <a
3616
       * href="https://stripe.com/docs/terminal/features/extended-authorizations#authorization-validity">authorization
3617
       * validity window.</a>
3618
       */
3619
      @SerializedName("request_extended_authorization")
3620
      Boolean requestExtendedAuthorization;
3621

3622
      /**
3623
       * Request ability to <a
3624
       * href="https://stripe.com/docs/terminal/features/incremental-authorizations">increment</a>
3625
       * this PaymentIntent if the combination of MCC and card brand is eligible. Check <a
3626
       * href="https://stripe.com/docs/api/charges/object#charge_object-payment_method_details-card_present-incremental_authorization_supported">incremental_authorization_supported</a>
3627
       * in the <a href="https://stripe.com/docs/api/payment_intents/confirm">Confirm</a> response
3628
       * to verify support.
3629
       */
3630
      @SerializedName("request_incremental_authorization_support")
3631
      Boolean requestIncrementalAuthorizationSupport;
3632

3633
      @SerializedName("routing")
3634
      Routing routing;
3635

3636
      @Getter
3637
      @Setter
3638
      @EqualsAndHashCode(callSuper = false)
3639
      public static class Routing extends StripeObject {
×
3640
        /**
3641
         * Requested routing priority
3642
         *
3643
         * <p>One of {@code domestic}, or {@code international}.
3644
         */
3645
        @SerializedName("requested_priority")
3646
        String requestedPriority;
3647
      }
3648
    }
3649

3650
    @Getter
3651
    @Setter
3652
    @EqualsAndHashCode(callSuper = false)
3653
    public static class Cashapp extends StripeObject {
×
3654
      /**
3655
       * Controls when the funds will be captured from the customer's account.
3656
       *
3657
       * <p>Equal to {@code manual}.
3658
       */
3659
      @SerializedName("capture_method")
3660
      String captureMethod;
3661

3662
      /**
3663
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3664
       *
3665
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3666
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3667
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3668
       * actions. If you don't provide a Customer, you can still <a
3669
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3670
       * Customer after the transaction completes.
3671
       *
3672
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3673
       * and attaches a <a
3674
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3675
       * payment method representing the card to the Customer instead.
3676
       *
3677
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3678
       * with regional legislation and network rules, such as <a
3679
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3680
       *
3681
       * <p>One of {@code none}, {@code off_session}, or {@code on_session}.
3682
       */
3683
      @SerializedName("setup_future_usage")
3684
      String setupFutureUsage;
3685
    }
3686

3687
    @Getter
3688
    @Setter
3689
    @EqualsAndHashCode(callSuper = false)
3690
    public static class CustomerBalance extends StripeObject {
×
3691
      @SerializedName("bank_transfer")
3692
      BankTransfer bankTransfer;
3693

3694
      /**
3695
       * The funding method type to be used when there are not enough funds in the customer balance.
3696
       * Permitted values include: {@code bank_transfer}.
3697
       *
3698
       * <p>Equal to {@code bank_transfer}.
3699
       */
3700
      @SerializedName("funding_type")
3701
      String fundingType;
3702

3703
      /**
3704
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3705
       *
3706
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3707
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3708
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3709
       * actions. If you don't provide a Customer, you can still <a
3710
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3711
       * Customer after the transaction completes.
3712
       *
3713
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3714
       * and attaches a <a
3715
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3716
       * payment method representing the card to the Customer instead.
3717
       *
3718
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3719
       * with regional legislation and network rules, such as <a
3720
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3721
       *
3722
       * <p>Equal to {@code none}.
3723
       */
3724
      @SerializedName("setup_future_usage")
3725
      String setupFutureUsage;
3726

3727
      @Getter
3728
      @Setter
3729
      @EqualsAndHashCode(callSuper = false)
3730
      public static class BankTransfer extends StripeObject {
×
3731
        @SerializedName("eu_bank_transfer")
3732
        EuBankTransfer euBankTransfer;
3733

3734
        /**
3735
         * List of address types that should be returned in the financial_addresses response. If not
3736
         * specified, all valid types will be returned.
3737
         *
3738
         * <p>Permitted values include: {@code sort_code}, {@code zengin}, {@code iban}, or {@code
3739
         * spei}.
3740
         */
3741
        @SerializedName("requested_address_types")
3742
        List<String> requestedAddressTypes;
3743

3744
        /**
3745
         * The bank transfer type that this PaymentIntent is allowed to use for funding Permitted
3746
         * values include: {@code eu_bank_transfer}, {@code gb_bank_transfer}, {@code
3747
         * jp_bank_transfer}, {@code mx_bank_transfer}, or {@code us_bank_transfer}.
3748
         *
3749
         * <p>One of {@code eu_bank_transfer}, {@code gb_bank_transfer}, {@code jp_bank_transfer},
3750
         * {@code mx_bank_transfer}, or {@code us_bank_transfer}.
3751
         */
3752
        @SerializedName("type")
3753
        String type;
3754

3755
        @Getter
3756
        @Setter
3757
        @EqualsAndHashCode(callSuper = false)
3758
        public static class EuBankTransfer extends StripeObject {
×
3759
          /**
3760
           * The desired country code of the bank account information. Permitted values include:
3761
           * {@code BE}, {@code DE}, {@code ES}, {@code FR}, {@code IE}, or {@code NL}.
3762
           *
3763
           * <p>One of {@code BE}, {@code DE}, {@code ES}, {@code FR}, {@code IE}, or {@code NL}.
3764
           */
3765
          @SerializedName("country")
3766
          String country;
3767
        }
3768
      }
3769
    }
3770

3771
    @Getter
3772
    @Setter
3773
    @EqualsAndHashCode(callSuper = false)
3774
    public static class Eps extends StripeObject {
×
3775
      /**
3776
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3777
       *
3778
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3779
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3780
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3781
       * actions. If you don't provide a Customer, you can still <a
3782
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3783
       * Customer after the transaction completes.
3784
       *
3785
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3786
       * and attaches a <a
3787
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3788
       * payment method representing the card to the Customer instead.
3789
       *
3790
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3791
       * with regional legislation and network rules, such as <a
3792
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3793
       *
3794
       * <p>Equal to {@code none}.
3795
       */
3796
      @SerializedName("setup_future_usage")
3797
      String setupFutureUsage;
3798
    }
3799

3800
    @Getter
3801
    @Setter
3802
    @EqualsAndHashCode(callSuper = false)
3803
    public static class Fpx extends StripeObject {
×
3804
      /**
3805
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3806
       *
3807
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3808
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3809
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3810
       * actions. If you don't provide a Customer, you can still <a
3811
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3812
       * Customer after the transaction completes.
3813
       *
3814
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3815
       * and attaches a <a
3816
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3817
       * payment method representing the card to the Customer instead.
3818
       *
3819
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3820
       * with regional legislation and network rules, such as <a
3821
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3822
       *
3823
       * <p>Equal to {@code none}.
3824
       */
3825
      @SerializedName("setup_future_usage")
3826
      String setupFutureUsage;
3827
    }
3828

3829
    @Getter
3830
    @Setter
3831
    @EqualsAndHashCode(callSuper = false)
3832
    public static class Giropay extends StripeObject {
×
3833
      /**
3834
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3835
       *
3836
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3837
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3838
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3839
       * actions. If you don't provide a Customer, you can still <a
3840
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3841
       * Customer after the transaction completes.
3842
       *
3843
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3844
       * and attaches a <a
3845
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3846
       * payment method representing the card to the Customer instead.
3847
       *
3848
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3849
       * with regional legislation and network rules, such as <a
3850
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3851
       *
3852
       * <p>Equal to {@code none}.
3853
       */
3854
      @SerializedName("setup_future_usage")
3855
      String setupFutureUsage;
3856
    }
3857

3858
    @Getter
3859
    @Setter
3860
    @EqualsAndHashCode(callSuper = false)
3861
    public static class Grabpay extends StripeObject {
×
3862
      /**
3863
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3864
       *
3865
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3866
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3867
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3868
       * actions. If you don't provide a Customer, you can still <a
3869
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3870
       * Customer after the transaction completes.
3871
       *
3872
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3873
       * and attaches a <a
3874
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3875
       * payment method representing the card to the Customer instead.
3876
       *
3877
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3878
       * with regional legislation and network rules, such as <a
3879
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3880
       *
3881
       * <p>Equal to {@code none}.
3882
       */
3883
      @SerializedName("setup_future_usage")
3884
      String setupFutureUsage;
3885
    }
3886

3887
    @Getter
3888
    @Setter
3889
    @EqualsAndHashCode(callSuper = false)
3890
    public static class Ideal extends StripeObject {
×
3891
      /**
3892
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3893
       *
3894
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3895
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3896
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3897
       * actions. If you don't provide a Customer, you can still <a
3898
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3899
       * Customer after the transaction completes.
3900
       *
3901
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3902
       * and attaches a <a
3903
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3904
       * payment method representing the card to the Customer instead.
3905
       *
3906
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3907
       * with regional legislation and network rules, such as <a
3908
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3909
       *
3910
       * <p>One of {@code none}, or {@code off_session}.
3911
       */
3912
      @SerializedName("setup_future_usage")
3913
      String setupFutureUsage;
3914
    }
3915

3916
    @Getter
3917
    @Setter
3918
    @EqualsAndHashCode(callSuper = false)
3919
    public static class InteracPresent extends StripeObject {}
×
3920

3921
    @Getter
3922
    @Setter
3923
    @EqualsAndHashCode(callSuper = false)
NEW
3924
    public static class KakaoPay extends StripeObject {
×
3925
      /**
3926
       * Controls when the funds will be captured from the customer's account.
3927
       *
3928
       * <p>Equal to {@code manual}.
3929
       */
3930
      @SerializedName("capture_method")
3931
      String captureMethod;
3932

3933
      /**
3934
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3935
       *
3936
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3937
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3938
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3939
       * actions. If you don't provide a Customer, you can still <a
3940
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3941
       * Customer after the transaction completes.
3942
       *
3943
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3944
       * and attaches a <a
3945
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3946
       * payment method representing the card to the Customer instead.
3947
       *
3948
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3949
       * with regional legislation and network rules, such as <a
3950
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3951
       *
3952
       * <p>One of {@code none}, or {@code off_session}.
3953
       */
3954
      @SerializedName("setup_future_usage")
3955
      String setupFutureUsage;
3956
    }
3957

3958
    @Getter
3959
    @Setter
3960
    @EqualsAndHashCode(callSuper = false)
3961
    public static class Klarna extends StripeObject {
×
3962
      /**
3963
       * Controls when the funds will be captured from the customer's account.
3964
       *
3965
       * <p>Equal to {@code manual}.
3966
       */
3967
      @SerializedName("capture_method")
3968
      String captureMethod;
3969

3970
      /** Preferred locale of the Klarna checkout page that the customer is redirected to. */
3971
      @SerializedName("preferred_locale")
3972
      String preferredLocale;
3973

3974
      /**
3975
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
3976
       *
3977
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
3978
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
3979
       * Customer after the PaymentIntent is confirmed and the customer completes any required
3980
       * actions. If you don't provide a Customer, you can still <a
3981
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
3982
       * Customer after the transaction completes.
3983
       *
3984
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
3985
       * and attaches a <a
3986
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
3987
       * payment method representing the card to the Customer instead.
3988
       *
3989
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
3990
       * with regional legislation and network rules, such as <a
3991
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
3992
       *
3993
       * <p>Equal to {@code none}.
3994
       */
3995
      @SerializedName("setup_future_usage")
3996
      String setupFutureUsage;
3997
    }
3998

3999
    @Getter
4000
    @Setter
4001
    @EqualsAndHashCode(callSuper = false)
4002
    public static class Konbini extends StripeObject {
×
4003
      /**
4004
       * An optional 10 to 11 digit numeric-only string determining the confirmation code at
4005
       * applicable convenience stores.
4006
       */
4007
      @SerializedName("confirmation_number")
4008
      String confirmationNumber;
4009

4010
      /**
4011
       * The number of calendar days (between 1 and 60) after which Konbini payment instructions
4012
       * will expire. For example, if a PaymentIntent is confirmed with Konbini and {@code
4013
       * expires_after_days} set to 2 on Monday JST, the instructions will expire on Wednesday
4014
       * 23:59:59 JST.
4015
       */
4016
      @SerializedName("expires_after_days")
4017
      Long expiresAfterDays;
4018

4019
      /**
4020
       * The timestamp at which the Konbini payment instructions will expire. Only one of {@code
4021
       * expires_after_days} or {@code expires_at} may be set.
4022
       */
4023
      @SerializedName("expires_at")
4024
      Long expiresAt;
4025

4026
      /**
4027
       * A product descriptor of up to 22 characters, which will appear to customers at the
4028
       * convenience store.
4029
       */
4030
      @SerializedName("product_description")
4031
      String productDescription;
4032

4033
      /**
4034
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4035
       *
4036
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4037
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4038
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4039
       * actions. If you don't provide a Customer, you can still <a
4040
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4041
       * Customer after the transaction completes.
4042
       *
4043
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4044
       * and attaches a <a
4045
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4046
       * payment method representing the card to the Customer instead.
4047
       *
4048
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4049
       * with regional legislation and network rules, such as <a
4050
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4051
       *
4052
       * <p>Equal to {@code none}.
4053
       */
4054
      @SerializedName("setup_future_usage")
4055
      String setupFutureUsage;
4056
    }
4057

4058
    @Getter
4059
    @Setter
4060
    @EqualsAndHashCode(callSuper = false)
NEW
4061
    public static class KrCard extends StripeObject {
×
4062
      /**
4063
       * Controls when the funds will be captured from the customer's account.
4064
       *
4065
       * <p>Equal to {@code manual}.
4066
       */
4067
      @SerializedName("capture_method")
4068
      String captureMethod;
4069

4070
      /**
4071
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4072
       *
4073
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4074
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4075
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4076
       * actions. If you don't provide a Customer, you can still <a
4077
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4078
       * Customer after the transaction completes.
4079
       *
4080
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4081
       * and attaches a <a
4082
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4083
       * payment method representing the card to the Customer instead.
4084
       *
4085
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4086
       * with regional legislation and network rules, such as <a
4087
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4088
       *
4089
       * <p>One of {@code none}, or {@code off_session}.
4090
       */
4091
      @SerializedName("setup_future_usage")
4092
      String setupFutureUsage;
4093
    }
4094

4095
    @Getter
4096
    @Setter
4097
    @EqualsAndHashCode(callSuper = false)
4098
    public static class Link extends StripeObject {
×
4099
      /**
4100
       * Controls when the funds will be captured from the customer's account.
4101
       *
4102
       * <p>Equal to {@code manual}.
4103
       */
4104
      @SerializedName("capture_method")
4105
      String captureMethod;
4106

4107
      /** [Deprecated] This is a legacy parameter that no longer has any function. */
4108
      @SerializedName("persistent_token")
4109
      @Deprecated
4110
      String persistentToken;
4111

4112
      /**
4113
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4114
       *
4115
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4116
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4117
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4118
       * actions. If you don't provide a Customer, you can still <a
4119
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4120
       * Customer after the transaction completes.
4121
       *
4122
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4123
       * and attaches a <a
4124
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4125
       * payment method representing the card to the Customer instead.
4126
       *
4127
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4128
       * with regional legislation and network rules, such as <a
4129
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4130
       *
4131
       * <p>One of {@code none}, or {@code off_session}.
4132
       */
4133
      @SerializedName("setup_future_usage")
4134
      String setupFutureUsage;
4135
    }
4136

4137
    @Getter
4138
    @Setter
4139
    @EqualsAndHashCode(callSuper = false)
4140
    public static class MbWay extends StripeObject {
×
4141
      /**
4142
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4143
       *
4144
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4145
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4146
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4147
       * actions. If you don't provide a Customer, you can still <a
4148
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4149
       * Customer after the transaction completes.
4150
       *
4151
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4152
       * and attaches a <a
4153
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4154
       * payment method representing the card to the Customer instead.
4155
       *
4156
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4157
       * with regional legislation and network rules, such as <a
4158
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4159
       *
4160
       * <p>Equal to {@code none}.
4161
       */
4162
      @SerializedName("setup_future_usage")
4163
      String setupFutureUsage;
4164
    }
4165

4166
    @Getter
4167
    @Setter
4168
    @EqualsAndHashCode(callSuper = false)
4169
    public static class Mobilepay extends StripeObject {
×
4170
      /**
4171
       * Controls when the funds will be captured from the customer's account.
4172
       *
4173
       * <p>Equal to {@code manual}.
4174
       */
4175
      @SerializedName("capture_method")
4176
      String captureMethod;
4177

4178
      /**
4179
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4180
       *
4181
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4182
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4183
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4184
       * actions. If you don't provide a Customer, you can still <a
4185
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4186
       * Customer after the transaction completes.
4187
       *
4188
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4189
       * and attaches a <a
4190
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4191
       * payment method representing the card to the Customer instead.
4192
       *
4193
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4194
       * with regional legislation and network rules, such as <a
4195
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4196
       *
4197
       * <p>Equal to {@code none}.
4198
       */
4199
      @SerializedName("setup_future_usage")
4200
      String setupFutureUsage;
4201
    }
4202

4203
    @Getter
4204
    @Setter
4205
    @EqualsAndHashCode(callSuper = false)
4206
    public static class Multibanco extends StripeObject {
×
4207
      /**
4208
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4209
       *
4210
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4211
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4212
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4213
       * actions. If you don't provide a Customer, you can still <a
4214
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4215
       * Customer after the transaction completes.
4216
       *
4217
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4218
       * and attaches a <a
4219
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4220
       * payment method representing the card to the Customer instead.
4221
       *
4222
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4223
       * with regional legislation and network rules, such as <a
4224
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4225
       *
4226
       * <p>Equal to {@code none}.
4227
       */
4228
      @SerializedName("setup_future_usage")
4229
      String setupFutureUsage;
4230
    }
4231

4232
    @Getter
4233
    @Setter
4234
    @EqualsAndHashCode(callSuper = false)
NEW
4235
    public static class NaverPay extends StripeObject {
×
4236
      /**
4237
       * Controls when the funds will be captured from the customer's account.
4238
       *
4239
       * <p>Equal to {@code manual}.
4240
       */
4241
      @SerializedName("capture_method")
4242
      String captureMethod;
4243
    }
4244

4245
    @Getter
4246
    @Setter
4247
    @EqualsAndHashCode(callSuper = false)
4248
    public static class Oxxo extends StripeObject {
×
4249
      /**
4250
       * The number of calendar days before an OXXO invoice expires. For example, if you create an
4251
       * OXXO invoice on Monday and you set expires_after_days to 2, the OXXO invoice will expire on
4252
       * Wednesday at 23:59 America/Mexico_City time.
4253
       */
4254
      @SerializedName("expires_after_days")
4255
      Long expiresAfterDays;
4256

4257
      /**
4258
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4259
       *
4260
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4261
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4262
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4263
       * actions. If you don't provide a Customer, you can still <a
4264
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4265
       * Customer after the transaction completes.
4266
       *
4267
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4268
       * and attaches a <a
4269
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4270
       * payment method representing the card to the Customer instead.
4271
       *
4272
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4273
       * with regional legislation and network rules, such as <a
4274
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4275
       *
4276
       * <p>Equal to {@code none}.
4277
       */
4278
      @SerializedName("setup_future_usage")
4279
      String setupFutureUsage;
4280
    }
4281

4282
    @Getter
4283
    @Setter
4284
    @EqualsAndHashCode(callSuper = false)
4285
    public static class P24 extends StripeObject {
×
4286
      /**
4287
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4288
       *
4289
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4290
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4291
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4292
       * actions. If you don't provide a Customer, you can still <a
4293
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4294
       * Customer after the transaction completes.
4295
       *
4296
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4297
       * and attaches a <a
4298
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4299
       * payment method representing the card to the Customer instead.
4300
       *
4301
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4302
       * with regional legislation and network rules, such as <a
4303
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4304
       *
4305
       * <p>Equal to {@code none}.
4306
       */
4307
      @SerializedName("setup_future_usage")
4308
      String setupFutureUsage;
4309
    }
4310

4311
    @Getter
4312
    @Setter
4313
    @EqualsAndHashCode(callSuper = false)
NEW
4314
    public static class Payco extends StripeObject {
×
4315
      /**
4316
       * Controls when the funds will be captured from the customer's account.
4317
       *
4318
       * <p>Equal to {@code manual}.
4319
       */
4320
      @SerializedName("capture_method")
4321
      String captureMethod;
4322
    }
4323

4324
    @Getter
4325
    @Setter
4326
    @EqualsAndHashCode(callSuper = false)
4327
    public static class Paynow extends StripeObject {
×
4328
      /**
4329
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4330
       *
4331
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4332
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4333
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4334
       * actions. If you don't provide a Customer, you can still <a
4335
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4336
       * Customer after the transaction completes.
4337
       *
4338
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4339
       * and attaches a <a
4340
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4341
       * payment method representing the card to the Customer instead.
4342
       *
4343
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4344
       * with regional legislation and network rules, such as <a
4345
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4346
       *
4347
       * <p>Equal to {@code none}.
4348
       */
4349
      @SerializedName("setup_future_usage")
4350
      String setupFutureUsage;
4351
    }
4352

4353
    @Getter
4354
    @Setter
4355
    @EqualsAndHashCode(callSuper = false)
4356
    public static class Paypal extends StripeObject {
×
4357
      /**
4358
       * Controls when the funds will be captured from the customer's account.
4359
       *
4360
       * <p>Equal to {@code manual}.
4361
       */
4362
      @SerializedName("capture_method")
4363
      String captureMethod;
4364

4365
      /** The line items purchased by the customer. */
4366
      @SerializedName("line_items")
4367
      List<PaymentIntent.PaymentMethodOptions.Paypal.LineItem> lineItems;
4368

4369
      /** Preferred locale of the PayPal checkout page that the customer is redirected to. */
4370
      @SerializedName("preferred_locale")
4371
      String preferredLocale;
4372

4373
      /**
4374
       * A reference of the PayPal transaction visible to customer which is mapped to PayPal's
4375
       * invoice ID. This must be a globally unique ID if you have configured in your PayPal
4376
       * settings to block multiple payments per invoice ID.
4377
       */
4378
      @SerializedName("reference")
4379
      String reference;
4380

4381
      /**
4382
       * A reference of the PayPal transaction visible to customer which is mapped to PayPal's
4383
       * invoice ID. This must be a globally unique ID if you have configured in your PayPal
4384
       * settings to block multiple payments per invoice ID.
4385
       */
4386
      @SerializedName("reference_id")
4387
      String referenceId;
4388

4389
      /**
4390
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4391
       *
4392
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4393
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4394
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4395
       * actions. If you don't provide a Customer, you can still <a
4396
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4397
       * Customer after the transaction completes.
4398
       *
4399
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4400
       * and attaches a <a
4401
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4402
       * payment method representing the card to the Customer instead.
4403
       *
4404
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4405
       * with regional legislation and network rules, such as <a
4406
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4407
       *
4408
       * <p>One of {@code none}, or {@code off_session}.
4409
       */
4410
      @SerializedName("setup_future_usage")
4411
      String setupFutureUsage;
4412

4413
      /**
4414
       * The Stripe connected account IDs of the sellers on the platform for this transaction
4415
       * (optional). Only allowed when <a
4416
       * href="https://stripe.com/docs/connect/separate-charges-and-transfers">separate charges and
4417
       * transfers</a> are used.
4418
       */
4419
      @SerializedName("subsellers")
4420
      List<String> subsellers;
4421

4422
      @Getter
4423
      @Setter
4424
      @EqualsAndHashCode(callSuper = false)
NEW
4425
      public static class LineItem extends StripeObject {
×
4426
        /**
4427
         * Type of the line item.
4428
         *
4429
         * <p>One of {@code digital_goods}, {@code donation}, or {@code physical_goods}.
4430
         */
4431
        @SerializedName("category")
4432
        String category;
4433

4434
        /** Description of the line item. */
4435
        @SerializedName("description")
4436
        String description;
4437

4438
        /** Descriptive name of the line item. */
4439
        @SerializedName("name")
4440
        String name;
4441

4442
        /** Quantity of the line item. Cannot be a negative number. */
4443
        @SerializedName("quantity")
4444
        Long quantity;
4445

4446
        /** Client facing stock keeping unit, article number or similar. */
4447
        @SerializedName("sku")
4448
        String sku;
4449

4450
        /**
4451
         * The Stripe account ID of the connected account that sells the item. This is only needed
4452
         * when using <a
4453
         * href="https://docs.stripe.com/connect/separate-charges-and-transfers">Separate Charges
4454
         * and Transfers</a>.
4455
         */
4456
        @SerializedName("sold_by")
4457
        String soldBy;
4458

4459
        @SerializedName("tax")
4460
        Tax tax;
4461

4462
        /** Price for a single unit of the line item in minor units. Cannot be a negative number. */
4463
        @SerializedName("unit_amount")
4464
        Long unitAmount;
4465

4466
        @Getter
4467
        @Setter
4468
        @EqualsAndHashCode(callSuper = false)
NEW
4469
        public static class Tax extends StripeObject {
×
4470
          /**
4471
           * The tax for a single unit of the line item in minor units. Cannot be a negative number.
4472
           */
4473
          @SerializedName("amount")
4474
          Long amount;
4475

4476
          /**
4477
           * The tax behavior for the line item.
4478
           *
4479
           * <p>One of {@code exclusive}, or {@code inclusive}.
4480
           */
4481
          @SerializedName("behavior")
4482
          String behavior;
4483
        }
4484
      }
4485
    }
4486

4487
    @Getter
4488
    @Setter
4489
    @EqualsAndHashCode(callSuper = false)
4490
    public static class Payto extends StripeObject {
×
4491
      @SerializedName("mandate_options")
4492
      MandateOptions mandateOptions;
4493

4494
      /**
4495
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4496
       *
4497
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4498
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4499
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4500
       * actions. If you don't provide a Customer, you can still <a
4501
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4502
       * Customer after the transaction completes.
4503
       *
4504
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4505
       * and attaches a <a
4506
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4507
       * payment method representing the card to the Customer instead.
4508
       *
4509
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4510
       * with regional legislation and network rules, such as <a
4511
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4512
       *
4513
       * <p>One of {@code none}, or {@code off_session}.
4514
       */
4515
      @SerializedName("setup_future_usage")
4516
      String setupFutureUsage;
4517

4518
      @Getter
4519
      @Setter
4520
      @EqualsAndHashCode(callSuper = false)
4521
      public static class MandateOptions extends StripeObject {
×
4522
        /**
4523
         * Amount that will be collected. It is required when {@code amount_type} is {@code fixed}.
4524
         */
4525
        @SerializedName("amount")
4526
        Long amount;
4527

4528
        /**
4529
         * The type of amount that will be collected. The amount charged must be exact or up to the
4530
         * value of {@code amount} param for {@code fixed} or {@code maximum} type respectively.
4531
         *
4532
         * <p>One of {@code fixed}, or {@code maximum}.
4533
         */
4534
        @SerializedName("amount_type")
4535
        String amountType;
4536

4537
        /**
4538
         * Date, in YYYY-MM-DD format, after which payments will not be collected. Defaults to no
4539
         * end date.
4540
         */
4541
        @SerializedName("end_date")
4542
        String endDate;
4543

4544
        /**
4545
         * The periodicity at which payments will be collected.
4546
         *
4547
         * <p>One of {@code adhoc}, {@code annual}, {@code daily}, {@code fortnightly}, {@code
4548
         * monthly}, {@code quarterly}, {@code semi_annual}, or {@code weekly}.
4549
         */
4550
        @SerializedName("payment_schedule")
4551
        String paymentSchedule;
4552

4553
        /**
4554
         * The number of payments that will be made during a payment period. Defaults to 1 except
4555
         * for when {@code payment_schedule} is {@code adhoc}. In that case, it defaults to no
4556
         * limit.
4557
         */
4558
        @SerializedName("payments_per_period")
4559
        Long paymentsPerPeriod;
4560

4561
        /**
4562
         * The purpose for which payments are made. Defaults to retail.
4563
         *
4564
         * <p>One of {@code dependant_support}, {@code government}, {@code loan}, {@code mortgage},
4565
         * {@code other}, {@code pension}, {@code personal}, {@code retail}, {@code salary}, {@code
4566
         * tax}, or {@code utility}.
4567
         */
4568
        @SerializedName("purpose")
4569
        String purpose;
4570
      }
4571
    }
4572

4573
    @Getter
4574
    @Setter
4575
    @EqualsAndHashCode(callSuper = false)
4576
    public static class Pix extends StripeObject {
×
4577
      /** The number of seconds (between 10 and 1209600) after which Pix payment will expire. */
4578
      @SerializedName("expires_after_seconds")
4579
      Long expiresAfterSeconds;
4580

4581
      /** The timestamp at which the Pix expires. */
4582
      @SerializedName("expires_at")
4583
      Long expiresAt;
4584

4585
      /**
4586
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4587
       *
4588
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4589
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4590
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4591
       * actions. If you don't provide a Customer, you can still <a
4592
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4593
       * Customer after the transaction completes.
4594
       *
4595
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4596
       * and attaches a <a
4597
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4598
       * payment method representing the card to the Customer instead.
4599
       *
4600
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4601
       * with regional legislation and network rules, such as <a
4602
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4603
       *
4604
       * <p>Equal to {@code none}.
4605
       */
4606
      @SerializedName("setup_future_usage")
4607
      String setupFutureUsage;
4608
    }
4609

4610
    @Getter
4611
    @Setter
4612
    @EqualsAndHashCode(callSuper = false)
4613
    public static class Promptpay extends StripeObject {
×
4614
      /**
4615
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4616
       *
4617
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4618
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4619
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4620
       * actions. If you don't provide a Customer, you can still <a
4621
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4622
       * Customer after the transaction completes.
4623
       *
4624
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4625
       * and attaches a <a
4626
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4627
       * payment method representing the card to the Customer instead.
4628
       *
4629
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4630
       * with regional legislation and network rules, such as <a
4631
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4632
       *
4633
       * <p>Equal to {@code none}.
4634
       */
4635
      @SerializedName("setup_future_usage")
4636
      String setupFutureUsage;
4637
    }
4638

4639
    @Getter
4640
    @Setter
4641
    @EqualsAndHashCode(callSuper = false)
4642
    public static class Rechnung extends StripeObject {}
×
4643

4644
    @Getter
4645
    @Setter
4646
    @EqualsAndHashCode(callSuper = false)
4647
    public static class RevolutPay extends StripeObject {
×
4648
      /**
4649
       * Controls when the funds will be captured from the customer's account.
4650
       *
4651
       * <p>Equal to {@code manual}.
4652
       */
4653
      @SerializedName("capture_method")
4654
      String captureMethod;
4655

4656
      /**
4657
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4658
       *
4659
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4660
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4661
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4662
       * actions. If you don't provide a Customer, you can still <a
4663
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4664
       * Customer after the transaction completes.
4665
       *
4666
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4667
       * and attaches a <a
4668
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4669
       * payment method representing the card to the Customer instead.
4670
       *
4671
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4672
       * with regional legislation and network rules, such as <a
4673
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4674
       *
4675
       * <p>One of {@code none}, or {@code off_session}.
4676
       */
4677
      @SerializedName("setup_future_usage")
4678
      String setupFutureUsage;
4679
    }
4680

4681
    @Getter
4682
    @Setter
4683
    @EqualsAndHashCode(callSuper = false)
NEW
4684
    public static class SamsungPay extends StripeObject {
×
4685
      /**
4686
       * Controls when the funds will be captured from the customer's account.
4687
       *
4688
       * <p>Equal to {@code manual}.
4689
       */
4690
      @SerializedName("capture_method")
4691
      String captureMethod;
4692
    }
4693

4694
    @Getter
4695
    @Setter
4696
    @EqualsAndHashCode(callSuper = false)
4697
    public static class SepaDebit extends StripeObject {
×
4698
      @SerializedName("mandate_options")
4699
      MandateOptions mandateOptions;
4700

4701
      /**
4702
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4703
       *
4704
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4705
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4706
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4707
       * actions. If you don't provide a Customer, you can still <a
4708
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4709
       * Customer after the transaction completes.
4710
       *
4711
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4712
       * and attaches a <a
4713
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4714
       * payment method representing the card to the Customer instead.
4715
       *
4716
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4717
       * with regional legislation and network rules, such as <a
4718
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4719
       *
4720
       * <p>One of {@code none}, {@code off_session}, or {@code on_session}.
4721
       */
4722
      @SerializedName("setup_future_usage")
4723
      String setupFutureUsage;
4724

4725
      @Getter
4726
      @Setter
4727
      @EqualsAndHashCode(callSuper = false)
4728
      public static class MandateOptions extends StripeObject {}
×
4729
    }
4730

4731
    @Getter
4732
    @Setter
4733
    @EqualsAndHashCode(callSuper = false)
4734
    public static class Sofort extends StripeObject {
×
4735
      /**
4736
       * Preferred language of the SOFORT authorization page that the customer is redirected to.
4737
       *
4738
       * <p>One of {@code de}, {@code en}, {@code es}, {@code fr}, {@code it}, {@code nl}, or {@code
4739
       * pl}.
4740
       */
4741
      @SerializedName("preferred_language")
4742
      String preferredLanguage;
4743

4744
      /**
4745
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4746
       *
4747
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4748
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4749
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4750
       * actions. If you don't provide a Customer, you can still <a
4751
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4752
       * Customer after the transaction completes.
4753
       *
4754
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4755
       * and attaches a <a
4756
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4757
       * payment method representing the card to the Customer instead.
4758
       *
4759
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4760
       * with regional legislation and network rules, such as <a
4761
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4762
       *
4763
       * <p>One of {@code none}, or {@code off_session}.
4764
       */
4765
      @SerializedName("setup_future_usage")
4766
      String setupFutureUsage;
4767
    }
4768

4769
    @Getter
4770
    @Setter
4771
    @EqualsAndHashCode(callSuper = false)
4772
    public static class Swish extends StripeObject {
×
4773
      /** The order ID displayed in the Swish app after the payment is authorized. */
4774
      @SerializedName("reference")
4775
      String reference;
4776

4777
      /**
4778
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4779
       *
4780
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4781
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4782
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4783
       * actions. If you don't provide a Customer, you can still <a
4784
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4785
       * Customer after the transaction completes.
4786
       *
4787
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4788
       * and attaches a <a
4789
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4790
       * payment method representing the card to the Customer instead.
4791
       *
4792
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4793
       * with regional legislation and network rules, such as <a
4794
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4795
       *
4796
       * <p>Equal to {@code none}.
4797
       */
4798
      @SerializedName("setup_future_usage")
4799
      String setupFutureUsage;
4800
    }
4801

4802
    @Getter
4803
    @Setter
4804
    @EqualsAndHashCode(callSuper = false)
4805
    public static class Twint extends StripeObject {
×
4806
      /**
4807
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4808
       *
4809
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4810
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4811
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4812
       * actions. If you don't provide a Customer, you can still <a
4813
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4814
       * Customer after the transaction completes.
4815
       *
4816
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4817
       * and attaches a <a
4818
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4819
       * payment method representing the card to the Customer instead.
4820
       *
4821
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4822
       * with regional legislation and network rules, such as <a
4823
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4824
       *
4825
       * <p>Equal to {@code none}.
4826
       */
4827
      @SerializedName("setup_future_usage")
4828
      String setupFutureUsage;
4829
    }
4830

4831
    @Getter
4832
    @Setter
4833
    @EqualsAndHashCode(callSuper = false)
4834
    public static class UsBankAccount extends StripeObject {
×
4835
      @SerializedName("financial_connections")
4836
      FinancialConnections financialConnections;
4837

4838
      @SerializedName("mandate_options")
4839
      MandateOptions mandateOptions;
4840

4841
      /**
4842
       * Preferred transaction settlement speed
4843
       *
4844
       * <p>One of {@code fastest}, or {@code standard}.
4845
       */
4846
      @SerializedName("preferred_settlement_speed")
4847
      String preferredSettlementSpeed;
4848

4849
      /**
4850
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4851
       *
4852
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4853
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4854
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4855
       * actions. If you don't provide a Customer, you can still <a
4856
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4857
       * Customer after the transaction completes.
4858
       *
4859
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4860
       * and attaches a <a
4861
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4862
       * payment method representing the card to the Customer instead.
4863
       *
4864
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4865
       * with regional legislation and network rules, such as <a
4866
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4867
       *
4868
       * <p>One of {@code none}, {@code off_session}, or {@code on_session}.
4869
       */
4870
      @SerializedName("setup_future_usage")
4871
      String setupFutureUsage;
4872

4873
      /**
4874
       * Bank account verification method.
4875
       *
4876
       * <p>One of {@code automatic}, {@code instant}, or {@code microdeposits}.
4877
       */
4878
      @SerializedName("verification_method")
4879
      String verificationMethod;
4880

4881
      @Getter
4882
      @Setter
4883
      @EqualsAndHashCode(callSuper = false)
4884
      public static class FinancialConnections extends StripeObject {
×
4885
        @SerializedName("filters")
4886
        Filters filters;
4887

4888
        @SerializedName("manual_entry")
4889
        ManualEntry manualEntry;
4890

4891
        /**
4892
         * The list of permissions to request. The {@code payment_method} permission must be
4893
         * included.
4894
         */
4895
        @SerializedName("permissions")
4896
        List<String> permissions;
4897

4898
        /** Data features requested to be retrieved upon account creation. */
4899
        @SerializedName("prefetch")
4900
        List<String> prefetch;
4901

4902
        /**
4903
         * For webview integrations only. Upon completing OAuth login in the native browser, the
4904
         * user will be redirected to this URL to return to your app.
4905
         */
4906
        @SerializedName("return_url")
4907
        String returnUrl;
4908

4909
        @Getter
4910
        @Setter
4911
        @EqualsAndHashCode(callSuper = false)
4912
        public static class Filters extends StripeObject {
×
4913
          /**
4914
           * The account subcategories to use to filter for possible accounts to link. Valid
4915
           * subcategories are {@code checking} and {@code savings}.
4916
           */
4917
          @SerializedName("account_subcategories")
4918
          List<String> accountSubcategories;
4919

4920
          /** The institution to use to filter for possible accounts to link. */
4921
          @SerializedName("institution")
4922
          String institution;
4923
        }
4924

4925
        @Getter
4926
        @Setter
4927
        @EqualsAndHashCode(callSuper = false)
4928
        public static class ManualEntry extends StripeObject {
×
4929
          /**
4930
           * Settings for configuring manual entry of account details.
4931
           *
4932
           * <p>One of {@code automatic}, or {@code custom}.
4933
           */
4934
          @SerializedName("mode")
4935
          String mode;
4936
        }
4937
      }
4938

4939
      @Getter
4940
      @Setter
4941
      @EqualsAndHashCode(callSuper = false)
4942
      public static class MandateOptions extends StripeObject {
×
4943
        /**
4944
         * Mandate collection method
4945
         *
4946
         * <p>Equal to {@code paper}.
4947
         */
4948
        @SerializedName("collection_method")
4949
        String collectionMethod;
4950
      }
4951
    }
4952

4953
    @Getter
4954
    @Setter
4955
    @EqualsAndHashCode(callSuper = false)
4956
    public static class WechatPay extends StripeObject {
×
4957
      /** The app ID registered with WeChat Pay. Only required when client is ios or android. */
4958
      @SerializedName("app_id")
4959
      String appId;
4960

4961
      /**
4962
       * The client type that the end customer will pay from
4963
       *
4964
       * <p>One of {@code android}, {@code ios}, or {@code web}.
4965
       */
4966
      @SerializedName("client")
4967
      String client;
4968

4969
      /**
4970
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
4971
       *
4972
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
4973
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
4974
       * Customer after the PaymentIntent is confirmed and the customer completes any required
4975
       * actions. If you don't provide a Customer, you can still <a
4976
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
4977
       * Customer after the transaction completes.
4978
       *
4979
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
4980
       * and attaches a <a
4981
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
4982
       * payment method representing the card to the Customer instead.
4983
       *
4984
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
4985
       * with regional legislation and network rules, such as <a
4986
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
4987
       *
4988
       * <p>Equal to {@code none}.
4989
       */
4990
      @SerializedName("setup_future_usage")
4991
      String setupFutureUsage;
4992
    }
4993

4994
    @Getter
4995
    @Setter
4996
    @EqualsAndHashCode(callSuper = false)
4997
    public static class Zip extends StripeObject {
×
4998
      /**
4999
       * Indicates that you intend to make future payments with this PaymentIntent's payment method.
5000
       *
5001
       * <p>If you provide a Customer with the PaymentIntent, you can use this parameter to <a
5002
       * href="https://stripe.com/payments/save-during-payment">attach the payment method</a> to the
5003
       * Customer after the PaymentIntent is confirmed and the customer completes any required
5004
       * actions. If you don't provide a Customer, you can still <a
5005
       * href="https://stripe.com/api/payment_methods/attach">attach</a> the payment method to a
5006
       * Customer after the transaction completes.
5007
       *
5008
       * <p>If the payment method is {@code card_present} and isn't a digital wallet, Stripe creates
5009
       * and attaches a <a
5010
       * href="https://stripe.com/api/charges/object#charge_object-payment_method_details-card_present-generated_card">generated_card</a>
5011
       * payment method representing the card to the Customer instead.
5012
       *
5013
       * <p>When processing card payments, Stripe uses {@code setup_future_usage} to help you comply
5014
       * with regional legislation and network rules, such as <a
5015
       * href="https://stripe.com/strong-customer-authentication">SCA</a>.
5016
       *
5017
       * <p>Equal to {@code none}.
5018
       */
5019
      @SerializedName("setup_future_usage")
5020
      String setupFutureUsage;
5021
    }
5022
  }
5023

5024
  @Getter
5025
  @Setter
5026
  @EqualsAndHashCode(callSuper = false)
5027
  public static class Processing extends StripeObject {
×
5028
    @SerializedName("card")
5029
    Card card;
5030

5031
    /**
5032
     * Type of the payment method for which payment is in {@code processing} state, one of {@code
5033
     * card}.
5034
     */
5035
    @SerializedName("type")
5036
    String type;
5037

5038
    @Getter
5039
    @Setter
5040
    @EqualsAndHashCode(callSuper = false)
5041
    public static class Card extends StripeObject {
×
5042
      @SerializedName("customer_notification")
5043
      CustomerNotification customerNotification;
5044

5045
      @Getter
5046
      @Setter
5047
      @EqualsAndHashCode(callSuper = false)
5048
      public static class CustomerNotification extends StripeObject {
×
5049
        /**
5050
         * Whether customer approval has been requested for this payment. For payments greater than
5051
         * INR 15000 or mandate amount, the customer must provide explicit approval of the payment
5052
         * with their bank.
5053
         */
5054
        @SerializedName("approval_requested")
5055
        Boolean approvalRequested;
5056

5057
        /** If customer approval is required, they need to provide approval before this time. */
5058
        @SerializedName("completes_at")
5059
        Long completesAt;
5060
      }
5061
    }
5062
  }
5063

5064
  @Getter
5065
  @Setter
5066
  @EqualsAndHashCode(callSuper = false)
5067
  public static class TransferData extends StripeObject {
1✔
5068
    /**
5069
     * Amount intended to be collected by this PaymentIntent. A positive integer representing how
5070
     * much to charge in the <a href="https://stripe.com/docs/currencies#zero-decimal">smallest
5071
     * currency unit</a> (e.g., 100 cents to charge $1.00 or 100 to charge ¥100, a zero-decimal
5072
     * currency). The minimum amount is $0.50 US or <a
5073
     * href="https://stripe.com/docs/currencies#minimum-and-maximum-charge-amounts">equivalent in
5074
     * charge currency</a>. The amount value supports up to eight digits (e.g., a value of 99999999
5075
     * for a USD charge of $999,999.99).
5076
     */
5077
    @SerializedName("amount")
5078
    Long amount;
5079

5080
    /**
5081
     * The account (if any) that the payment is attributed to for tax reporting, and where funds
5082
     * from the payment are transferred to after payment success.
5083
     */
5084
    @SerializedName("destination")
5085
    @Getter(lombok.AccessLevel.NONE)
5086
    @Setter(lombok.AccessLevel.NONE)
5087
    ExpandableField<Account> destination;
5088

5089
    /** Get ID of expandable {@code destination} object. */
5090
    public String getDestination() {
5091
      return (this.destination != null) ? this.destination.getId() : null;
1✔
5092
    }
5093

5094
    public void setDestination(String id) {
5095
      this.destination = ApiResource.setExpandableFieldId(id, this.destination);
×
5096
    }
×
5097

5098
    /** Get expanded {@code destination}. */
5099
    public Account getDestinationObject() {
5100
      return (this.destination != null) ? this.destination.getExpanded() : null;
1✔
5101
    }
5102

5103
    public void setDestinationObject(Account expandableObject) {
5104
      this.destination = new ExpandableField<Account>(expandableObject.getId(), expandableObject);
×
5105
    }
×
5106
  }
5107

5108
  @Override
5109
  public void setResponseGetter(StripeResponseGetter responseGetter) {
5110
    super.setResponseGetter(responseGetter);
1✔
5111
    trySetResponseGetter(amountDetails, responseGetter);
1✔
5112
    trySetResponseGetter(application, responseGetter);
1✔
5113
    trySetResponseGetter(asyncWorkflows, responseGetter);
1✔
5114
    trySetResponseGetter(automaticPaymentMethods, responseGetter);
1✔
5115
    trySetResponseGetter(customer, responseGetter);
1✔
5116
    trySetResponseGetter(invoice, responseGetter);
1✔
5117
    trySetResponseGetter(lastPaymentError, responseGetter);
1✔
5118
    trySetResponseGetter(latestCharge, responseGetter);
1✔
5119
    trySetResponseGetter(nextAction, responseGetter);
1✔
5120
    trySetResponseGetter(onBehalfOf, responseGetter);
1✔
5121
    trySetResponseGetter(paymentDetails, responseGetter);
1✔
5122
    trySetResponseGetter(paymentMethod, responseGetter);
1✔
5123
    trySetResponseGetter(paymentMethodConfigurationDetails, responseGetter);
1✔
5124
    trySetResponseGetter(paymentMethodOptions, responseGetter);
1✔
5125
    trySetResponseGetter(processing, responseGetter);
1✔
5126
    trySetResponseGetter(review, responseGetter);
1✔
5127
    trySetResponseGetter(shipping, responseGetter);
1✔
5128
    trySetResponseGetter(source, responseGetter);
1✔
5129
    trySetResponseGetter(transferData, responseGetter);
1✔
5130
  }
1✔
5131
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc