Class: Stripe::StripeEventNotificationHandler

Inherits:
Object
  • Object
show all
Defined in:
lib/stripe/stripe_event_notification_handler.rb

Instance Method Summary collapse

Constructor Details

#initialize(client, webhook_secret, &fallback_callback) ⇒ StripeEventNotificationHandler

Returns a new instance of StripeEventNotificationHandler.

Raises:

  • (ArgumentError) 


14
15
16
17
18
19
20
21
22
23
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 14

def initialize(client, webhook_secret, &fallback_callback)
  raise ArgumentError, "You must pass a block to act as a fallback" if fallback_callback.nil?

  @client = client
  @webhook_secret = webhook_secret
  @fallback_callback = fallback_callback

  @registered_handlers = {}
  @has_handled_events = false
end

Instance Method Details

#handle(webhook_body, sig_header) ⇒ Object 



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 25

def handle(webhook_body, sig_header)
  # we're ok with this not being a thread-safe write since registering
  # handlers should happen synchronously on startup before any multi-threaded reads happen
  @has_handled_events = true

  notif = @client.parse_event_notification(
    webhook_body,
    sig_header,
    @webhook_secret
  )

  # Create a new client with the event's context to ensure thread-safety
  event_client = new_client_with_context(notif.context)

  handler = @registered_handlers[notif.type]
  if handler
    handler.call(notif, event_client)
  else
    @fallback_callback.call(notif, event_client,
                            UnhandledNotificationDetails.new(!notif.is_a?(Stripe::Events::UnknownEventNotification)))
  end
end

#on_v1_account_application_authorized(&handler) ⇒ Object

event-handler-methods: The beginning of the section generated from our OpenAPI spec

Raises:

  • (ArgumentError) 


77
78
79
80
81
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 77

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.account.application.authorized", &handler)
end

#on_v1_account_application_deauthorized(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


83
84
85
86
87
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 83

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.account.application.deauthorized", &handler)
end

#on_v1_account_external_account_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


89
90
91
92
93
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 89

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.account.external_account.created", &handler)
end

#on_v1_account_external_account_deleted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


95
96
97
98
99
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 95

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.account.external_account.deleted", &handler)
end

#on_v1_account_external_account_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


101
102
103
104
105
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 101

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.account.external_account.updated", &handler)
end

#on_v1_account_signals_including_delinquency_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


113
114
115
116
117
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 113

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.account_signals[delinquency].created", &handler)
end

#on_v1_account_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


107
108
109
110
111
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 107

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.account.updated", &handler)
end

#on_v1_application_fee_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


119
120
121
122
123
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 119

def on_v1_application_fee_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.application_fee.created", &handler)
end

#on_v1_application_fee_refund_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


125
126
127
128
129
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 125

def on_v1_application_fee_refund_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.application_fee.refund.updated", &handler)
end

#on_v1_application_fee_refunded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


131
132
133
134
135
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 131

def on_v1_application_fee_refunded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.application_fee.refunded", &handler)
end

#on_v1_balance_available(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


137
138
139
140
141
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 137

