Class: CheckoutSdk::Payments::HostedPaymentsSession

Inherits:
Object
  • Object
show all
Defined in:
lib/checkout_sdk/payments/hosted/hosted_payments_session.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR) ⇒ HostedPaymentsSession 



102
103
104
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 102

def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
  @payment_type = payment_type
end

Instance Attribute Details

#allow_payment_methods ⇒ Array(CheckoutSdk::Common::PaymentSourceType) 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#amount ⇒ Integer 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#amount_allocations ⇒ Array(CheckoutSdk::Common::AmountAllocations) 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#billing ⇒ BillingInformation 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#billing_descriptor ⇒ BillingDescriptor 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#cancel_url ⇒ String 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#capture ⇒ TrueClass, FalseClass 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#capture_on ⇒ Time 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#currency ⇒ String 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#customer ⇒ CheckoutSdk::Common::CustomerRequest 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#customer_retry ⇒ PaymentRetryRequest 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#description ⇒ String 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#disabled_payment_methods ⇒ Array(CheckoutSdk::Common::PaymentSourceType) 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#display_name ⇒ String 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#failure_url ⇒ String 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#instruction ⇒ HostedPaymentInstruction 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#locale ⇒ String 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#metadata ⇒ Hash(String=>Object) 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#payment_ip ⇒ String 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#payment_method_configuration ⇒ PaymentMethodConfiguration 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#payment_type ⇒ String 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#processing ⇒ ProcessingSettings 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#processing_channel_id ⇒ String 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#products ⇒ Array(CheckoutSdk::Common::Product) 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#recipient ⇒ PaymentRecipient 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#reference ⇒ String 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#risk ⇒ RiskRequest 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#sender ⇒ CheckoutSdk::Payments::Sender 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#shipping ⇒ ShippingDetails 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#success_url ⇒ String 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end

#three_ds ⇒ ThreeDSRequest 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/checkout_sdk/payments/hosted/hosted_payments_session.rb', line 69

class HostedPaymentsSession
  attr_accessor :currency,
                :billing,
                :success_url,
                :cancel_url,
                :failure_url,
                :amount,
                :payment_type,
                :payment_ip,
                :billing_descriptor,
                :reference,
                :description,
                :display_name,
                :processing_channel_id,
                :amount_allocations,
                :customer,
                :shipping,
                :recipient,
                :processing,
                :allow_payment_methods,
                :disabled_payment_methods,
                :products,
                :risk,
                :customer_retry,
                :sender,
                :metadata,
                :locale,
                :three_ds,
                :capture,
                :capture_on,
                :instruction,
                :payment_method_configuration

  def initialize(payment_type: CheckoutSdk::Payments::PaymentType::REGULAR)
    @payment_type = payment_type
  end
end