def on_v1_balance_available(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.balance.available", &handler)
end

#on_v1_billing_alert_triggered(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


143
144
145
146
147
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 143

def on_v1_billing_alert_triggered(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.billing.alert.triggered", &handler)
end

#on_v1_billing_meter_error_report_triggered(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


149
150
151
152
153
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 149

def on_v1_billing_meter_error_report_triggered(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.billing.meter.error_report_triggered", &handler)
end

#on_v1_billing_meter_no_meter_found(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


155
156
157
158
159
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 155

def on_v1_billing_meter_no_meter_found(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.billing.meter.no_meter_found", &handler)
end

#on_v1_billing_portal_configuration_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


161
162
163
164
165
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 161

def on_v1_billing_portal_configuration_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.billing_portal.configuration.created", &handler)
end

#on_v1_billing_portal_configuration_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


167
168
169
170
171
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 167

def on_v1_billing_portal_configuration_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.billing_portal.configuration.updated", &handler)
end

#on_v1_billing_portal_session_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


173
174
175
176
177
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 173

def on_v1_billing_portal_session_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.billing_portal.session.created", &handler)
end

#on_v1_capability_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


179
180
181
182
183
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 179

def on_v1_capability_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.capability.updated", &handler)
end

#on_v1_cash_balance_funds_available(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


185
186
187
188
189
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 185

def on_v1_cash_balance_funds_available(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.cash_balance.funds_available", &handler)
end

#on_v1_charge_captured(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


191
192
193
194
195
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 191

def on_v1_charge_captured(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.charge.captured", &handler)
end

#on_v1_charge_dispute_closed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


197
198
199
200
201
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 197

def on_v1_charge_dispute_closed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.charge.dispute.closed", &handler)
end

#on_v1_charge_dispute_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


203
204
205
206
207
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 203

def on_v1_charge_dispute_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.charge.dispute.created", &handler)
end

#on_v1_charge_dispute_funds_reinstated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


209
210
211
212
213
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 209

def on_v1_charge_dispute_funds_reinstated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.charge.dispute.funds_reinstated", &handler)
end

#on_v1_charge_dispute_funds_withdrawn(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


215
216
217
218
219
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 215

def on_v1_charge_dispute_funds_withdrawn(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.charge.dispute.funds_withdrawn", &handler)
end

#on_v1_charge_dispute_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


221
222
223
224
225
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 221

def on_v1_charge_dispute_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.charge.dispute.updated", &handler)
end

#on_v1_charge_expired(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


227
228
229
230
231
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 227

def on_v1_charge_expired(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.charge.expired", &handler)
end

#on_v1_charge_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


233
234
235
236
237
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 233

def on_v1_charge_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.charge.failed", &handler)
end

#on_v1_charge_pending(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


239
240
241
242
243
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 239

def on_v1_charge_pending(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.charge.pending", &handler)
end

#on_v1_charge_refund_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


245
246
247
248
249
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 245

def on_v1_charge_refund_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.charge.refund.updated", &handler)
end

#on_v1_charge_refunded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


251
252
253
254
255
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 251

def on_v1_charge_refunded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.charge.refunded", &handler)
end

#on_v1_charge_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


257
258
259
260
261
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 257

def on_v1_charge_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.charge.succeeded", &handler)
end

#on_v1_charge_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


263
264
265
266
267
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 263

def on_v1_charge_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.charge.updated", &handler)
end

#on_v1_checkout_session_async_payment_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


269
270
271
272
273
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 269

def on_v1_checkout_session_async_payment_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.checkout.session.async_payment_failed", &handler)
end

#on_v1_checkout_session_async_payment_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


275
276
277
278
279
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 275

def on_v1_checkout_session_async_payment_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.checkout.session.async_payment_succeeded", &handler)
end

#on_v1_checkout_session_completed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


281
282
283
284
285
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 281

def on_v1_checkout_session_completed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.checkout.session.completed", &handler)
end

#on_v1_checkout_session_expired(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


287
288
289
290
291
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 287

def on_v1_checkout_session_expired(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.checkout.session.expired", &handler)
end

#on_v1_climate_order_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


293
294
295
296
297
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 293

def on_v1_climate_order_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.climate.order.canceled", &handler)
end

#on_v1_climate_order_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


299
300
301
302
303
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 299

def on_v1_climate_order_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.climate.order.created", &handler)
end

#on_v1_climate_order_delayed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


305
306
307
308
309
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 305

def on_v1_climate_order_delayed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.climate.order.delayed", &handler)
end

#on_v1_climate_order_delivered(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


311
312
313
314
315
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 311

def on_v1_climate_order_delivered(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.climate.order.delivered", &handler)
end

#on_v1_climate_order_product_substituted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


317
318
319
320
321
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 317

def on_v1_climate_order_product_substituted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.climate.order.product_substituted", &handler)
end

#on_v1_climate_product_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


323
324
325
326
327
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 323

def on_v1_climate_product_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.climate.product.created", &handler)
end

#on_v1_climate_product_pricing_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


329
330
331
332
333
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 329

def on_v1_climate_product_pricing_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.climate.product.pricing_updated", &handler)
end

#on_v1_coupon_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


335
336
337
338
339
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 335

def on_v1_coupon_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.coupon.created", &handler)
end

#on_v1_coupon_deleted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


341
342
343
344
345
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 341

def on_v1_coupon_deleted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.coupon.deleted", &handler)
end

#on_v1_coupon_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


347
348
349
350
351
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 347

def on_v1_coupon_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.coupon.updated", &handler)
end

#on_v1_credit_note_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


353
354
355
356
357
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 353

def on_v1_credit_note_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.credit_note.created", &handler)
end

#on_v1_credit_note_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


359
360
361
362
363
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 359

def on_v1_credit_note_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.credit_note.updated", &handler)
end

#on_v1_credit_note_voided(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


365
366
367
368
369
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 365

def on_v1_credit_note_voided(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.credit_note.voided", &handler)
end

#on_v1_customer_cash_balance_transaction_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


455
456
457
458
459
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 455

def on_v1_customer_cash_balance_transaction_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer_cash_balance_transaction.created", &handler)
end

#on_v1_customer_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


371
372
373
374
375
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 371

def on_v1_customer_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer.created", &handler)
end

#on_v1_customer_deleted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


377
378
379
380
381
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 377

def on_v1_customer_deleted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer.deleted", &handler)
end

#on_v1_customer_subscription_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


383
384
385
386
387
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 383

def on_v1_customer_subscription_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer.subscription.created", &handler)
end

#on_v1_customer_subscription_deleted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


389
390
391
392
393
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 389

def on_v1_customer_subscription_deleted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer.subscription.deleted", &handler)
end

#on_v1_customer_subscription_paused(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


395
396
397
398
399
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 395

def on_v1_customer_subscription_paused(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer.subscription.paused", &handler)
end

#on_v1_customer_subscription_pending_update_applied(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


401
402
403
404
405
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 401

def on_v1_customer_subscription_pending_update_applied(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer.subscription.pending_update_applied", &handler)
end

#on_v1_customer_subscription_pending_update_expired(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


407
408
409
410
411
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 407

def on_v1_customer_subscription_pending_update_expired(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer.subscription.pending_update_expired", &handler)
end

#on_v1_customer_subscription_resumed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


413
414
415
416
417
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 413

def on_v1_customer_subscription_resumed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer.subscription.resumed", &handler)
end

#on_v1_customer_subscription_trial_will_end(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


419
420
421
422
423
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 419

def on_v1_customer_subscription_trial_will_end(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer.subscription.trial_will_end", &handler)
end

#on_v1_customer_subscription_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


425
426
427
428
429
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 425

def on_v1_customer_subscription_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer.subscription.updated", &handler)
end

#on_v1_customer_tax_id_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


431
432
433
434
435
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 431

def on_v1_customer_tax_id_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer.tax_id.created", &handler)
end

#on_v1_customer_tax_id_deleted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


437
438
439
440
441
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 437

def on_v1_customer_tax_id_deleted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer.tax_id.deleted", &handler)
end

#on_v1_customer_tax_id_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


443
444
445
446
447
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 443

def on_v1_customer_tax_id_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer.tax_id.updated", &handler)
end

#on_v1_customer_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


449
450
451
452
453
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 449

def on_v1_customer_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.customer.updated", &handler)
end

#on_v1_entitlements_active_entitlement_summary_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


461
462
463
464
465
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 461

def on_v1_entitlements_active_entitlement_summary_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.entitlements.active_entitlement_summary.updated", &handler)
end

#on_v1_file_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


467
468
469
470
471
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 467

def on_v1_file_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.file.created", &handler)
end

#on_v1_financial_connections_account_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


473
474
475
476
477
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 473

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.financial_connections.account.created", &handler)
end

#on_v1_financial_connections_account_deactivated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


479
480
481
482
483
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 479

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.financial_connections.account.deactivated", &handler)
end

#on_v1_financial_connections_account_disconnected(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


485
486
487
488
489
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 485

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.financial_connections.account.disconnected", &handler)
end

#on_v1_financial_connections_account_reactivated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


491
492
493
494
495
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 491

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.financial_connections.account.reactivated", &handler)
end

#on_v1_financial_connections_account_refreshed_balance(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


497
498
499
500
501
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 497

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.financial_connections.account.refreshed_balance", &handler)
end

#on_v1_financial_connections_account_refreshed_ownership(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


503
504
505
506
507
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 503

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.financial_connections.account.refreshed_ownership", &handler)
end

#on_v1_financial_connections_account_refreshed_transactions(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


509
510
511
512
513
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 509

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.financial_connections.account.refreshed_transactions", &handler)
end

#on_v1_identity_verification_session_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


515
516
517
518
519
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 515

def on_v1_identity_verification_session_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.identity.verification_session.canceled", &handler)
end

#on_v1_identity_verification_session_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


521
522
523
524
525
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 521

def on_v1_identity_verification_session_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.identity.verification_session.created", &handler)
end

#on_v1_identity_verification_session_processing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


527
528
529
530
531
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 527

def on_v1_identity_verification_session_processing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.identity.verification_session.processing", &handler)
end

#on_v1_identity_verification_session_redacted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


533
534
535
536
537
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 533

def on_v1_identity_verification_session_redacted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.identity.verification_session.redacted", &handler)
end

#on_v1_identity_verification_session_requires_input(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


539
540
541
542
543
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 539

def on_v1_identity_verification_session_requires_input(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.identity.verification_session.requires_input", &handler)
end

#on_v1_identity_verification_session_verified(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


545
546
547
548
549
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 545

def on_v1_identity_verification_session_verified(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.identity.verification_session.verified", &handler)
end

#on_v1_invoice_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


551
552
553
554
555
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 551

def on_v1_invoice_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.created", &handler)
end

#on_v1_invoice_deleted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


557
558
559
560
561
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 557

def on_v1_invoice_deleted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.deleted", &handler)
end

#on_v1_invoice_finalization_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


563
564
565
566
567
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 563

def on_v1_invoice_finalization_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.finalization_failed", &handler)
end

#on_v1_invoice_finalized(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


569
570
571
572
573
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 569

def on_v1_invoice_finalized(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.finalized", &handler)
end

#on_v1_invoice_marked_uncollectible(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


575
576
577
578
579
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 575

def on_v1_invoice_marked_uncollectible(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.marked_uncollectible", &handler)
end

#on_v1_invoice_overdue(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


581
582
583
584
585
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 581

def on_v1_invoice_overdue(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.overdue", &handler)
end

#on_v1_invoice_overpaid(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


587
588
589
590
591
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 587

def on_v1_invoice_overpaid(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.overpaid", &handler)
end

#on_v1_invoice_paid(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


593
594
595
596
597
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 593

def on_v1_invoice_paid(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.paid", &handler)
end

#on_v1_invoice_payment_action_required(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


599
600
601
602
603
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 599

def on_v1_invoice_payment_action_required(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.payment_action_required", &handler)
end

#on_v1_invoice_payment_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


605
606
607
608
609
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 605

def on_v1_invoice_payment_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.payment_failed", &handler)
end

#on_v1_invoice_payment_paid(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


647
648
649
650
651
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 647

def on_v1_invoice_payment_paid(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice_payment.paid", &handler)
end

#on_v1_invoice_payment_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


611
612
613
614
615
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 611

def on_v1_invoice_payment_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.payment_succeeded", &handler)
end

#on_v1_invoice_sent(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


617
618
619
620
621
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 617

def on_v1_invoice_sent(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.sent", &handler)
end

#on_v1_invoice_upcoming(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


623
624
625
626
627
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 623

def on_v1_invoice_upcoming(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.upcoming", &handler)
end

#on_v1_invoice_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


629
630
631
632
633
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 629

def on_v1_invoice_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.updated", &handler)
end

#on_v1_invoice_voided(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


635
636
637
638
639
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 635

def on_v1_invoice_voided(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.voided", &handler)
end

#on_v1_invoice_will_be_due(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


641
642
643
644
645
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 641

def on_v1_invoice_will_be_due(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoice.will_be_due", &handler)
end

#on_v1_invoiceitem_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


653
654
655
656
657
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 653

def on_v1_invoiceitem_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoiceitem.created", &handler)
end

#on_v1_invoiceitem_deleted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


659
660
661
662
663
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 659

def on_v1_invoiceitem_deleted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.invoiceitem.deleted", &handler)
end

#on_v1_issuing_authorization_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


665
666
667
668
669
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 665

def on_v1_issuing_authorization_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_authorization.created", &handler)
end

#on_v1_issuing_authorization_request(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


671
672
673
674
675
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 671

def on_v1_issuing_authorization_request(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_authorization.request", &handler)
end

#on_v1_issuing_authorization_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


677
678
679
680
681
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 677

def on_v1_issuing_authorization_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_authorization.updated", &handler)
end

#on_v1_issuing_card_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


683
684
685
686
687
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 683

def on_v1_issuing_card_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_card.created", &handler)
end

#on_v1_issuing_card_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


689
690
691
692
693
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 689

def on_v1_issuing_card_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_card.updated", &handler)
end

#on_v1_issuing_cardholder_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


695
696
697
698
699
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 695

def on_v1_issuing_cardholder_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_cardholder.created", &handler)
end

#on_v1_issuing_cardholder_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


701
702
703
704
705
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 701

def on_v1_issuing_cardholder_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_cardholder.updated", &handler)
end

#on_v1_issuing_dispute_closed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


707
708
709
710
711
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 707

def on_v1_issuing_dispute_closed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_dispute.closed", &handler)
end

#on_v1_issuing_dispute_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


713
714
715
716
717
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 713

def on_v1_issuing_dispute_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_dispute.created", &handler)
end

#on_v1_issuing_dispute_funds_reinstated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


719
720
721
722
723
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 719

def on_v1_issuing_dispute_funds_reinstated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_dispute.funds_reinstated", &handler)
end

#on_v1_issuing_dispute_funds_rescinded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


725
726
727
728
729
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 725

def on_v1_issuing_dispute_funds_rescinded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_dispute.funds_rescinded", &handler)
end

#on_v1_issuing_dispute_submitted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


731
732
733
734
735
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 731

def on_v1_issuing_dispute_submitted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_dispute.submitted", &handler)
end

#on_v1_issuing_dispute_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


737
738
739
740
741
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 737

def on_v1_issuing_dispute_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_dispute.updated", &handler)
end

#on_v1_issuing_personalization_design_activated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


743
744
745
746
747
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 743

def on_v1_issuing_personalization_design_activated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_personalization_design.activated", &handler)
end

#on_v1_issuing_personalization_design_deactivated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


749
750
751
752
753
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 749

def on_v1_issuing_personalization_design_deactivated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_personalization_design.deactivated", &handler)
end

#on_v1_issuing_personalization_design_rejected(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


755
756
757
758
759
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 755

def on_v1_issuing_personalization_design_rejected(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_personalization_design.rejected", &handler)
end

#on_v1_issuing_personalization_design_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


761
762
763
764
765
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 761

def on_v1_issuing_personalization_design_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_personalization_design.updated", &handler)
end

#on_v1_issuing_token_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


767
768
769
770
771
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 767

def on_v1_issuing_token_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_token.created", &handler)
end

#on_v1_issuing_token_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


773
774
775
776
777
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 773

def on_v1_issuing_token_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_token.updated", &handler)
end

#on_v1_issuing_transaction_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


779
780
781
782
783
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 779

def on_v1_issuing_transaction_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_transaction.created", &handler)
end

#on_v1_issuing_transaction_purchase_details_receipt_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


785
786
787
788
789
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 785

def on_v1_issuing_transaction_purchase_details_receipt_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_transaction.purchase_details_receipt_updated", &handler)
end

#on_v1_issuing_transaction_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


791
792
793
794
795
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 791

def on_v1_issuing_transaction_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.issuing_transaction.updated", &handler)
end

#on_v1_mandate_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


797
798
799
800
801
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 797

def on_v1_mandate_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.mandate.updated", &handler)
end

#on_v1_payment_intent_amount_capturable_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


803
804
805
806
807
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 803

def on_v1_payment_intent_amount_capturable_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payment_intent.amount_capturable_updated", &handler)
end

#on_v1_payment_intent_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


809
810
811
812
813
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 809

def on_v1_payment_intent_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payment_intent.canceled", &handler)
end

#on_v1_payment_intent_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


815
816
817
818
819
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 815

def on_v1_payment_intent_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payment_intent.created", &handler)
end

#on_v1_payment_intent_partially_funded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


821
822
823
824
825
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 821

def on_v1_payment_intent_partially_funded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payment_intent.partially_funded", &handler)
end

#on_v1_payment_intent_payment_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


827
828
829
830
831
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 827

def on_v1_payment_intent_payment_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payment_intent.payment_failed", &handler)
end

#on_v1_payment_intent_processing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


833
834
835
836
837
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 833

def on_v1_payment_intent_processing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payment_intent.processing", &handler)
end

#on_v1_payment_intent_requires_action(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


839
840
841
842
843
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 839

def on_v1_payment_intent_requires_action(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payment_intent.requires_action", &handler)
end

#on_v1_payment_intent_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


845
846
847
848
849
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 845

def on_v1_payment_intent_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payment_intent.succeeded", &handler)
end

#on_v1_payment_link_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


851
852
853
854
855
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 851

def on_v1_payment_link_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payment_link.created", &handler)
end

#on_v1_payment_link_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


857
858
859
860
861
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 857

def on_v1_payment_link_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payment_link.updated", &handler)
end

#on_v1_payment_method_attached(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


863
864
865
866
867
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 863

def on_v1_payment_method_attached(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payment_method.attached", &handler)
end

#on_v1_payment_method_automatically_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


869
870
871
872
873
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 869

def on_v1_payment_method_automatically_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payment_method.automatically_updated", &handler)
end

#on_v1_payment_method_detached(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


875
876
877
878
879
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 875

def on_v1_payment_method_detached(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payment_method.detached", &handler)
end

#on_v1_payment_method_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


881
882
883
884
885
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 881

def on_v1_payment_method_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payment_method.updated", &handler)
end

#on_v1_payout_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


887
888
889
890
891
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 887

def on_v1_payout_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payout.canceled", &handler)
end

#on_v1_payout_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


893
894
895
896
897
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 893

def on_v1_payout_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payout.created", &handler)
end

#on_v1_payout_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


899
900
901
902
903
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 899

def on_v1_payout_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payout.failed", &handler)
end

#on_v1_payout_paid(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


905
906
907
908
909
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 905

def on_v1_payout_paid(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payout.paid", &handler)
end

#on_v1_payout_reconciliation_completed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


911
912
913
914
915
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 911

def on_v1_payout_reconciliation_completed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payout.reconciliation_completed", &handler)
end

#on_v1_payout_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


917
918
919
920
921
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 917

def on_v1_payout_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.payout.updated", &handler)
end

#on_v1_person_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


923
924
925
926
927
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 923

def on_v1_person_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.person.created", &handler)
end

#on_v1_person_deleted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


929
930
931
932
933
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 929

def on_v1_person_deleted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.person.deleted", &handler)
end

#on_v1_person_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


935
936
937
938
939
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 935

def on_v1_person_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.person.updated", &handler)
end

#on_v1_plan_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


941
942
943
944
945
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 941

def on_v1_plan_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.plan.created", &handler)
end

#on_v1_plan_deleted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


947
948
949
950
951
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 947

def on_v1_plan_deleted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.plan.deleted", &handler)
end

#on_v1_plan_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


953
954
955
956
957
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 953

def on_v1_plan_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.plan.updated", &handler)
end

#on_v1_price_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


959
960
961
962
963
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 959

def on_v1_price_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.price.created", &handler)
end

#on_v1_price_deleted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


965
966
967
968
969
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 965

def on_v1_price_deleted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.price.deleted", &handler)
end

#on_v1_price_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


971
972
973
974
975
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 971

def on_v1_price_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.price.updated", &handler)
end

#on_v1_product_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


977
978
979
980
981
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 977

def on_v1_product_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.product.created", &handler)
end

#on_v1_product_deleted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


983
984
985
986
987
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 983

def on_v1_product_deleted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.product.deleted", &handler)
end

#on_v1_product_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


989
990
991
992
993
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 989

def on_v1_product_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.product.updated", &handler)
end

#on_v1_promotion_code_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


995
996
997
998
999
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 995

def on_v1_promotion_code_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.promotion_code.created", &handler)
end

#on_v1_promotion_code_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1001
1002
1003
1004
1005
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1001

def on_v1_promotion_code_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.promotion_code.updated", &handler)
end

#on_v1_quote_accepted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1007
1008
1009
1010
1011
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1007

def on_v1_quote_accepted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.quote.accepted", &handler)
end

#on_v1_quote_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1013
1014
1015
1016
1017
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1013

def on_v1_quote_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.quote.canceled", &handler)
end

#on_v1_quote_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1019
1020
1021
1022
1023
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1019

def on_v1_quote_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.quote.created", &handler)
end

#on_v1_quote_finalized(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1025
1026
1027
1028
1029
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1025

def on_v1_quote_finalized(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.quote.finalized", &handler)
end

#on_v1_radar_early_fraud_warning_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1031
1032
1033
1034
1035
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1031

def on_v1_radar_early_fraud_warning_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.radar.early_fraud_warning.created", &handler)
end

#on_v1_radar_early_fraud_warning_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1037
1038
1039
1040
1041
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1037

def on_v1_radar_early_fraud_warning_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.radar.early_fraud_warning.updated", &handler)
end

#on_v1_refund_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1043
1044
1045
1046
1047
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1043

def on_v1_refund_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.refund.created", &handler)
end

#on_v1_refund_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1049
1050
1051
1052
1053
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1049

def on_v1_refund_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.refund.failed", &handler)
end

#on_v1_refund_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1055
1056
1057
1058
1059
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1055

def on_v1_refund_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.refund.updated", &handler)
end

#on_v1_review_closed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1061
1062
1063
1064
1065
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1061

def on_v1_review_closed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.review.closed", &handler)
end

#on_v1_review_opened(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1067
1068
1069
1070
1071
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1067

def on_v1_review_opened(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.review.opened", &handler)
end

#on_v1_setup_intent_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1073
1074
1075
1076
1077
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1073

def on_v1_setup_intent_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.setup_intent.canceled", &handler)
end

#on_v1_setup_intent_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1079
1080
1081
1082
1083
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1079

def on_v1_setup_intent_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.setup_intent.created", &handler)
end

#on_v1_setup_intent_requires_action(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1085
1086
1087
1088
1089
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1085

def on_v1_setup_intent_requires_action(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.setup_intent.requires_action", &handler)
end

#on_v1_setup_intent_setup_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1091
1092
1093
1094
1095
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1091

def on_v1_setup_intent_setup_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.setup_intent.setup_failed", &handler)
end

#on_v1_setup_intent_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1097
1098
1099
1100
1101
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1097

def on_v1_setup_intent_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.setup_intent.succeeded", &handler)
end

#on_v1_sigma_scheduled_query_run_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1103
1104
1105
1106
1107
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1103

def on_v1_sigma_scheduled_query_run_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.sigma.scheduled_query_run.created", &handler)
end

#on_v1_source_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1109
1110
1111
1112
1113
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1109

def on_v1_source_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.source.canceled", &handler)
end

#on_v1_source_chargeable(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1115
1116
1117
1118
1119
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1115

def on_v1_source_chargeable(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.source.chargeable", &handler)
end

#on_v1_source_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1121
1122
1123
1124
1125
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1121

def on_v1_source_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.source.failed", &handler)
end

#on_v1_source_refund_attributes_required(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1127
1128
1129
1130
1131
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1127

def on_v1_source_refund_attributes_required(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.source.refund_attributes_required", &handler)
end

#on_v1_subscription_schedule_aborted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1133
1134
1135
1136
1137
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1133

def on_v1_subscription_schedule_aborted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.subscription_schedule.aborted", &handler)
end

#on_v1_subscription_schedule_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1139
1140
1141
1142
1143
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1139

def on_v1_subscription_schedule_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.subscription_schedule.canceled", &handler)
end

#on_v1_subscription_schedule_completed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1145
1146
1147
1148
1149
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1145

def on_v1_subscription_schedule_completed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.subscription_schedule.completed", &handler)
end

#on_v1_subscription_schedule_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1151
1152
1153
1154
1155
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1151

def on_v1_subscription_schedule_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.subscription_schedule.created", &handler)
end

#on_v1_subscription_schedule_expiring(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1157
1158
1159
1160
1161
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1157

def on_v1_subscription_schedule_expiring(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.subscription_schedule.expiring", &handler)
end

#on_v1_subscription_schedule_released(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1163
1164
1165
1166
1167
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1163

def on_v1_subscription_schedule_released(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.subscription_schedule.released", &handler)
end

#on_v1_subscription_schedule_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1169
1170
1171
1172
1173
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1169

def on_v1_subscription_schedule_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.subscription_schedule.updated", &handler)
end

#on_v1_tax_rate_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1181
1182
1183
1184
1185
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1181

def on_v1_tax_rate_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.tax_rate.created", &handler)
end

#on_v1_tax_rate_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1187
1188
1189
1190
1191
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1187

def on_v1_tax_rate_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.tax_rate.updated", &handler)
end

#on_v1_tax_settings_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1175
1176
1177
1178
1179
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1175

def on_v1_tax_settings_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.tax.settings.updated", &handler)
end

#on_v1_terminal_reader_action_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1193
1194
1195
1196
1197
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1193

def on_v1_terminal_reader_action_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.terminal.reader.action_failed", &handler)
end

#on_v1_terminal_reader_action_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1199
1200
1201
1202
1203
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1199

def on_v1_terminal_reader_action_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.terminal.reader.action_succeeded", &handler)
end

#on_v1_terminal_reader_action_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1205
1206
1207
1208
1209
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1205

def on_v1_terminal_reader_action_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.terminal.reader.action_updated", &handler)
end

#on_v1_test_helpers_test_clock_advancing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1211
1212
1213
1214
1215
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1211

def on_v1_test_helpers_test_clock_advancing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.test_helpers.test_clock.advancing", &handler)
end

#on_v1_test_helpers_test_clock_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1217
1218
1219
1220
1221
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1217

def on_v1_test_helpers_test_clock_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.test_helpers.test_clock.created", &handler)
end

#on_v1_test_helpers_test_clock_deleted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1223
1224
1225
1226
1227
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1223

def on_v1_test_helpers_test_clock_deleted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.test_helpers.test_clock.deleted", &handler)
end

#on_v1_test_helpers_test_clock_internal_failure(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1229
1230
1231
1232
1233
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1229

def on_v1_test_helpers_test_clock_internal_failure(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.test_helpers.test_clock.internal_failure", &handler)
end

#on_v1_test_helpers_test_clock_ready(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1235
1236
1237
1238
1239
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1235

def on_v1_test_helpers_test_clock_ready(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.test_helpers.test_clock.ready", &handler)
end

#on_v1_topup_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1241
1242
1243
1244
1245
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1241

def on_v1_topup_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.topup.canceled", &handler)
end

#on_v1_topup_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1247
1248
1249
1250
1251
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1247

def on_v1_topup_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.topup.created", &handler)
end

#on_v1_topup_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1253
1254
1255
1256
1257
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1253

def on_v1_topup_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.topup.failed", &handler)
end

#on_v1_topup_reversed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1259
1260
1261
1262
1263
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1259

def on_v1_topup_reversed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.topup.reversed", &handler)
end

#on_v1_topup_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1265
1266
1267
1268
1269
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1265

def on_v1_topup_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.topup.succeeded", &handler)
end

#on_v1_transfer_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1271
1272
1273
1274
1275
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1271

def on_v1_transfer_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.transfer.created", &handler)
end

#on_v1_transfer_reversed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1277
1278
1279
1280
1281
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1277

def on_v1_transfer_reversed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.transfer.reversed", &handler)
end

#on_v1_transfer_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1283
1284
1285
1286
1287
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1283

def on_v1_transfer_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v1.transfer.updated", &handler)
end

#on_v2_billing_cadence_billed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1289
1290
1291
1292
1293
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1289

def on_v2_billing_cadence_billed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.cadence.billed", &handler)
end

#on_v2_billing_cadence_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1295
1296
1297
1298
1299
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1295

def on_v2_billing_cadence_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.cadence.canceled", &handler)
end

#on_v2_billing_cadence_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1301
1302
1303
1304
1305
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1301

def on_v2_billing_cadence_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.cadence.created", &handler)
end

#on_v2_billing_license_fee_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1307
1308
1309
1310
1311
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1307

def on_v2_billing_license_fee_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.license_fee.created", &handler)
end

#on_v2_billing_license_fee_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1313
1314
1315
1316
1317
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1313

def on_v2_billing_license_fee_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.license_fee.updated", &handler)
end

#on_v2_billing_license_fee_version_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1319
1320
1321
1322
1323
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1319

def on_v2_billing_license_fee_version_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.license_fee_version.created", &handler)
end

#on_v2_billing_licensed_item_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1325
1326
1327
1328
1329
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1325

def on_v2_billing_licensed_item_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.licensed_item.created", &handler)
end

#on_v2_billing_licensed_item_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1331
1332
1333
1334
1335
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1331

def on_v2_billing_licensed_item_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.licensed_item.updated", &handler)
end

#on_v2_billing_metered_item_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1337
1338
1339
1340
1341
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1337

def on_v2_billing_metered_item_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.metered_item.created", &handler)
end

#on_v2_billing_metered_item_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1343
1344
1345
1346
1347
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1343

def on_v2_billing_metered_item_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.metered_item.updated", &handler)
end

#on_v2_billing_pricing_plan_component_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1361
1362
1363
1364
1365
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1361

def on_v2_billing_pricing_plan_component_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.pricing_plan_component.created", &handler)
end

#on_v2_billing_pricing_plan_component_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1367
1368
1369
1370
1371
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1367

def on_v2_billing_pricing_plan_component_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.pricing_plan_component.updated", &handler)
end

#on_v2_billing_pricing_plan_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1349
1350
1351
1352
1353
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1349

def on_v2_billing_pricing_plan_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.pricing_plan.created", &handler)
end

#on_v2_billing_pricing_plan_subscription_collection_awaiting_customer_action(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1373
1374
1375
1376
1377
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1373

def on_v2_billing_pricing_plan_subscription_collection_awaiting_customer_action(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.pricing_plan_subscription.collection_awaiting_customer_action", &handler)
end

#on_v2_billing_pricing_plan_subscription_collection_current(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1379
1380
1381
1382
1383
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1379

def on_v2_billing_pricing_plan_subscription_collection_current(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.pricing_plan_subscription.collection_current", &handler)
end

#on_v2_billing_pricing_plan_subscription_collection_past_due(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1385
1386
1387
1388
1389
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1385

def on_v2_billing_pricing_plan_subscription_collection_past_due(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.pricing_plan_subscription.collection_past_due", &handler)
end

#on_v2_billing_pricing_plan_subscription_collection_paused(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1391
1392
1393
1394
1395
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1391

def on_v2_billing_pricing_plan_subscription_collection_paused(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.pricing_plan_subscription.collection_paused", &handler)
end

#on_v2_billing_pricing_plan_subscription_collection_unpaid(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1397
1398
1399
1400
1401
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1397

def on_v2_billing_pricing_plan_subscription_collection_unpaid(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.pricing_plan_subscription.collection_unpaid", &handler)
end

#on_v2_billing_pricing_plan_subscription_servicing_activated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1403
1404
1405
1406
1407
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1403

def on_v2_billing_pricing_plan_subscription_servicing_activated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.pricing_plan_subscription.servicing_activated", &handler)
end

#on_v2_billing_pricing_plan_subscription_servicing_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1409
1410
1411
1412
1413
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1409

def on_v2_billing_pricing_plan_subscription_servicing_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.pricing_plan_subscription.servicing_canceled", &handler)
end

#on_v2_billing_pricing_plan_subscription_servicing_paused(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1415
1416
1417
1418
1419
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1415

def on_v2_billing_pricing_plan_subscription_servicing_paused(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.pricing_plan_subscription.servicing_paused", &handler)
end

#on_v2_billing_pricing_plan_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1355
1356
1357
1358
1359
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1355

def on_v2_billing_pricing_plan_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.pricing_plan.updated", &handler)
end

#on_v2_billing_pricing_plan_version_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1421
1422
1423
1424
1425
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1421

def on_v2_billing_pricing_plan_version_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.pricing_plan_version.created", &handler)
end

#on_v2_billing_rate_card_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1427
1428
1429
1430
1431
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1427

def on_v2_billing_rate_card_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card.created", &handler)
end

#on_v2_billing_rate_card_custom_pricing_unit_overage_rate_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1439
1440
1441
1442
1443
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1439

def on_v2_billing_rate_card_custom_pricing_unit_overage_rate_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card_custom_pricing_unit_overage_rate.created", &handler)
end

#on_v2_billing_rate_card_rate_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1445
1446
1447
1448
1449
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1445

def on_v2_billing_rate_card_rate_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card_rate.created", &handler)
end

#on_v2_billing_rate_card_subscription_activated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1451
1452
1453
1454
1455
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1451

def on_v2_billing_rate_card_subscription_activated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card_subscription.activated", &handler)
end

#on_v2_billing_rate_card_subscription_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1457
1458
1459
1460
1461
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1457

def on_v2_billing_rate_card_subscription_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card_subscription.canceled", &handler)
end

#on_v2_billing_rate_card_subscription_collection_awaiting_customer_action(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1463
1464
1465
1466
1467
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1463

def on_v2_billing_rate_card_subscription_collection_awaiting_customer_action(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card_subscription.collection_awaiting_customer_action", &handler)
end

#on_v2_billing_rate_card_subscription_collection_current(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1469
1470
1471
1472
1473
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1469

def on_v2_billing_rate_card_subscription_collection_current(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card_subscription.collection_current", &handler)
end

#on_v2_billing_rate_card_subscription_collection_past_due(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1475
1476
1477
1478
1479
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1475

def on_v2_billing_rate_card_subscription_collection_past_due(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card_subscription.collection_past_due", &handler)
end

#on_v2_billing_rate_card_subscription_collection_paused(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1481
1482
1483
1484
1485
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1481

def on_v2_billing_rate_card_subscription_collection_paused(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card_subscription.collection_paused", &handler)
end

#on_v2_billing_rate_card_subscription_collection_unpaid(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1487
1488
1489
1490
1491
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1487

def on_v2_billing_rate_card_subscription_collection_unpaid(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card_subscription.collection_unpaid", &handler)
end

#on_v2_billing_rate_card_subscription_servicing_activated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1493
1494
1495
1496
1497
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1493

def on_v2_billing_rate_card_subscription_servicing_activated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card_subscription.servicing_activated", &handler)
end

#on_v2_billing_rate_card_subscription_servicing_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1499
1500
1501
1502
1503
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1499

def on_v2_billing_rate_card_subscription_servicing_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card_subscription.servicing_canceled", &handler)
end

#on_v2_billing_rate_card_subscription_servicing_paused(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1505
1506
1507
1508
1509
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1505

def on_v2_billing_rate_card_subscription_servicing_paused(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card_subscription.servicing_paused", &handler)
end

#on_v2_billing_rate_card_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1433
1434
1435
1436
1437
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1433

def on_v2_billing_rate_card_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card.updated", &handler)
end

#on_v2_billing_rate_card_version_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1511
1512
1513
1514
1515
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1511

def on_v2_billing_rate_card_version_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.billing.rate_card_version.created", &handler)
end

#on_v2_commerce_product_catalog_imports_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1517
1518
1519
1520
1521
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1517

def on_v2_commerce_product_catalog_imports_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.commerce.product_catalog.imports.failed", &handler)
end

#on_v2_commerce_product_catalog_imports_processing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1523
1524
1525
1526
1527
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1523

def on_v2_commerce_product_catalog_imports_processing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.commerce.product_catalog.imports.processing", &handler)
end

#on_v2_commerce_product_catalog_imports_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1529
1530
1531
1532
1533
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1529

def on_v2_commerce_product_catalog_imports_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.commerce.product_catalog.imports.succeeded", &handler)
end

#on_v2_commerce_product_catalog_imports_succeeded_with_errors(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1535
1536
1537
1538
1539
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1535

def on_v2_commerce_product_catalog_imports_succeeded_with_errors(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.commerce.product_catalog.imports.succeeded_with_errors", &handler)
end

#on_v2_core_account_closed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1541
1542
1543
1544
1545
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1541

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account.closed", &handler)
end

#on_v2_core_account_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1547
1548
1549
1550
1551
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1547

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account.created", &handler)
end

#on_v2_core_account_including_configuration_card_creator_capability_status_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1559
1560
1561
1562
1563
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1559

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account[configuration.card_creator].capability_status_updated", &handler)
end

#on_v2_core_account_including_configuration_card_creator_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1565
1566
1567
1568
1569
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1565

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account[configuration.card_creator].updated", &handler)
end

#on_v2_core_account_including_configuration_customer_capability_status_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1571
1572
1573
1574
1575
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1571

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account[configuration.customer].capability_status_updated", &handler)
end

#on_v2_core_account_including_configuration_customer_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1577
1578
1579
1580
1581
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1577

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account[configuration.customer].updated", &handler)
end

#on_v2_core_account_including_configuration_merchant_capability_status_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1583
1584
1585
1586
1587
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1583

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account[configuration.merchant].capability_status_updated", &handler)
end

#on_v2_core_account_including_configuration_merchant_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1589
1590
1591
1592
1593
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1589

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account[configuration.merchant].updated", &handler)
end

#on_v2_core_account_including_configuration_recipient_capability_status_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1595
1596
1597
1598
1599
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1595

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account[configuration.recipient].capability_status_updated", &handler)
end

#on_v2_core_account_including_configuration_recipient_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1601
1602
1603
1604
1605
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1601

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account[configuration.recipient].updated", &handler)
end

#on_v2_core_account_including_configuration_storer_capability_status_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1607
1608
1609
1610
1611
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1607

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account[configuration.storer].capability_status_updated", &handler)
end

#on_v2_core_account_including_configuration_storer_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1613
1614
1615
1616
1617
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1613

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account[configuration.storer].updated", &handler)
end

#on_v2_core_account_including_defaults_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1619
1620
1621
1622
1623
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1619

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account[defaults].updated", &handler)
end

#on_v2_core_account_including_future_requirements_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1625
1626
1627
1628
1629
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1625

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account[future_requirements].updated", &handler)
end

#on_v2_core_account_including_identity_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1631
1632
1633
1634
1635
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1631

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account[identity].updated", &handler)
end

#on_v2_core_account_including_requirements_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1637
1638
1639
1640
1641
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1637

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account[requirements].updated", &handler)
end

#on_v2_core_account_link_returned(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1643
1644
1645
1646
1647
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1643

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account_link.returned", &handler)
end

#on_v2_core_account_person_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1649
1650
1651
1652
1653
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1649

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account_person.created", &handler)
end

#on_v2_core_account_person_deleted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1655
1656
1657
1658
1659
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1655

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account_person.deleted", &handler)
end

#on_v2_core_account_person_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1661
1662
1663
1664
1665
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1661

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account_person.updated", &handler)
end

#on_v2_core_account_signals_fraudulent_website_ready(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1667
1668
1669
1670
1671
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1667

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account_signals.fraudulent_website_ready", &handler)
end

#on_v2_core_account_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1553
1554
1555
1556
1557
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1553

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.account.updated", &handler)
end

#on_v2_core_approval_request_approved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1673
1674
1675
1676
1677
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1673

def on_v2_core_approval_request_approved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.approval_request.approved", &handler)
end

#on_v2_core_approval_request_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1679
1680
1681
1682
1683
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1679

def on_v2_core_approval_request_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.approval_request.canceled", &handler)
end

#on_v2_core_approval_request_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1685
1686
1687
1688
1689
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1685

def on_v2_core_approval_request_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.approval_request.created", &handler)
end

#on_v2_core_approval_request_expired(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1691
1692
1693
1694
1695
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1691

def on_v2_core_approval_request_expired(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.approval_request.expired", &handler)
end

#on_v2_core_approval_request_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1697
1698
1699
1700
1701
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1697

def on_v2_core_approval_request_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.approval_request.failed", &handler)
end

#on_v2_core_approval_request_rejected(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1703
1704
1705
1706
1707
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1703

def on_v2_core_approval_request_rejected(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.approval_request.rejected", &handler)
end

#on_v2_core_approval_request_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1709
1710
1711
1712
1713
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1709

def on_v2_core_approval_request_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.approval_request.succeeded", &handler)
end

#on_v2_core_batch_job_batch_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1715
1716
1717
1718
1719
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1715

def on_v2_core_batch_job_batch_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.batch_job.batch_failed", &handler)
end

#on_v2_core_batch_job_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1721
1722
1723
1724
1725
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1721

def on_v2_core_batch_job_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.batch_job.canceled", &handler)
end

#on_v2_core_batch_job_completed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1727
1728
1729
1730
1731
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1727

def on_v2_core_batch_job_completed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.batch_job.completed", &handler)
end

#on_v2_core_batch_job_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1733
1734
1735
1736
1737
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1733

def on_v2_core_batch_job_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.batch_job.created", &handler)
end

#on_v2_core_batch_job_ready_for_upload(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1739
1740
1741
1742
1743
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1739

def on_v2_core_batch_job_ready_for_upload(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.batch_job.ready_for_upload", &handler)
end

#on_v2_core_batch_job_timeout(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1745
1746
1747
1748
1749
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1745

def on_v2_core_batch_job_timeout(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.batch_job.timeout", &handler)
end

#on_v2_core_batch_job_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1751
1752
1753
1754
1755
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1751

def on_v2_core_batch_job_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.batch_job.updated", &handler)
end

#on_v2_core_batch_job_upload_timeout(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1757
1758
1759
1760
1761
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1757

def on_v2_core_batch_job_upload_timeout(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.batch_job.upload_timeout", &handler)
end

#on_v2_core_batch_job_validating(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1763
1764
1765
1766
1767
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1763

def on_v2_core_batch_job_validating(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.batch_job.validating", &handler)
end

#on_v2_core_batch_job_validation_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1769
1770
1771
1772
1773
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1769

def on_v2_core_batch_job_validation_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.batch_job.validation_failed", &handler)
end

#on_v2_core_claimable_sandbox_claimed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1775
1776
1777
1778
1779
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1775

def on_v2_core_claimable_sandbox_claimed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.claimable_sandbox.claimed", &handler)
end

#on_v2_core_claimable_sandbox_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1781
1782
1783
1784
1785
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1781

def on_v2_core_claimable_sandbox_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.claimable_sandbox.created", &handler)
end

#on_v2_core_claimable_sandbox_expired(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1787
1788
1789
1790
1791
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1787

def on_v2_core_claimable_sandbox_expired(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.claimable_sandbox.expired", &handler)
end

#on_v2_core_claimable_sandbox_expiring(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1793
1794
1795
1796
1797
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1793

def on_v2_core_claimable_sandbox_expiring(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.claimable_sandbox.expiring", &handler)
end

#on_v2_core_claimable_sandbox_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1799
1800
1801
1802
1803
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1799

def on_v2_core_claimable_sandbox_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.claimable_sandbox.updated", &handler)
end

#on_v2_core_event_destination_ping(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1805
1806
1807
1808
1809
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1805

def on_v2_core_event_destination_ping(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.event_destination.ping", &handler)
end

#on_v2_core_health_api_error_firing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1811
1812
1813
1814
1815
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1811

def on_v2_core_health_api_error_firing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.api_error.firing", &handler)
end

#on_v2_core_health_api_error_resolved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1817
1818
1819
1820
1821
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1817

def on_v2_core_health_api_error_resolved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.api_error.resolved", &handler)
end

#on_v2_core_health_api_latency_firing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1823
1824
1825
1826
1827
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1823

def on_v2_core_health_api_latency_firing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.api_latency.firing", &handler)
end

#on_v2_core_health_api_latency_resolved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1829
1830
1831
1832
1833
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1829

def on_v2_core_health_api_latency_resolved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.api_latency.resolved", &handler)
end

#on_v2_core_health_authorization_rate_drop_firing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1835
1836
1837
1838
1839
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1835

def on_v2_core_health_authorization_rate_drop_firing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.authorization_rate_drop.firing", &handler)
end

#on_v2_core_health_authorization_rate_drop_resolved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1841
1842
1843
1844
1845
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1841

def on_v2_core_health_authorization_rate_drop_resolved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.authorization_rate_drop.resolved", &handler)
end

#on_v2_core_health_elements_error_firing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1847
1848
1849
1850
1851
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1847

def on_v2_core_health_elements_error_firing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.elements_error.firing", &handler)
end

#on_v2_core_health_elements_error_resolved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1853
1854
1855
1856
1857
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1853

def on_v2_core_health_elements_error_resolved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.elements_error.resolved", &handler)
end

#on_v2_core_health_event_generation_failure_resolved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1859
1860
1861
1862
1863
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1859

def on_v2_core_health_event_generation_failure_resolved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.event_generation_failure.resolved", &handler)
end

#on_v2_core_health_fraud_rate_increased(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1865
1866
1867
1868
1869
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1865

def on_v2_core_health_fraud_rate_increased(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.fraud_rate.increased", &handler)
end

#on_v2_core_health_invoice_count_dropped_firing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1871
1872
1873
1874
1875
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1871

def on_v2_core_health_invoice_count_dropped_firing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.invoice_count_dropped.firing", &handler)
end

#on_v2_core_health_invoice_count_dropped_resolved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1877
1878
1879
1880
1881
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1877

def on_v2_core_health_invoice_count_dropped_resolved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.invoice_count_dropped.resolved", &handler)
end

#on_v2_core_health_issuing_authorization_request_errors_firing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1883
1884
1885
1886
1887
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1883

def on_v2_core_health_issuing_authorization_request_errors_firing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.issuing_authorization_request_errors.firing", &handler)
end

#on_v2_core_health_issuing_authorization_request_errors_resolved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1889
1890
1891
1892
1893
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1889

def on_v2_core_health_issuing_authorization_request_errors_resolved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.issuing_authorization_request_errors.resolved", &handler)
end

#on_v2_core_health_issuing_authorization_request_timeout_firing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1895
1896
1897
1898
1899
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1895

def on_v2_core_health_issuing_authorization_request_timeout_firing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.issuing_authorization_request_timeout.firing", &handler)
end

#on_v2_core_health_issuing_authorization_request_timeout_resolved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1901
1902
1903
1904
1905
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1901

def on_v2_core_health_issuing_authorization_request_timeout_resolved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.issuing_authorization_request_timeout.resolved", &handler)
end

#on_v2_core_health_meter_event_summaries_delayed_firing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1907
1908
1909
1910
1911
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1907

def on_v2_core_health_meter_event_summaries_delayed_firing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.meter_event_summaries_delayed.firing", &handler)
end

#on_v2_core_health_meter_event_summaries_delayed_resolved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1913
1914
1915
1916
1917
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1913

def on_v2_core_health_meter_event_summaries_delayed_resolved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.meter_event_summaries_delayed.resolved", &handler)
end

#on_v2_core_health_payment_method_error_firing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1919
1920
1921
1922
1923
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1919

def on_v2_core_health_payment_method_error_firing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.payment_method_error.firing", &handler)
end

#on_v2_core_health_payment_method_error_resolved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1925
1926
1927
1928
1929
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1925

def on_v2_core_health_payment_method_error_resolved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.payment_method_error.resolved", &handler)
end

#on_v2_core_health_sepa_debit_delayed_firing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1931
1932
1933
1934
1935
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1931

def on_v2_core_health_sepa_debit_delayed_firing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.sepa_debit_delayed.firing", &handler)
end

#on_v2_core_health_sepa_debit_delayed_resolved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1937
1938
1939
1940
1941
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1937

def on_v2_core_health_sepa_debit_delayed_resolved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.sepa_debit_delayed.resolved", &handler)
end

#on_v2_core_health_traffic_volume_drop_firing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1943
1944
1945
1946
1947
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1943

def on_v2_core_health_traffic_volume_drop_firing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.traffic_volume_drop.firing", &handler)
end

#on_v2_core_health_traffic_volume_drop_resolved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1949
1950
1951
1952
1953
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1949

def on_v2_core_health_traffic_volume_drop_resolved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.traffic_volume_drop.resolved", &handler)
end

#on_v2_core_health_webhook_latency_firing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1955
1956
1957
1958
1959
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1955

def on_v2_core_health_webhook_latency_firing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.webhook_latency.firing", &handler)
end

#on_v2_core_health_webhook_latency_resolved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1961
1962
1963
1964
1965
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1961

def on_v2_core_health_webhook_latency_resolved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.core.health.webhook_latency.resolved", &handler)
end

#on_v2_data_reporting_query_run_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1967
1968
1969
1970
1971
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1967

def on_v2_data_reporting_query_run_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.data.reporting.query_run.created", &handler)
end

#on_v2_data_reporting_query_run_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1973
1974
1975
1976
1977
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1973

def on_v2_data_reporting_query_run_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.data.reporting.query_run.failed", &handler)
end

#on_v2_data_reporting_query_run_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1979
1980
1981
1982
1983
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1979

def on_v2_data_reporting_query_run_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.data.reporting.query_run.succeeded", &handler)
end

#on_v2_data_reporting_query_run_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1985
1986
1987
1988
1989
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1985

def on_v2_data_reporting_query_run_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.data.reporting.query_run.updated", &handler)
end

#on_v2_extend_extension_run_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1991
1992
1993
1994
1995
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1991

def on_v2_extend_extension_run_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.extend.extension_run.failed", &handler)
end

#on_v2_extend_workflow_run_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


1997
1998
1999
2000
2001
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 1997

def on_v2_extend_workflow_run_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.extend.workflow_run.failed", &handler)
end

#on_v2_extend_workflow_run_started(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2003
2004
2005
2006
2007
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2003

def on_v2_extend_workflow_run_started(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.extend.workflow_run.started", &handler)
end

#on_v2_extend_workflow_run_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2009
2010
2011
2012
2013
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2009

def on_v2_extend_workflow_run_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.extend.workflow_run.succeeded", &handler)
end

#on_v2_iam_api_key_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2015
2016
2017
2018
2019
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2015

def on_v2_iam_api_key_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.iam.api_key.created", &handler)
end

#on_v2_iam_api_key_default_secret_revealed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2021
2022
2023
2024
2025
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2021

def on_v2_iam_api_key_default_secret_revealed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.iam.api_key.default_secret_revealed", &handler)
end

#on_v2_iam_api_key_expired(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2027
2028
2029
2030
2031
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2027

def on_v2_iam_api_key_expired(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.iam.api_key.expired", &handler)
end

#on_v2_iam_api_key_permissions_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2033
2034
2035
2036
2037
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2033

def on_v2_iam_api_key_permissions_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.iam.api_key.permissions_updated", &handler)
end

#on_v2_iam_api_key_rotated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2039
2040
2041
2042
2043
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2039

def on_v2_iam_api_key_rotated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.iam.api_key.rotated", &handler)
end

#on_v2_iam_api_key_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2045
2046
2047
2048
2049
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2045

def on_v2_iam_api_key_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.iam.api_key.updated", &handler)
end

#on_v2_iam_stripe_access_grant_approved(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2051
2052
2053
2054
2055
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2051

def on_v2_iam_stripe_access_grant_approved(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.iam.stripe_access_grant.approved", &handler)
end

#on_v2_iam_stripe_access_grant_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2057
2058
2059
2060
2061
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2057

def on_v2_iam_stripe_access_grant_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.iam.stripe_access_grant.canceled", &handler)
end

#on_v2_iam_stripe_access_grant_denied(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2063
2064
2065
2066
2067
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2063

def on_v2_iam_stripe_access_grant_denied(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.iam.stripe_access_grant.denied", &handler)
end

#on_v2_iam_stripe_access_grant_removed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2069
2070
2071
2072
2073
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2069

def on_v2_iam_stripe_access_grant_removed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.iam.stripe_access_grant.removed", &handler)
end

#on_v2_iam_stripe_access_grant_requested(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2075
2076
2077
2078
2079
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2075

def on_v2_iam_stripe_access_grant_requested(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.iam.stripe_access_grant.requested", &handler)
end

#on_v2_iam_stripe_access_grant_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2081
2082
2083
2084
2085
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2081

def on_v2_iam_stripe_access_grant_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.iam.stripe_access_grant.updated", &handler)
end

#on_v2_money_management_adjustment_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2087
2088
2089
2090
2091
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2087

def on_v2_money_management_adjustment_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.adjustment.created", &handler)
end

#on_v2_money_management_financial_account_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2093
2094
2095
2096
2097
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2093

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.financial_account.created", &handler)
end

#on_v2_money_management_financial_account_statement_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2105
2106
2107
2108
2109
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2105

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.financial_account_statement.created", &handler)
end

#on_v2_money_management_financial_account_statement_restated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2111
2112
2113
2114
2115
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2111

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.financial_account_statement.restated", &handler)
end

#on_v2_money_management_financial_account_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2099
2100
2101
2102
2103
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2099

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.financial_account.updated", &handler)
end

#on_v2_money_management_financial_address_activated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2117
2118
2119
2120
2121
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2117

def on_v2_money_management_financial_address_activated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.financial_address.activated", &handler)
end

#on_v2_money_management_financial_address_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2123
2124
2125
2126
2127
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2123

def on_v2_money_management_financial_address_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.financial_address.failed", &handler)
end

#on_v2_money_management_inbound_transfer_available(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2129
2130
2131
2132
2133
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2129

def on_v2_money_management_inbound_transfer_available(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.inbound_transfer.available", &handler)
end

#on_v2_money_management_inbound_transfer_bank_debit_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2135
2136
2137
2138
2139
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2135

def on_v2_money_management_inbound_transfer_bank_debit_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.inbound_transfer.bank_debit_failed", &handler)
end

#on_v2_money_management_inbound_transfer_bank_debit_processing(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2141
2142
2143
2144
2145
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2141

def on_v2_money_management_inbound_transfer_bank_debit_processing(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.inbound_transfer.bank_debit_processing", &handler)
end

#on_v2_money_management_inbound_transfer_bank_debit_queued(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2147
2148
2149
2150
2151
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2147

def on_v2_money_management_inbound_transfer_bank_debit_queued(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.inbound_transfer.bank_debit_queued", &handler)
end

#on_v2_money_management_inbound_transfer_bank_debit_returned(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2153
2154
2155
2156
2157
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2153

def on_v2_money_management_inbound_transfer_bank_debit_returned(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.inbound_transfer.bank_debit_returned", &handler)
end

#on_v2_money_management_inbound_transfer_bank_debit_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2159
2160
2161
2162
2163
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2159

def on_v2_money_management_inbound_transfer_bank_debit_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.inbound_transfer.bank_debit_succeeded", &handler)
end

#on_v2_money_management_outbound_payment_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2165
2166
2167
2168
2169
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2165

def on_v2_money_management_outbound_payment_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.outbound_payment.canceled", &handler)
end

#on_v2_money_management_outbound_payment_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2171
2172
2173
2174
2175
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2171

def on_v2_money_management_outbound_payment_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.outbound_payment.created", &handler)
end

#on_v2_money_management_outbound_payment_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2177
2178
2179
2180
2181
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2177

def on_v2_money_management_outbound_payment_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.outbound_payment.failed", &handler)
end

#on_v2_money_management_outbound_payment_posted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2183
2184
2185
2186
2187
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2183

def on_v2_money_management_outbound_payment_posted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.outbound_payment.posted", &handler)
end

#on_v2_money_management_outbound_payment_returned(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2189
2190
2191
2192
2193
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2189

def on_v2_money_management_outbound_payment_returned(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.outbound_payment.returned", &handler)
end

#on_v2_money_management_outbound_payment_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2195
2196
2197
2198
2199
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2195

def on_v2_money_management_outbound_payment_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.outbound_payment.updated", &handler)
end

#on_v2_money_management_outbound_transfer_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2201
2202
2203
2204
2205
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2201

def on_v2_money_management_outbound_transfer_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.outbound_transfer.canceled", &handler)
end

#on_v2_money_management_outbound_transfer_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2207
2208
2209
2210
2211
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2207

def on_v2_money_management_outbound_transfer_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.outbound_transfer.created", &handler)
end

#on_v2_money_management_outbound_transfer_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2213
2214
2215
2216
2217
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2213

def on_v2_money_management_outbound_transfer_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.outbound_transfer.failed", &handler)
end

#on_v2_money_management_outbound_transfer_posted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2219
2220
2221
2222
2223
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2219

def on_v2_money_management_outbound_transfer_posted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.outbound_transfer.posted", &handler)
end

#on_v2_money_management_outbound_transfer_returned(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2225
2226
2227
2228
2229
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2225

def on_v2_money_management_outbound_transfer_returned(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.outbound_transfer.returned", &handler)
end

#on_v2_money_management_outbound_transfer_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2231
2232
2233
2234
2235
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2231

def on_v2_money_management_outbound_transfer_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.outbound_transfer.updated", &handler)
end

#on_v2_money_management_payout_method_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2237
2238
2239
2240
2241
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2237

def on_v2_money_management_payout_method_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.payout_method.created", &handler)
end

#on_v2_money_management_payout_method_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2243
2244
2245
2246
2247
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2243

def on_v2_money_management_payout_method_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.payout_method.updated", &handler)
end

#on_v2_money_management_received_credit_available(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2249
2250
2251
2252
2253
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2249

def on_v2_money_management_received_credit_available(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.received_credit.available", &handler)
end

#on_v2_money_management_received_credit_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2255
2256
2257
2258
2259
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2255

def on_v2_money_management_received_credit_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.received_credit.failed", &handler)
end

#on_v2_money_management_received_credit_returned(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2261
2262
2263
2264
2265
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2261

def on_v2_money_management_received_credit_returned(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.received_credit.returned", &handler)
end

#on_v2_money_management_received_credit_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2267
2268
2269
2270
2271
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2267

def on_v2_money_management_received_credit_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.received_credit.succeeded", &handler)
end

#on_v2_money_management_received_debit_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2273
2274
2275
2276
2277
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2273

def on_v2_money_management_received_debit_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.received_debit.canceled", &handler)
end

#on_v2_money_management_received_debit_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2279
2280
2281
2282
2283
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2279

def on_v2_money_management_received_debit_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.received_debit.failed", &handler)
end

#on_v2_money_management_received_debit_pending(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2285
2286
2287
2288
2289
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2285

def on_v2_money_management_received_debit_pending(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.received_debit.pending", &handler)
end

#on_v2_money_management_received_debit_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2291
2292
2293
2294
2295
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2291

def on_v2_money_management_received_debit_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.received_debit.succeeded", &handler)
end

#on_v2_money_management_received_debit_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2297
2298
2299
2300
2301
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2297

def on_v2_money_management_received_debit_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.received_debit.updated", &handler)
end

#on_v2_money_management_recipient_verification_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2303
2304
2305
2306
2307
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2303

def on_v2_money_management_recipient_verification_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.recipient_verification.created", &handler)
end

#on_v2_money_management_recipient_verification_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2309
2310
2311
2312
2313
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2309

def on_v2_money_management_recipient_verification_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.recipient_verification.updated", &handler)
end

#on_v2_money_management_transaction_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2315
2316
2317
2318
2319
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2315

def on_v2_money_management_transaction_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.transaction.created", &handler)
end

#on_v2_money_management_transaction_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2321
2322
2323
2324
2325
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2321

def on_v2_money_management_transaction_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.money_management.transaction.updated", &handler)
end

#on_v2_orchestrated_commerce_agreement_confirmed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2327
2328
2329
2330
2331
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2327

def on_v2_orchestrated_commerce_agreement_confirmed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.orchestrated_commerce.agreement.confirmed", &handler)
end

#on_v2_orchestrated_commerce_agreement_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2333
2334
2335
2336
2337
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2333

def on_v2_orchestrated_commerce_agreement_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.orchestrated_commerce.agreement.created", &handler)
end

#on_v2_orchestrated_commerce_agreement_partially_confirmed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2339
2340
2341
2342
2343
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2339

def on_v2_orchestrated_commerce_agreement_partially_confirmed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.orchestrated_commerce.agreement.partially_confirmed", &handler)
end

#on_v2_orchestrated_commerce_agreement_terminated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2345
2346
2347
2348
2349
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2345

def on_v2_orchestrated_commerce_agreement_terminated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.orchestrated_commerce.agreement.terminated", &handler)
end

#on_v2_payments_off_session_payment_attempt_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2351
2352
2353
2354
2355
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2351

def on_v2_payments_off_session_payment_attempt_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.off_session_payment.attempt_failed", &handler)
end

#on_v2_payments_off_session_payment_attempt_started(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2357
2358
2359
2360
2361
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2357

def on_v2_payments_off_session_payment_attempt_started(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.off_session_payment.attempt_started", &handler)
end

#on_v2_payments_off_session_payment_authorization_attempt_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2363
2364
2365
2366
2367
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2363

def on_v2_payments_off_session_payment_authorization_attempt_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.off_session_payment.authorization_attempt_failed", &handler)
end

#on_v2_payments_off_session_payment_authorization_attempt_started(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2369
2370
2371
2372
2373
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2369

def on_v2_payments_off_session_payment_authorization_attempt_started(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.off_session_payment.authorization_attempt_started", &handler)
end

#on_v2_payments_off_session_payment_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2375
2376
2377
2378
2379
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2375

def on_v2_payments_off_session_payment_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.off_session_payment.canceled", &handler)
end

#on_v2_payments_off_session_payment_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2381
2382
2383
2384
2385
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2381

def on_v2_payments_off_session_payment_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.off_session_payment.created", &handler)
end

#on_v2_payments_off_session_payment_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2387
2388
2389
2390
2391
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2387

def on_v2_payments_off_session_payment_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.off_session_payment.failed", &handler)
end

#on_v2_payments_off_session_payment_paused(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2393
2394
2395
2396
2397
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2393

def on_v2_payments_off_session_payment_paused(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.off_session_payment.paused", &handler)
end

#on_v2_payments_off_session_payment_requires_capture(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2399
2400
2401
2402
2403
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2399

def on_v2_payments_off_session_payment_requires_capture(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.off_session_payment.requires_capture", &handler)
end

#on_v2_payments_off_session_payment_resumed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2405
2406
2407
2408
2409
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2405

def on_v2_payments_off_session_payment_resumed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.off_session_payment.resumed", &handler)
end

#on_v2_payments_off_session_payment_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2411
2412
2413
2414
2415
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2411

def on_v2_payments_off_session_payment_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.off_session_payment.succeeded", &handler)
end

#on_v2_payments_settlement_allocation_intent_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2417
2418
2419
2420
2421
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2417

def on_v2_payments_settlement_allocation_intent_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.settlement_allocation_intent.canceled", &handler)
end

#on_v2_payments_settlement_allocation_intent_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2423
2424
2425
2426
2427
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2423

def on_v2_payments_settlement_allocation_intent_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.settlement_allocation_intent.created", &handler)
end

#on_v2_payments_settlement_allocation_intent_errored(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2429
2430
2431
2432
2433
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2429

def on_v2_payments_settlement_allocation_intent_errored(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.settlement_allocation_intent.errored", &handler)
end

#on_v2_payments_settlement_allocation_intent_funds_not_received(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2435
2436
2437
2438
2439
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2435

def on_v2_payments_settlement_allocation_intent_funds_not_received(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.settlement_allocation_intent.funds_not_received", &handler)
end

#on_v2_payments_settlement_allocation_intent_matched(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2441
2442
2443
2444
2445
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2441

def on_v2_payments_settlement_allocation_intent_matched(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.settlement_allocation_intent.matched", &handler)
end

#on_v2_payments_settlement_allocation_intent_not_found(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2447
2448
2449
2450
2451
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2447

def on_v2_payments_settlement_allocation_intent_not_found(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.settlement_allocation_intent.not_found", &handler)
end

#on_v2_payments_settlement_allocation_intent_settled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2453
2454
2455
2456
2457
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2453

def on_v2_payments_settlement_allocation_intent_settled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.settlement_allocation_intent.settled", &handler)
end

#on_v2_payments_settlement_allocation_intent_split_canceled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2465
2466
2467
2468
2469
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2465

def on_v2_payments_settlement_allocation_intent_split_canceled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.settlement_allocation_intent_split.canceled", &handler)
end

#on_v2_payments_settlement_allocation_intent_split_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2471
2472
2473
2474
2475
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2471

def on_v2_payments_settlement_allocation_intent_split_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.settlement_allocation_intent_split.created", &handler)
end

#on_v2_payments_settlement_allocation_intent_split_settled(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2477
2478
2479
2480
2481
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2477

def on_v2_payments_settlement_allocation_intent_split_settled(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.settlement_allocation_intent_split.settled", &handler)
end

#on_v2_payments_settlement_allocation_intent_submitted(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2459
2460
2461
2462
2463
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2459

def on_v2_payments_settlement_allocation_intent_submitted(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.payments.settlement_allocation_intent.submitted", &handler)
end

#on_v2_reporting_report_run_created(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2483
2484
2485
2486
2487
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2483

def on_v2_reporting_report_run_created(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.reporting.report_run.created", &handler)
end

#on_v2_reporting_report_run_failed(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2489
2490
2491
2492
2493
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2489

def on_v2_reporting_report_run_failed(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.reporting.report_run.failed", &handler)
end

#on_v2_reporting_report_run_succeeded(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2495
2496
2497
2498
2499
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2495

def on_v2_reporting_report_run_succeeded(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.reporting.report_run.succeeded", &handler)
end

#on_v2_reporting_report_run_updated(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2501
2502
2503
2504
2505
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2501

def on_v2_reporting_report_run_updated(&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.reporting.report_run.updated", &handler)
end

#on_v2_signals_account_signal_fraudulent_merchant_ready(&handler) ⇒ Object

Raises:

  • (ArgumentError) 


2507
2508
2509
2510
2511
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 2507

def (&handler)
  raise ArgumentError, "Block required to register event handler" if handler.nil?

  register("v2.signals.account_signal.fraudulent_merchant_ready", &handler)
end

#registered_event_types ⇒ Object 



48
49
50
 
# File 'lib/stripe/stripe_event_notification_handler.rb', line 48

def registered_event_types
  @registered_handlers.keys.sort
end