Class: CyberSource::AgentCapabilitiesApi

#activate_agent_key(agent_id, key_id, opts = {}) ⇒ `AddAgentKeyResponse201`

Activate a key Activate a deactivated key. Raises 404 if agent or key not found, 403 if agent is deactivated.

Parameters:

agent_id —
Unique agent identifier
key_id —
Unique key identifier
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(AddAgentKeyResponse201)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 30

def activate_agent_key(agent_id, key_id, opts = {})
  data, status_code, headers = activate_agent_key_with_http_info(agent_id, key_id, opts)
  return data, status_code, headers
end

#activate_agent_key_with_http_info(agent_id, key_id, opts = {}) ⇒ `Array<(AddAgentKeyResponse201, Fixnum, Hash)>`

Activate a key Activate a deactivated key. Raises 404 if agent or key not found, 403 if agent is deactivated.

Parameters:

agent_id —
Unique agent identifier
key_id —
Unique key identifier
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(AddAgentKeyResponse201, Fixnum, Hash)>) —
AddAgentKeyResponse201 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 41

def activate_agent_key_with_http_info(agent_id, key_id, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.activate_agent_key ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'agent_id' is set
  if @api_client.config.client_side_validation && agent_id.nil?
    fail ArgumentError, "Missing the required parameter 'agent_id' when calling AgentCapabilitiesApi.activate_agent_key"
  end
  # verify the required parameter 'key_id' is set
  if @api_client.config.client_side_validation && key_id.nil?
    fail ArgumentError, "Missing the required parameter 'key_id' when calling AgentCapabilitiesApi.activate_agent_key"
  end
  # resource path
  local_var_path = 'icc/v1/agents/{agentId}/keys/{keyId}/activate'.sub('{' + 'agentId' + '}', agent_id.to_s).sub('{' + 'keyId' + '}', key_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  if 'POST' == 'POST'
    post_body = '{}'
  else
    post_body = nil
  end
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["activate_agent_key","activate_agent_key_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["activate_agent_key","activate_agent_key_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'AddAgentKeyResponse201',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#activate_agent_key\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#add_agent_key(agent_id, key_request, opts = {}) ⇒ `AddAgentKeyResponse201`

Add a key to an agent [category 1 — Agent_Capabilities] Upload a Base64-encoded public key for an agent.

Parameters:

agent_id —
Unique agent identifier
key_request —
Key creation request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(AddAgentKeyResponse201)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 119

def add_agent_key(agent_id, key_request, opts = {})
  data, status_code, headers = add_agent_key_with_http_info(agent_id, key_request, opts)
  return data, status_code, headers
end

#add_agent_key_with_http_info(agent_id, key_request, opts = {}) ⇒ `Array<(AddAgentKeyResponse201, Fixnum, Hash)>`

Add a key to an agent [category 1 — Agent_Capabilities] Upload a Base64-encoded public key for an agent.

Parameters:

agent_id —
Unique agent identifier
key_request —
Key creation request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(AddAgentKeyResponse201, Fixnum, Hash)>) —
AddAgentKeyResponse201 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 130

def add_agent_key_with_http_info(agent_id, key_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.add_agent_key ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'agent_id' is set
  if @api_client.config.client_side_validation && agent_id.nil?
    fail ArgumentError, "Missing the required parameter 'agent_id' when calling AgentCapabilitiesApi.add_agent_key"
  end
  # verify the required parameter 'key_request' is set
  if @api_client.config.client_side_validation && key_request.nil?
    fail ArgumentError, "Missing the required parameter 'key_request' when calling AgentCapabilitiesApi.add_agent_key"
  end
  # resource path
  local_var_path = 'icc/v1/agents/{agentId}/keys'.sub('{' + 'agentId' + '}', agent_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(key_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'KeyRequest', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["add_agent_key","add_agent_key_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["add_agent_key","add_agent_key_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'AddAgentKeyResponse201',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#add_agent_key\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#cancel_checkout(session_id, opts = {}) ⇒ `InlineResponse20018`

Cancel Checkout ACP Cancels an active ACP checkout session. No charge is made to the buyer. This call is safe to make multiple times — cancelling an already-cancelled session returns a successful response without error. Sessions also expire automatically after 30 minutes of inactivity, so explicit cancellation is optional but recommended to release any reserved inventory immediately.

Parameters:

session_id —
The unique identifier of the ACP checkout session to cancel. Obtained from the `id` field in the Create Session response.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Client-generated unique key to ensure this request is processed exactly once. If a request with the same key was already processed, the original response is returned.
:accept_language (String) —
Preferred language for the response (e.g. `en-US`, `fr-FR`). Passed to the merchant backend for localized content.
:user_agent (String) —
Client user agent string identifying the AI agent platform and version.
:request_id (String) —
Unique request identifier for distributed tracing and debugging. Echoed back in the response headers.
:signature (String) —
Request signature for payload integrity verification.
:timestamp (String) —
ISO 8601 timestamp of when the request was generated. Used in conjunction with Signature for replay protection.
:api_version (String) —
ACP specification version the client is targeting (e.g. `2024-01-01`). When omitted, the latest supported version is assumed.

Returns:

(InlineResponse20018)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 212

def cancel_checkout(session_id, opts = {})
  data, status_code, headers = cancel_checkout_with_http_info(session_id, opts)
  return data, status_code, headers
end

#cancel_checkout_with_http_info(session_id, opts = {}) ⇒ `Array<(InlineResponse20018, Fixnum, Hash)>`

Cancel Checkout ACP Cancels an active ACP checkout session. No charge is made to the buyer. This call is safe to make multiple times — cancelling an already-cancelled session returns a successful response without error. Sessions also expire automatically after 30 minutes of inactivity, so explicit cancellation is optional but recommended to release any reserved inventory immediately.

Parameters:

session_id —
The unique identifier of the ACP checkout session to cancel. Obtained from the `id` field in the Create Session response.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Client-generated unique key to ensure this request is processed exactly once. If a request with the same key was already processed, the original response is returned.
:accept_language (String) —
Preferred language for the response (e.g. `en-US`, `fr-FR`). Passed to the merchant backend for localized content.
:user_agent (String) —
Client user agent string identifying the AI agent platform and version.
:request_id (String) —
Unique request identifier for distributed tracing and debugging. Echoed back in the response headers.
:signature (String) —
Request signature for payload integrity verification.
:timestamp (String) —
ISO 8601 timestamp of when the request was generated. Used in conjunction with Signature for replay protection.
:api_version (String) —
ACP specification version the client is targeting (e.g. `2024-01-01`). When omitted, the latest supported version is assumed.

Returns:

(Array<(InlineResponse20018, Fixnum, Hash)>) —
InlineResponse20018 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 229

def cancel_checkout_with_http_info(session_id, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.cancel_checkout ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'session_id' is set
  if @api_client.config.client_side_validation && session_id.nil?
    fail ArgumentError, "Missing the required parameter 'session_id' when calling AgentCapabilitiesApi.cancel_checkout"
  end
  # resource path
  local_var_path = 'icc/v1/checkout_sessions/{session_id}/cancel'.sub('{' + 'session_id' + '}', session_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])
  header_params[:'Idempotency-Key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?
  header_params[:'Accept-Language'] = opts[:'accept_language'] if !opts[:'accept_language'].nil?
  header_params[:'User-Agent'] = opts[:'user_agent'] if !opts[:'user_agent'].nil?
  header_params[:'Request-Id'] = opts[:'request_id'] if !opts[:'request_id'].nil?
  header_params[:'Signature'] = opts[:'signature'] if !opts[:'signature'].nil?
  header_params[:'Timestamp'] = opts[:'timestamp'] if !opts[:'timestamp'].nil?
  header_params[:'API-Version'] = opts[:'api_version'] if !opts[:'api_version'].nil?

  # form parameters
  form_params = {}

  # http body (model)
  if 'POST' == 'POST'
    post_body = '{}'
  else
    post_body = nil
  end
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["cancel_checkout","cancel_checkout_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["cancel_checkout","cancel_checkout_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'InlineResponse20018',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#cancel_checkout\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#cancel_purchase_intent(instruction_id, agentic_cancel_purchase_intent_request, opts = {}) ⇒ `AgenticCreatePurchaseIntentResponse200`

Cancel a purchase intent Cancel an existing purchase intent (instruction) identified by its instructionId. The agent calls this endpoint when the consumer decides to abandon the purchase before payment credentials have been used. Requires device information and assurance data for identity verification. Returns status CANCELLED (HTTP 200) on success, or PENDING (HTTP 202) with pendingEvents if cardholder authentication is required before cancellation can proceed.

Parameters:

instruction_id
agentic_cancel_purchase_intent_request —
Unique identifier for the purchase intent instruction.
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(AgenticCreatePurchaseIntentResponse200)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 310

def cancel_purchase_intent(instruction_id, agentic_cancel_purchase_intent_request, opts = {})
  data, status_code, headers = cancel_purchase_intent_with_http_info(instruction_id, agentic_cancel_purchase_intent_request, opts)
  return data, status_code, headers
end

#cancel_purchase_intent_with_http_info(instruction_id, agentic_cancel_purchase_intent_request, opts = {}) ⇒ `Array<(AgenticCreatePurchaseIntentResponse200, Fixnum, Hash)>`

Cancel a purchase intent Cancel an existing purchase intent (instruction) identified by its instructionId. The agent calls this endpoint when the consumer decides to abandon the purchase before payment credentials have been used. Requires device information and assurance data for identity verification. Returns status CANCELLED (HTTP 200) on success, or PENDING (HTTP 202) with pendingEvents if cardholder authentication is required before cancellation can proceed.

Parameters:

instruction_id
agentic_cancel_purchase_intent_request —
Unique identifier for the purchase intent instruction.
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(AgenticCreatePurchaseIntentResponse200, Fixnum, Hash)>) —
AgenticCreatePurchaseIntentResponse200 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 321

def cancel_purchase_intent_with_http_info(instruction_id, agentic_cancel_purchase_intent_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.cancel_purchase_intent ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'instruction_id' is set
  if @api_client.config.client_side_validation && instruction_id.nil?
    fail ArgumentError, "Missing the required parameter 'instruction_id' when calling AgentCapabilitiesApi.cancel_purchase_intent"
  end
  # verify the required parameter 'agentic_cancel_purchase_intent_request' is set
  if @api_client.config.client_side_validation && agentic_cancel_purchase_intent_request.nil?
    fail ArgumentError, "Missing the required parameter 'agentic_cancel_purchase_intent_request' when calling AgentCapabilitiesApi.cancel_purchase_intent"
  end
  # resource path
  local_var_path = 'icc/v1/instructions/{instructionId}/cancel'.sub('{' + 'instructionId' + '}', instruction_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(agentic_cancel_purchase_intent_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'AgenticCancelPurchaseIntentRequest', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["cancel_purchase_intent","cancel_purchase_intent_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["cancel_purchase_intent","cancel_purchase_intent_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:PUT, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'AgenticCreatePurchaseIntentResponse200',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#cancel_purchase_intent\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#complete_checkout(session_id, acp_complete_checkout_request, opts = {}) ⇒ `InlineResponse20017`

Complete Checkout ACP Final step of the ACP checkout flow. Submits payment and buyer information to place the order with the merchant. On success, the session transitions to completed and an order_id is returned confirming the merchant accepted the order. Once completed, the session is immutable — it cannot be updated or cancelled. Payment token: The payment.token must be a valid token from the payment provider configured for the merchant (e.g. a tokenized card from Stripe or Braintree). ACG forwards the token to the merchant's payment processor — it is never stored.

Parameters:

session_id —
The unique identifier of the ACP checkout session to complete.
acp_complete_checkout_request —
Final buyer and payment details needed to place the order. Both `buyer` and `payment` may have been provided in earlier Create/Update calls; if so, they can be omitted here. At least a valid payment token is required to process the transaction.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Client-generated unique key to ensure this request is processed exactly once. If a request with the same key was already processed, the original response is returned.
:accept_language (String) —
Preferred language for the response (e.g. `en-US`, `fr-FR`). Passed to the merchant backend for localized content.
:user_agent (String) —
Client user agent string identifying the AI agent platform and version.
:request_id (String) —
Unique request identifier for distributed tracing and debugging. Echoed back in the response headers.
:signature (String) —
Request signature for payload integrity verification.
:timestamp (String) —
ISO 8601 timestamp of when the request was generated. Used in conjunction with Signature for replay protection.
:api_version (String) —
ACP specification version the client is targeting (e.g. `2024-01-01`). When omitted, the latest supported version is assumed.

Returns:

(InlineResponse20017)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 404

def complete_checkout(session_id, acp_complete_checkout_request, opts = {})
  data, status_code, headers = complete_checkout_with_http_info(session_id, acp_complete_checkout_request, opts)
  return data, status_code, headers
end

#complete_checkout_with_http_info(session_id, acp_complete_checkout_request, opts = {}) ⇒ `Array<(InlineResponse20017, Fixnum, Hash)>`

Complete Checkout ACP Final step of the ACP checkout flow. Submits payment and buyer information to place the order with the merchant. On success, the session transitions to `completed` and an `order_id` is returned confirming the merchant accepted the order. Once completed, the session is immutable — it cannot be updated or cancelled. Payment token: The `payment.token` must be a valid token from the payment provider configured for the merchant (e.g. a tokenized card from Stripe or Braintree). ACG forwards the token to the merchant's payment processor — it is never stored.

Parameters:

session_id —
The unique identifier of the ACP checkout session to complete.
acp_complete_checkout_request —
Final buyer and payment details needed to place the order. Both `buyer` and `payment` may have been provided in earlier Create/Update calls; if so, they can be omitted here. At least a valid payment token is required to process the transaction.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Client-generated unique key to ensure this request is processed exactly once. If a request with the same key was already processed, the original response is returned.
:accept_language (String) —
Preferred language for the response (e.g. `en-US`, `fr-FR`). Passed to the merchant backend for localized content.
:user_agent (String) —
Client user agent string identifying the AI agent platform and version.
:request_id (String) —
Unique request identifier for distributed tracing and debugging. Echoed back in the response headers.
:signature (String) —
Request signature for payload integrity verification.
:timestamp (String) —
ISO 8601 timestamp of when the request was generated. Used in conjunction with Signature for replay protection.
:api_version (String) —
ACP specification version the client is targeting (e.g. `2024-01-01`). When omitted, the latest supported version is assumed.

Returns:

(Array<(InlineResponse20017, Fixnum, Hash)>) —
InlineResponse20017 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 422

def complete_checkout_with_http_info(session_id, acp_complete_checkout_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.complete_checkout ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'session_id' is set
  if @api_client.config.client_side_validation && session_id.nil?
    fail ArgumentError, "Missing the required parameter 'session_id' when calling AgentCapabilitiesApi.complete_checkout"
  end
  # verify the required parameter 'acp_complete_checkout_request' is set
  if @api_client.config.client_side_validation && acp_complete_checkout_request.nil?
    fail ArgumentError, "Missing the required parameter 'acp_complete_checkout_request' when calling AgentCapabilitiesApi.complete_checkout"
  end
  # resource path
  local_var_path = 'icc/v1/checkout_sessions/{session_id}/complete'.sub('{' + 'session_id' + '}', session_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])
  header_params[:'Idempotency-Key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?
  header_params[:'Accept-Language'] = opts[:'accept_language'] if !opts[:'accept_language'].nil?
  header_params[:'User-Agent'] = opts[:'user_agent'] if !opts[:'user_agent'].nil?
  header_params[:'Request-Id'] = opts[:'request_id'] if !opts[:'request_id'].nil?
  header_params[:'Signature'] = opts[:'signature'] if !opts[:'signature'].nil?
  header_params[:'Timestamp'] = opts[:'timestamp'] if !opts[:'timestamp'].nil?
  header_params[:'API-Version'] = opts[:'api_version'] if !opts[:'api_version'].nil?

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(acp_complete_checkout_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'AcpCompleteCheckoutRequest', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["complete_checkout","complete_checkout_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["complete_checkout","complete_checkout_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'InlineResponse20017',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#complete_checkout\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#confirm_transaction_events(instruction_id, agentic_confirm_transaction_events_request, opts = {}) ⇒ `AgenticConfirmTransactionEventsResponse202`

Confirm transaction events Confirm transaction events for a completed purchase. The agent calls this endpoint after the payment has been submitted to notify the Intelligent Commerce Connect of the transaction outcome. The request includes processor information (transaction type, status, approval codes), order details (shipping, tracking, product information), and merchant information. Returns HTTP 202 acknowledging receipt of the confirmation.

Parameters:

instruction_id —
Unique identifier for the purchase intent instruction.
agentic_confirm_transaction_events_request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(AgenticConfirmTransactionEventsResponse202)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 505

def confirm_transaction_events(instruction_id, agentic_confirm_transaction_events_request, opts = {})
  data, status_code, headers = confirm_transaction_events_with_http_info(instruction_id, agentic_confirm_transaction_events_request, opts)
  return data, status_code, headers
end

#confirm_transaction_events_with_http_info(instruction_id, agentic_confirm_transaction_events_request, opts = {}) ⇒ `Array<(AgenticConfirmTransactionEventsResponse202, Fixnum, Hash)>`

Confirm transaction events Confirm transaction events for a completed purchase. The agent calls this endpoint after the payment has been submitted to notify the Intelligent Commerce Connect of the transaction outcome. The request includes processor information (transaction type, status, approval codes), order details (shipping, tracking, product information), and merchant information. Returns HTTP 202 acknowledging receipt of the confirmation.

Parameters:

instruction_id —
Unique identifier for the purchase intent instruction.
agentic_confirm_transaction_events_request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(AgenticConfirmTransactionEventsResponse202, Fixnum, Hash)>) —
AgenticConfirmTransactionEventsResponse202 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 516

def confirm_transaction_events_with_http_info(instruction_id, agentic_confirm_transaction_events_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.confirm_transaction_events ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'instruction_id' is set
  if @api_client.config.client_side_validation && instruction_id.nil?
    fail ArgumentError, "Missing the required parameter 'instruction_id' when calling AgentCapabilitiesApi.confirm_transaction_events"
  end
  # verify the required parameter 'agentic_confirm_transaction_events_request' is set
  if @api_client.config.client_side_validation && agentic_confirm_transaction_events_request.nil?
    fail ArgumentError, "Missing the required parameter 'agentic_confirm_transaction_events_request' when calling AgentCapabilitiesApi.confirm_transaction_events"
  end
  # resource path
  local_var_path = 'icc/v1/instructions/{instructionId}/confirmations'.sub('{' + 'instructionId' + '}', instruction_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(agentic_confirm_transaction_events_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'AgenticConfirmTransactionEventsRequest', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["confirm_transaction_events","confirm_transaction_events_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["confirm_transaction_events","confirm_transaction_events_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'AgenticConfirmTransactionEventsResponse202',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#confirm_transaction_events\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#create_checkout_session(acp_create_checkout_session_request, opts = {}) ⇒ `InlineResponse20113`

Create Checkout Session ACP Step 1 of the ACP checkout flow. Initiates a new ACP checkout session with the buyer's cart. ACG validates item availability against the merchant's catalog, calculates initial pricing and tax, and returns a session object with a unique id. Store the id — every subsequent call in this checkout flow (update, complete, cancel) requires it. The session remains active for 30 minutes. A new session must be created after expiry. Idempotency: Supply an Idempotency-Key header to safely retry this call without creating duplicate sessions.

Parameters:

acp_create_checkout_session_request —
The cart contents and buyer context for this checkout session. `items` is required. `buyer` and `fulfillment_address` are optional on creation and can be provided via Update Session before completing checkout.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Client-generated unique key to ensure this request is processed exactly once. If a request with the same key was already processed, the original response is returned.
:accept_language (String) —
Preferred language for the response (e.g. `en-US`, `fr-FR`). Passed to the merchant backend for localized content.
:user_agent (String) —
Client user agent string identifying the AI agent platform and version.
:request_id (String) —
Unique request identifier for distributed tracing and debugging. Echoed back in the response headers.
:signature (String) —
Request signature for payload integrity verification.
:timestamp (String) —
ISO 8601 timestamp of when the request was generated. Used in conjunction with Signature for replay protection.
:api_version (String) —
ACP specification version the client is targeting (e.g. `2024-01-01`). When omitted, the latest supported version is assumed.

Returns:

(InlineResponse20113)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 598

def create_checkout_session(acp_create_checkout_session_request, opts = {})
  data, status_code, headers = create_checkout_session_with_http_info(acp_create_checkout_session_request, opts)
  return data, status_code, headers
end

#create_checkout_session_with_http_info(acp_create_checkout_session_request, opts = {}) ⇒ `Array<(InlineResponse20113, Fixnum, Hash)>`

Create Checkout Session ACP Step 1 of the ACP checkout flow. Initiates a new ACP checkout session with the buyer's cart. ACG validates item availability against the merchant's catalog, calculates initial pricing and tax, and returns a session object with a unique `id`. Store the `id` — every subsequent call in this checkout flow (update, complete, cancel) requires it. The session remains active for 30 minutes. A new session must be created after expiry. Idempotency: Supply an `Idempotency-Key` header to safely retry this call without creating duplicate sessions.

Parameters:

acp_create_checkout_session_request —
The cart contents and buyer context for this checkout session. `items` is required. `buyer` and `fulfillment_address` are optional on creation and can be provided via Update Session before completing checkout.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Client-generated unique key to ensure this request is processed exactly once. If a request with the same key was already processed, the original response is returned.
:accept_language (String) —
Preferred language for the response (e.g. `en-US`, `fr-FR`). Passed to the merchant backend for localized content.
:user_agent (String) —
Client user agent string identifying the AI agent platform and version.
:request_id (String) —
Unique request identifier for distributed tracing and debugging. Echoed back in the response headers.
:signature (String) —
Request signature for payload integrity verification.
:timestamp (String) —
ISO 8601 timestamp of when the request was generated. Used in conjunction with Signature for replay protection.
:api_version (String) —
ACP specification version the client is targeting (e.g. `2024-01-01`). When omitted, the latest supported version is assumed.

Returns:

(Array<(InlineResponse20113, Fixnum, Hash)>) —
InlineResponse20113 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 615

def create_checkout_session_with_http_info(acp_create_checkout_session_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.create_checkout_session ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'acp_create_checkout_session_request' is set
  if @api_client.config.client_side_validation && acp_create_checkout_session_request.nil?
    fail ArgumentError, "Missing the required parameter 'acp_create_checkout_session_request' when calling AgentCapabilitiesApi.create_checkout_session"
  end
  # resource path
  local_var_path = 'icc/v1/checkout_sessions'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])
  header_params[:'Idempotency-Key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?
  header_params[:'Accept-Language'] = opts[:'accept_language'] if !opts[:'accept_language'].nil?
  header_params[:'User-Agent'] = opts[:'user_agent'] if !opts[:'user_agent'].nil?
  header_params[:'Request-Id'] = opts[:'request_id'] if !opts[:'request_id'].nil?
  header_params[:'Signature'] = opts[:'signature'] if !opts[:'signature'].nil?
  header_params[:'Timestamp'] = opts[:'timestamp'] if !opts[:'timestamp'].nil?
  header_params[:'API-Version'] = opts[:'api_version'] if !opts[:'api_version'].nil?

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(acp_create_checkout_session_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'AcpCreateCheckoutSessionRequest', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["create_checkout_session","create_checkout_session_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["create_checkout_session","create_checkout_session_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'InlineResponse20113',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#create_checkout_session\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#deactivate_agent_key(agent_id, key_id, opts = {}) ⇒ `nil`

Deactivate a key Deactivate a key (soft delete). Raises 404 if key not found.

Parameters:

agent_id —
Unique agent identifier
key_id —
Unique key identifier
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(nil)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 694

def deactivate_agent_key(agent_id, key_id, opts = {})
  data, status_code, headers = deactivate_agent_key_with_http_info(agent_id, key_id, opts)
  return data, status_code, headers
end

#deactivate_agent_key_with_http_info(agent_id, key_id, opts = {}) ⇒ `Array<(nil, Fixnum, Hash)>`

Deactivate a key Deactivate a key (soft delete). Raises 404 if key not found.

Parameters:

agent_id —
Unique agent identifier
key_id —
Unique key identifier
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(nil, Fixnum, Hash)>) —
nil, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 705

def deactivate_agent_key_with_http_info(agent_id, key_id, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.deactivate_agent_key ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'agent_id' is set
  if @api_client.config.client_side_validation && agent_id.nil?
    fail ArgumentError, "Missing the required parameter 'agent_id' when calling AgentCapabilitiesApi.deactivate_agent_key"
  end
  # verify the required parameter 'key_id' is set
  if @api_client.config.client_side_validation && key_id.nil?
    fail ArgumentError, "Missing the required parameter 'key_id' when calling AgentCapabilitiesApi.deactivate_agent_key"
  end
  # resource path
  local_var_path = 'icc/v1/agents/{agentId}/keys/{keyId}'.sub('{' + 'agentId' + '}', agent_id.to_s).sub('{' + 'keyId' + '}', key_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  if 'DELETE' == 'POST'
    post_body = '{}'
  else
    post_body = nil
  end
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["deactivate_agent_key","deactivate_agent_key_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["deactivate_agent_key","deactivate_agent_key_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:DELETE, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#deactivate_agent_key\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#enroll_card(agentic_card_enrollment_request, opts = {}) ⇒ `AgenticCardEnrollmentResponse200`

Enroll a card Enroll a payment card for agentic or e-commerce transactions. This is typically the first step in the Intelligent Commerce payment lifecycle — the agent calls this endpoint to register a consumer's card, creating a tokenized reference that can be used in subsequent purchase instructions and payment credential retrieval. Requires device information, consumer identity, billing details, and payment instrument references. Returns a status of ACTIVE (HTTP 200) if enrollment completes immediately, or PENDING (HTTP 202) with pendingEvents if cardholder authentication is required. Call this endpoint when a consumer wants to add a new payment card or when setting up a card for agentic payment flows.

Parameters:

agentic_card_enrollment_request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(AgenticCardEnrollmentResponse200)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 781

def enroll_card(agentic_card_enrollment_request, opts = {})
  data, status_code, headers = enroll_card_with_http_info(agentic_card_enrollment_request, opts)
  return data, status_code, headers
end

#enroll_card_with_http_info(agentic_card_enrollment_request, opts = {}) ⇒ `Array<(AgenticCardEnrollmentResponse200, Fixnum, Hash)>`

Enroll a card Enroll a payment card for agentic or e-commerce transactions. This is typically the first step in the Intelligent Commerce payment lifecycle — the agent calls this endpoint to register a consumer's card, creating a tokenized reference that can be used in subsequent purchase instructions and payment credential retrieval. Requires device information, consumer identity, billing details, and payment instrument references. Returns a status of ACTIVE (HTTP 200) if enrollment completes immediately, or PENDING (HTTP 202) with pendingEvents if cardholder authentication is required. Call this endpoint when a consumer wants to add a new payment card or when setting up a card for agentic payment flows.

Parameters:

agentic_card_enrollment_request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(AgenticCardEnrollmentResponse200, Fixnum, Hash)>) —
AgenticCardEnrollmentResponse200 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 791

def enroll_card_with_http_info(agentic_card_enrollment_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.enroll_card ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'agentic_card_enrollment_request' is set
  if @api_client.config.client_side_validation && agentic_card_enrollment_request.nil?
    fail ArgumentError, "Missing the required parameter 'agentic_card_enrollment_request' when calling AgentCapabilitiesApi.enroll_card"
  end
  # resource path
  local_var_path = 'icc/v1/tokens'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(agentic_card_enrollment_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'AgenticCardEnrollmentRequest', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["enroll_card","enroll_card_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["enroll_card","enroll_card_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'AgenticCardEnrollmentResponse200',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#enroll_card\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#get_agent(agent_id, opts = {}) ⇒ `AgentRegistrationResponse201`

Get an agent [category 1 — Agent_Capabilities] Get agent by ID with all keys. Raises 404 if agent not found.

Parameters:

agent_id —
Unique agent identifier
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(AgentRegistrationResponse201)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 862

def get_agent(agent_id, opts = {})
  data, status_code, headers = get_agent_with_http_info(agent_id, opts)
  return data, status_code, headers
end

#get_agent_key(agent_id, key_id, opts = {}) ⇒ `AddAgentKeyResponse201`

Get a key by agent and key ID Get a specific key by agent ID and key ID. Raises 404 if key not found.

Parameters:

agent_id —
Unique agent identifier
key_id —
Unique key identifier
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(AddAgentKeyResponse201)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 946

def get_agent_key(agent_id, key_id, opts = {})
  data, status_code, headers = get_agent_key_with_http_info(agent_id, key_id, opts)
  return data, status_code, headers
end

#get_agent_key_with_http_info(agent_id, key_id, opts = {}) ⇒ `Array<(AddAgentKeyResponse201, Fixnum, Hash)>`

Get a key by agent and key ID Get a specific key by agent ID and key ID. Raises 404 if key not found.

Parameters:

agent_id —
Unique agent identifier
key_id —
Unique key identifier
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(AddAgentKeyResponse201, Fixnum, Hash)>) —
AddAgentKeyResponse201 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 957

def get_agent_key_with_http_info(agent_id, key_id, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.get_agent_key ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'agent_id' is set
  if @api_client.config.client_side_validation && agent_id.nil?
    fail ArgumentError, "Missing the required parameter 'agent_id' when calling AgentCapabilitiesApi.get_agent_key"
  end
  # verify the required parameter 'key_id' is set
  if @api_client.config.client_side_validation && key_id.nil?
    fail ArgumentError, "Missing the required parameter 'key_id' when calling AgentCapabilitiesApi.get_agent_key"
  end
  # resource path
  local_var_path = 'icc/v1/agents/{agentId}/keys/{keyId}'.sub('{' + 'agentId' + '}', agent_id.to_s).sub('{' + 'keyId' + '}', key_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  if 'GET' == 'POST'
    post_body = '{}'
  else
    post_body = nil
  end
  inbound_mle_status = "false"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["get_agent_key","get_agent_key_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["get_agent_key","get_agent_key_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:GET, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'AddAgentKeyResponse201',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#get_agent_key\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#get_agent_with_http_info(agent_id, opts = {}) ⇒ `Array<(AgentRegistrationResponse201, Fixnum, Hash)>`

Get an agent [category 1 — Agent_Capabilities] Get agent by ID with all keys. Raises 404 if agent not found.

Parameters:

agent_id —
Unique agent identifier
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(AgentRegistrationResponse201, Fixnum, Hash)>) —
AgentRegistrationResponse201 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 872

def get_agent_with_http_info(agent_id, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.get_agent ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'agent_id' is set
  if @api_client.config.client_side_validation && agent_id.nil?
    fail ArgumentError, "Missing the required parameter 'agent_id' when calling AgentCapabilitiesApi.get_agent"
  end
  # resource path
  local_var_path = 'icc/v1/agents/{agentId}'.sub('{' + 'agentId' + '}', agent_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  if 'GET' == 'POST'
    post_body = '{}'
  else
    post_body = nil
  end
  inbound_mle_status = "false"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["get_agent","get_agent_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["get_agent","get_agent_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:GET, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'AgentRegistrationResponse201',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#get_agent\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#get_checkout_session(session_id, acp_get_checkout_session_request, opts = {}) ⇒ `InlineResponse20113`

Get Checkout Session ACP Retrieves the current state of an ACP checkout session, including line items, buyer information, and current totals. Use this to: - Verify session status before presenting a checkout summary to the buyer - Resume an interrupted checkout flow - Poll for status after an async operation - Confirm a session has not expired before submitting payment

Parameters:

session_id —
The unique identifier of the ACP checkout session to retrieve. Obtained from the `id` field in the Create Session response.
acp_get_checkout_session_request —
Empty request body.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Client-generated unique key to ensure this request is processed exactly once. If a request with the same key was already processed, the original response is returned.
:accept_language (String) —
Preferred language for the response (e.g. `en-US`, `fr-FR`). Passed to the merchant backend for localized content.
:user_agent (String) —
Client user agent string identifying the AI agent platform and version.
:request_id (String) —
Unique request identifier for distributed tracing and debugging. Echoed back in the response headers.
:signature (String) —
Request signature for payload integrity verification.
:timestamp (String) —
ISO 8601 timestamp of when the request was generated. Used in conjunction with Signature for replay protection.
:api_version (String) —
ACP specification version the client is targeting (e.g. `2024-01-01`). When omitted, the latest supported version is assumed.

Returns:

(InlineResponse20113)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1042

def get_checkout_session(session_id, acp_get_checkout_session_request, opts = {})
  data, status_code, headers = get_checkout_session_with_http_info(session_id, acp_get_checkout_session_request, opts)
  return data, status_code, headers
end

#get_checkout_session_with_http_info(session_id, acp_get_checkout_session_request, opts = {}) ⇒ `Array<(InlineResponse20113, Fixnum, Hash)>`

Get Checkout Session ACP Retrieves the current state of an ACP checkout session, including line items, buyer information, and current totals. Use this to: - Verify session status before presenting a checkout summary to the buyer - Resume an interrupted checkout flow - Poll for status after an async operation - Confirm a session has not expired before submitting payment

Parameters:

session_id —
The unique identifier of the ACP checkout session to retrieve. Obtained from the `id` field in the Create Session response.
acp_get_checkout_session_request —
Empty request body.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Client-generated unique key to ensure this request is processed exactly once. If a request with the same key was already processed, the original response is returned.
:accept_language (String) —
Preferred language for the response (e.g. `en-US`, `fr-FR`). Passed to the merchant backend for localized content.
:user_agent (String) —
Client user agent string identifying the AI agent platform and version.
:request_id (String) —
Unique request identifier for distributed tracing and debugging. Echoed back in the response headers.
:signature (String) —
Request signature for payload integrity verification.
:timestamp (String) —
ISO 8601 timestamp of when the request was generated. Used in conjunction with Signature for replay protection.
:api_version (String) —
ACP specification version the client is targeting (e.g. `2024-01-01`). When omitted, the latest supported version is assumed.

Returns:

(Array<(InlineResponse20113, Fixnum, Hash)>) —
InlineResponse20113 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1060

def get_checkout_session_with_http_info(session_id, acp_get_checkout_session_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.get_checkout_session ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'session_id' is set
  if @api_client.config.client_side_validation && session_id.nil?
    fail ArgumentError, "Missing the required parameter 'session_id' when calling AgentCapabilitiesApi.get_checkout_session"
  end
  # verify the required parameter 'acp_get_checkout_session_request' is set
  if @api_client.config.client_side_validation && acp_get_checkout_session_request.nil?
    fail ArgumentError, "Missing the required parameter 'acp_get_checkout_session_request' when calling AgentCapabilitiesApi.get_checkout_session"
  end
  # resource path
  local_var_path = 'icc/v1/checkout_sessions/{session_id}'.sub('{' + 'session_id' + '}', session_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])
  header_params[:'Idempotency-Key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?
  header_params[:'Accept-Language'] = opts[:'accept_language'] if !opts[:'accept_language'].nil?
  header_params[:'User-Agent'] = opts[:'user_agent'] if !opts[:'user_agent'].nil?
  header_params[:'Request-Id'] = opts[:'request_id'] if !opts[:'request_id'].nil?
  header_params[:'Signature'] = opts[:'signature'] if !opts[:'signature'].nil?
  header_params[:'Timestamp'] = opts[:'timestamp'] if !opts[:'timestamp'].nil?
  header_params[:'API-Version'] = opts[:'api_version'] if !opts[:'api_version'].nil?

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(acp_get_checkout_session_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'Object', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "false"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["get_checkout_session","get_checkout_session_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["get_checkout_session","get_checkout_session_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:GET, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'InlineResponse20113',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#get_checkout_session\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#initiate_purchase_intent(agentic_create_purchase_intent_request, opts = {}) ⇒ `AgenticCreatePurchaseIntentResponse200`

Initiate a purchase intent Create a new purchase intent (instruction) for an agentic transaction. The agent calls this endpoint after a card has been enrolled to define what the consumer wants to buy. The request includes payment instrument references, device and assurance data, mandates (spending limits, merchant preferences, and product descriptions), and optional buyer information. Return an instructionId (HTTP 200) if the intent is created immediately, or PENDING (HTTP 202) with pendingEvents if cardholder authentication is required. The instructionId returned is used in all subsequent operations - update, cancel, retrieve credentials, and confirm transaction.

Parameters:

agentic_create_purchase_intent_request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(AgenticCreatePurchaseIntentResponse200)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1142

def initiate_purchase_intent(agentic_create_purchase_intent_request, opts = {})
  data, status_code, headers = initiate_purchase_intent_with_http_info(agentic_create_purchase_intent_request, opts)
  return data, status_code, headers
end

#initiate_purchase_intent_with_http_info(agentic_create_purchase_intent_request, opts = {}) ⇒ `Array<(AgenticCreatePurchaseIntentResponse200, Fixnum, Hash)>`

Initiate a purchase intent Create a new purchase intent (instruction) for an agentic transaction. The agent calls this endpoint after a card has been enrolled to define what the consumer wants to buy. The request includes payment instrument references, device and assurance data, mandates (spending limits, merchant preferences, and product descriptions), and optional buyer information. Return an instructionId (HTTP 200) if the intent is created immediately, or PENDING (HTTP 202) with pendingEvents if cardholder authentication is required. The instructionId returned is used in all subsequent operations - update, cancel, retrieve credentials, and confirm transaction.

Parameters:

agentic_create_purchase_intent_request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(AgenticCreatePurchaseIntentResponse200, Fixnum, Hash)>) —
AgenticCreatePurchaseIntentResponse200 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1152

def initiate_purchase_intent_with_http_info(agentic_create_purchase_intent_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.initiate_purchase_intent ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'agentic_create_purchase_intent_request' is set
  if @api_client.config.client_side_validation && agentic_create_purchase_intent_request.nil?
    fail ArgumentError, "Missing the required parameter 'agentic_create_purchase_intent_request' when calling AgentCapabilitiesApi.initiate_purchase_intent"
  end
  # resource path
  local_var_path = 'icc/v1/instructions'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(agentic_create_purchase_intent_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'AgenticCreatePurchaseIntentRequest', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["initiate_purchase_intent","initiate_purchase_intent_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["initiate_purchase_intent","initiate_purchase_intent_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'AgenticCreatePurchaseIntentResponse200',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#initiate_purchase_intent\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#list_agent_keys(agent_id, opts = {}) ⇒ `ListAgentKeysResponse200`

List keys for an agent [category 1 — Agent_Capabilities] List all keys for a specific agent with pagination.

Parameters:

agent_id —
Unique agent identifier
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:page (Integer) —
Page number (1-indexed) (default to 1)
:page_size (Integer) —
Items per page (max 100) (default to 30)

Returns:

(ListAgentKeysResponse200)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1225

def list_agent_keys(agent_id, opts = {})
  data, status_code, headers = list_agent_keys_with_http_info(agent_id, opts)
  return data, status_code, headers
end

#list_agent_keys_with_http_info(agent_id, opts = {}) ⇒ `Array<(ListAgentKeysResponse200, Fixnum, Hash)>`

List keys for an agent [category 1 — Agent_Capabilities] List all keys for a specific agent with pagination.

Parameters:

agent_id —
Unique agent identifier
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:page (Integer) —
Page number (1-indexed)
:page_size (Integer) —
Items per page (max 100)

Returns:

(Array<(ListAgentKeysResponse200, Fixnum, Hash)>) —
ListAgentKeysResponse200 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1237

def list_agent_keys_with_http_info(agent_id, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.list_agent_keys ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'agent_id' is set
  if @api_client.config.client_side_validation && agent_id.nil?
    fail ArgumentError, "Missing the required parameter 'agent_id' when calling AgentCapabilitiesApi.list_agent_keys"
  end
  # resource path
  local_var_path = 'icc/v1/agents/{agentId}/keys'.sub('{' + 'agentId' + '}', agent_id.to_s)

  # query parameters
  query_params = {}
  query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
  query_params[:'pageSize'] = opts[:'page_size'] if !opts[:'page_size'].nil?

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  if 'GET' == 'POST'
    post_body = '{}'
  else
    post_body = nil
  end
  inbound_mle_status = "false"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["list_agent_keys","list_agent_keys_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["list_agent_keys","list_agent_keys_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:GET, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'ListAgentKeysResponse200',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#list_agent_keys\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#register_agent(agent_request, opts = {}) ⇒ `AgentRegistrationResponse201`

Register an agent Register a new AI agent in the VARS. Once registered, the agent can upload public keys that merchants and Visa services use to verify request signatures. Raises 409 if domain, contactEmail, or tokenRequestorId already exists.

Parameters:

agent_request —
Agent registration request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(AgentRegistrationResponse201)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1312

def register_agent(agent_request, opts = {})
  data, status_code, headers = register_agent_with_http_info(agent_request, opts)
  return data, status_code, headers
end

#register_agent_with_http_info(agent_request, opts = {}) ⇒ `Array<(AgentRegistrationResponse201, Fixnum, Hash)>`

Register an agent Register a new AI agent in the VARS. Once registered, the agent can upload public keys that merchants and Visa services use to verify request signatures. Raises 409 if domain, contactEmail, or tokenRequestorId already exists.

Parameters:

agent_request —
Agent registration request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(AgentRegistrationResponse201, Fixnum, Hash)>) —
AgentRegistrationResponse201 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1322

def register_agent_with_http_info(agent_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.register_agent ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'agent_request' is set
  if @api_client.config.client_side_validation && agent_request.nil?
    fail ArgumentError, "Missing the required parameter 'agent_request' when calling AgentCapabilitiesApi.register_agent"
  end
  # resource path
  local_var_path = 'icc/v1/agents'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(agent_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'AgentRequest', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["register_agent","register_agent_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["register_agent","register_agent_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'AgentRegistrationResponse201',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#register_agent\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#retrieve_payment_credentials(instruction_id, agentic_retrieve_payment_credentials_request, opts = {}) ⇒ `AgenticRetrievePaymentCredentialsResponse200`

Retrieve payment credentials Retrieve tokenized payment credentials for a purchase intent to complete the transaction at a merchant. The agent calls this endpoint after a purchase intent has been created and approved, providing transaction-level details including order information, merchant details, payment options, and production information. Returns COMPLETED (HTTP 200) with a signed payload containing encrypted payment credentials (authorization token and JWS-signed payload), or PENDING (HTTP 202) with pendingEvents if additional cardholder authentication is required. The signed payload is used by the merchant's payment processor to complete the transaction.

Parameters:

instruction_id —
Unique identifier for the purchase intent instruction.
agentic_retrieve_payment_credentials_request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(AgenticRetrievePaymentCredentialsResponse200)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1394

def retrieve_payment_credentials(instruction_id, agentic_retrieve_payment_credentials_request, opts = {})
  data, status_code, headers = retrieve_payment_credentials_with_http_info(instruction_id, agentic_retrieve_payment_credentials_request, opts)
  return data, status_code, headers
end

#retrieve_payment_credentials_with_http_info(instruction_id, agentic_retrieve_payment_credentials_request, opts = {}) ⇒ `Array<(AgenticRetrievePaymentCredentialsResponse200, Fixnum, Hash)>`

Retrieve payment credentials Retrieve tokenized payment credentials for a purchase intent to complete the transaction at a merchant. The agent calls this endpoint after a purchase intent has been created and approved, providing transaction-level details including order information, merchant details, payment options, and production information. Returns COMPLETED (HTTP 200) with a signed payload containing encrypted payment credentials (authorization token and JWS-signed payload), or PENDING (HTTP 202) with pendingEvents if additional cardholder authentication is required. The signed payload is used by the merchant's payment processor to complete the transaction.

Parameters:

instruction_id —
Unique identifier for the purchase intent instruction.
agentic_retrieve_payment_credentials_request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(AgenticRetrievePaymentCredentialsResponse200, Fixnum, Hash)>) —
AgenticRetrievePaymentCredentialsResponse200 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1405

def retrieve_payment_credentials_with_http_info(instruction_id, agentic_retrieve_payment_credentials_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.retrieve_payment_credentials ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'instruction_id' is set
  if @api_client.config.client_side_validation && instruction_id.nil?
    fail ArgumentError, "Missing the required parameter 'instruction_id' when calling AgentCapabilitiesApi.retrieve_payment_credentials"
  end
  # verify the required parameter 'agentic_retrieve_payment_credentials_request' is set
  if @api_client.config.client_side_validation && agentic_retrieve_payment_credentials_request.nil?
    fail ArgumentError, "Missing the required parameter 'agentic_retrieve_payment_credentials_request' when calling AgentCapabilitiesApi.retrieve_payment_credentials"
  end
  # resource path
  local_var_path = 'icc/v1/instructions/{instructionId}/credentials'.sub('{' + 'instructionId' + '}', instruction_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(agentic_retrieve_payment_credentials_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'AgenticRetrievePaymentCredentialsRequest', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["retrieve_payment_credentials","retrieve_payment_credentials_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["retrieve_payment_credentials","retrieve_payment_credentials_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'AgenticRetrievePaymentCredentialsResponse200',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#retrieve_payment_credentials\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#ucp_cancel_checkout(session_id, opts = {}) ⇒ `InlineResponse20114`

Cancel Checkout UCP Cancels an active UCP checkout session. No charge is made. This operation is idempotent — cancelling an already-cancelled session returns a successful response. Sessions also expire automatically after 30 minutes of inactivity.

Parameters:

session_id —
The unique identifier of the UCP checkout session to cancel.
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(InlineResponse20114)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1480

def ucp_cancel_checkout(session_id, opts = {})
  data, status_code, headers = ucp_cancel_checkout_with_http_info(session_id, opts)
  return data, status_code, headers
end

#ucp_cancel_checkout_with_http_info(session_id, opts = {}) ⇒ `Array<(InlineResponse20114, Fixnum, Hash)>`

Cancel Checkout UCP Cancels an active UCP checkout session. No charge is made. This operation is idempotent — cancelling an already-cancelled session returns a successful response. Sessions also expire automatically after 30 minutes of inactivity.

Parameters:

session_id —
The unique identifier of the UCP checkout session to cancel.
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(InlineResponse20114, Fixnum, Hash)>) —
InlineResponse20114 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1490

def ucp_cancel_checkout_with_http_info(session_id, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.ucp_cancel_checkout ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'session_id' is set
  if @api_client.config.client_side_validation && session_id.nil?
    fail ArgumentError, "Missing the required parameter 'session_id' when calling AgentCapabilitiesApi.ucp_cancel_checkout"
  end
  # resource path
  local_var_path = 'icc/v1/checkout-sessions/{session_id}/cancel'.sub('{' + 'session_id' + '}', session_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  if 'POST' == 'POST'
    post_body = '{}'
  else
    post_body = nil
  end
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["ucp_cancel_checkout","ucp_cancel_checkout_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["ucp_cancel_checkout","ucp_cancel_checkout_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'InlineResponse20114',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#ucp_cancel_checkout\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#ucp_complete_checkout(session_id, opts = {}) ⇒ `InlineResponse20114`

Complete Checkout UCP Final step of the UCP checkout flow. Finalizes the session and places the order with the merchant. ACG translates the UCP completion request to the merchant's checkout API. On success, the session transitions to completed. An order_id is not returned in the UCP response — use the ACP Complete endpoint if you need order confirmation details. Always use an idempotency-key to prevent duplicate orders on network retries.

Parameters:

session_id —
The unique identifier of the UCP checkout session to complete.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Strongly recommended. A unique key that ensures this order is placed exactly once on retries. Lowercase per UCP spec.
:ucp_complete_checkout_request (UcpCompleteCheckoutRequest) —
UCP completion payload containing payment instrument and optional risk signals. If payment context was already provided in the Create or Update call, the body can be omitted. Risk signals are logged for fraud analysis and are not forwarded to the merchant.

Returns:

(InlineResponse20114)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1565

def ucp_complete_checkout(session_id, opts = {})
  data, status_code, headers = ucp_complete_checkout_with_http_info(session_id, opts)
  return data, status_code, headers
end

#ucp_complete_checkout_with_http_info(session_id, opts = {}) ⇒ `Array<(InlineResponse20114, Fixnum, Hash)>`

Complete Checkout UCP Final step of the UCP checkout flow. Finalizes the session and places the order with the merchant. ACG translates the UCP completion request to the merchant's checkout API. On success, the session transitions to `completed`. An `order_id` is not returned in the UCP response — use the ACP Complete endpoint if you need order confirmation details. Always use an `idempotency-key` to prevent duplicate orders on network retries.

Parameters:

session_id —
The unique identifier of the UCP checkout session to complete.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Strongly recommended. A unique key that ensures this order is placed exactly once on retries. Lowercase per UCP spec.
:ucp_complete_checkout_request (UcpCompleteCheckoutRequest) —
UCP completion payload containing payment instrument and optional risk signals. If payment context was already provided in the Create or Update call, the body can be omitted. Risk signals are logged for fraud analysis and are not forwarded to the merchant.

Returns:

(Array<(InlineResponse20114, Fixnum, Hash)>) —
InlineResponse20114 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1577

def ucp_complete_checkout_with_http_info(session_id, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.ucp_complete_checkout ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'session_id' is set
  if @api_client.config.client_side_validation && session_id.nil?
    fail ArgumentError, "Missing the required parameter 'session_id' when calling AgentCapabilitiesApi.ucp_complete_checkout"
  end
  # resource path
  local_var_path = 'icc/v1/checkout-sessions/{session_id}/complete'.sub('{' + 'session_id' + '}', session_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])
  header_params[:'idempotency-key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(opts[:'ucp_complete_checkout_request'])
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'UcpCompleteCheckoutRequest', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["ucp_complete_checkout","ucp_complete_checkout_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["ucp_complete_checkout","ucp_complete_checkout_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'InlineResponse20114',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#ucp_complete_checkout\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#ucp_create_checkout_session(ucp_create_checkout_session_request, opts = {}) ⇒ `InlineResponse20114`

Create Checkout Session UCP Step 1 of the UCP checkout flow. Creates a new UCP checkout session using Google's Universal Commerce Protocol format. ACG translates the UCP request into the internal ACP format, applies merchant pricing, and returns a UCP-format session response with a session id. UCP uses line_items (instead of items) and lowercase header names (idempotency-key) per the UCP specification. Store the id from the response — it is required for all subsequent UCP calls.

Parameters:

ucp_create_checkout_session_request —
UCP checkout session creation payload containing line items, buyer details, currency, and optional payment, fulfillment, and discount information.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Client-generated unique key (UUID recommended) to ensure this request is processed exactly once. Lowercase per UCP specification.

Returns:

(InlineResponse20114)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1650

def ucp_create_checkout_session(ucp_create_checkout_session_request, opts = {})
  data, status_code, headers = ucp_create_checkout_session_with_http_info(ucp_create_checkout_session_request, opts)
  return data, status_code, headers
end

#ucp_create_checkout_session_with_http_info(ucp_create_checkout_session_request, opts = {}) ⇒ `Array<(InlineResponse20114, Fixnum, Hash)>`

Create Checkout Session UCP Step 1 of the UCP checkout flow. Creates a new UCP checkout session using Google's Universal Commerce Protocol format. ACG translates the UCP request into the internal ACP format, applies merchant pricing, and returns a UCP-format session response with a session `id`. UCP uses `line_items` (instead of `items`) and lowercase header names (`idempotency-key`) per the UCP specification. Store the `id` from the response — it is required for all subsequent UCP calls.

Parameters:

ucp_create_checkout_session_request —
UCP checkout session creation payload containing line items, buyer details, currency, and optional payment, fulfillment, and discount information.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Client-generated unique key (UUID recommended) to ensure this request is processed exactly once. Lowercase per UCP specification.

Returns:

(Array<(InlineResponse20114, Fixnum, Hash)>) —
InlineResponse20114 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1661

def ucp_create_checkout_session_with_http_info(ucp_create_checkout_session_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.ucp_create_checkout_session ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'ucp_create_checkout_session_request' is set
  if @api_client.config.client_side_validation && ucp_create_checkout_session_request.nil?
    fail ArgumentError, "Missing the required parameter 'ucp_create_checkout_session_request' when calling AgentCapabilitiesApi.ucp_create_checkout_session"
  end
  # resource path
  local_var_path = 'icc/v1/checkout-sessions'

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])
  header_params[:'idempotency-key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(ucp_create_checkout_session_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'UcpCreateCheckoutSessionRequest', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["ucp_create_checkout_session","ucp_create_checkout_session_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["ucp_create_checkout_session","ucp_create_checkout_session_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'InlineResponse20114',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#ucp_create_checkout_session\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#ucp_get_checkout_session(session_id, ucp_get_checkout_session_request, opts = {}) ⇒ `InlineResponse20114`

Get Checkout Session UCP Retrieves the current state of a UCP checkout session. Use this to verify session status, retrieve updated totals after a fulfillment change, or resume a session after an interruption.

Parameters:

session_id —
The unique identifier of the UCP checkout session to retrieve. Obtained from the `id` field in the Create Session response.
ucp_get_checkout_session_request —
Empty request body.
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(InlineResponse20114)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1734

def ucp_get_checkout_session(session_id, ucp_get_checkout_session_request, opts = {})
  data, status_code, headers = ucp_get_checkout_session_with_http_info(session_id, ucp_get_checkout_session_request, opts)
  return data, status_code, headers
end

#ucp_get_checkout_session_with_http_info(session_id, ucp_get_checkout_session_request, opts = {}) ⇒ `Array<(InlineResponse20114, Fixnum, Hash)>`

Get Checkout Session UCP Retrieves the current state of a UCP checkout session. Use this to verify session status, retrieve updated totals after a fulfillment change, or resume a session after an interruption.

Parameters:

session_id —
The unique identifier of the UCP checkout session to retrieve. Obtained from the `id` field in the Create Session response.
ucp_get_checkout_session_request —
Empty request body.
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(InlineResponse20114, Fixnum, Hash)>) —
InlineResponse20114 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1745

def ucp_get_checkout_session_with_http_info(session_id, ucp_get_checkout_session_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.ucp_get_checkout_session ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'session_id' is set
  if @api_client.config.client_side_validation && session_id.nil?
    fail ArgumentError, "Missing the required parameter 'session_id' when calling AgentCapabilitiesApi.ucp_get_checkout_session"
  end
  # verify the required parameter 'ucp_get_checkout_session_request' is set
  if @api_client.config.client_side_validation && ucp_get_checkout_session_request.nil?
    fail ArgumentError, "Missing the required parameter 'ucp_get_checkout_session_request' when calling AgentCapabilitiesApi.ucp_get_checkout_session"
  end
  # resource path
  local_var_path = 'icc/v1/checkout-sessions/{session_id}'.sub('{' + 'session_id' + '}', session_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(ucp_get_checkout_session_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'Object', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "false"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["ucp_get_checkout_session","ucp_get_checkout_session_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["ucp_get_checkout_session","ucp_get_checkout_session_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:GET, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'InlineResponse20114',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#ucp_get_checkout_session\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#ucp_update_checkout_session(session_id, ucp_update_checkout_session_request, opts = {}) ⇒ `InlineResponse20114`

Update Checkout Session UCP Modifies an active UCP checkout session and returns the updated session state. Use this to change line item quantities, update fulfillment address or method, or apply discount codes. Totals are recalculated and returned in the response. Only the fields you include in the request body are updated.

Parameters:

session_id —
The unique identifier of the UCP checkout session to update.
ucp_update_checkout_session_request —
UCP session update payload. All fields are optional — only fields you include will be applied.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Client-generated unique key for idempotency. Lowercase per UCP spec.

Returns:

(InlineResponse20114)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1822

def ucp_update_checkout_session(session_id, ucp_update_checkout_session_request, opts = {})
  data, status_code, headers = ucp_update_checkout_session_with_http_info(session_id, ucp_update_checkout_session_request, opts)
  return data, status_code, headers
end

#ucp_update_checkout_session_with_http_info(session_id, ucp_update_checkout_session_request, opts = {}) ⇒ `Array<(InlineResponse20114, Fixnum, Hash)>`

Update Checkout Session UCP Modifies an active UCP checkout session and returns the updated session state. Use this to change line item quantities, update fulfillment address or method, or apply discount codes. Totals are recalculated and returned in the response. Only the fields you include in the request body are updated.

Parameters:

session_id —
The unique identifier of the UCP checkout session to update.
ucp_update_checkout_session_request —
UCP session update payload. All fields are optional — only fields you include will be applied.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Client-generated unique key for idempotency. Lowercase per UCP spec.

Returns:

(Array<(InlineResponse20114, Fixnum, Hash)>) —
InlineResponse20114 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1834

def ucp_update_checkout_session_with_http_info(session_id, ucp_update_checkout_session_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.ucp_update_checkout_session ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'session_id' is set
  if @api_client.config.client_side_validation && session_id.nil?
    fail ArgumentError, "Missing the required parameter 'session_id' when calling AgentCapabilitiesApi.ucp_update_checkout_session"
  end
  # verify the required parameter 'ucp_update_checkout_session_request' is set
  if @api_client.config.client_side_validation && ucp_update_checkout_session_request.nil?
    fail ArgumentError, "Missing the required parameter 'ucp_update_checkout_session_request' when calling AgentCapabilitiesApi.ucp_update_checkout_session"
  end
  # resource path
  local_var_path = 'icc/v1/checkout-sessions/{session_id}'.sub('{' + 'session_id' + '}', session_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])
  header_params[:'idempotency-key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(ucp_update_checkout_session_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'UcpUpdateCheckoutSessionRequest', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["ucp_update_checkout_session","ucp_update_checkout_session_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["ucp_update_checkout_session","ucp_update_checkout_session_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:PUT, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'InlineResponse20114',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#ucp_update_checkout_session\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#update_agent(agent_id, agent_update, opts = {}) ⇒ `AgentRegistrationResponse201`

Update an agent [category 1 — Agent_Capabilities] Update agent information. Updatable fields are name, domain, description, contactEmail, and agentMetadata. Extra fields (e.g. tokenRequestorId, keys) will return 422 Validation Error. Raises 404 if agent not found, 403 if agent is deactivated, 409 if new domain or contactEmail already exists.

Parameters:

agent_id —
Unique agent identifier
agent_update —
Agent update request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(AgentRegistrationResponse201)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1911

def update_agent(agent_id, agent_update, opts = {})
  data, status_code, headers = update_agent_with_http_info(agent_id, agent_update, opts)
  return data, status_code, headers
end

#update_agent_key(agent_id, key_id, key_update, opts = {}) ⇒ `AddAgentKeyResponse201`

Update a key Update key information. Updatable fields are keyName, publicKey, algorithm, and expirationDate. Raises 404 if agent or key not found, 403 if agent or key is deactivated, 409 if new keyName already exists.

Parameters:

agent_id —
Unique agent identifier
key_id —
Unique key identifier
key_update —
Key update request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(AddAgentKeyResponse201)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1999

def update_agent_key(agent_id, key_id, key_update, opts = {})
  data, status_code, headers = update_agent_key_with_http_info(agent_id, key_id, key_update, opts)
  return data, status_code, headers
end

#update_agent_key_with_http_info(agent_id, key_id, key_update, opts = {}) ⇒ `Array<(AddAgentKeyResponse201, Fixnum, Hash)>`

Update a key Update key information. Updatable fields are keyName, publicKey, algorithm, and expirationDate. Raises 404 if agent or key not found, 403 if agent or key is deactivated, 409 if new keyName already exists.

Parameters:

agent_id —
Unique agent identifier
key_id —
Unique key identifier
key_update —
Key update request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(AddAgentKeyResponse201, Fixnum, Hash)>) —
AddAgentKeyResponse201 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 2011

def update_agent_key_with_http_info(agent_id, key_id, key_update, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.update_agent_key ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'agent_id' is set
  if @api_client.config.client_side_validation && agent_id.nil?
    fail ArgumentError, "Missing the required parameter 'agent_id' when calling AgentCapabilitiesApi.update_agent_key"
  end
  # verify the required parameter 'key_id' is set
  if @api_client.config.client_side_validation && key_id.nil?
    fail ArgumentError, "Missing the required parameter 'key_id' when calling AgentCapabilitiesApi.update_agent_key"
  end
  # verify the required parameter 'key_update' is set
  if @api_client.config.client_side_validation && key_update.nil?
    fail ArgumentError, "Missing the required parameter 'key_update' when calling AgentCapabilitiesApi.update_agent_key"
  end
  # resource path
  local_var_path = 'icc/v1/agents/{agentId}/keys/{keyId}'.sub('{' + 'agentId' + '}', agent_id.to_s).sub('{' + 'keyId' + '}', key_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(key_update)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'KeyUpdate', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["update_agent_key","update_agent_key_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["update_agent_key","update_agent_key_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:PUT, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'AddAgentKeyResponse201',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#update_agent_key\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#update_agent_with_http_info(agent_id, agent_update, opts = {}) ⇒ `Array<(AgentRegistrationResponse201, Fixnum, Hash)>`

Update an agent [category 1 — Agent_Capabilities] Update agent information. Updatable fields are name, domain, description, contactEmail, and agentMetadata. Extra fields (e.g. tokenRequestorId, keys) will return 422 Validation Error. Raises 404 if agent not found, 403 if agent is deactivated, 409 if new domain or contactEmail already exists.

Parameters:

agent_id —
Unique agent identifier
agent_update —
Agent update request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(AgentRegistrationResponse201, Fixnum, Hash)>) —
AgentRegistrationResponse201 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 1922

def update_agent_with_http_info(agent_id, agent_update, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.update_agent ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'agent_id' is set
  if @api_client.config.client_side_validation && agent_id.nil?
    fail ArgumentError, "Missing the required parameter 'agent_id' when calling AgentCapabilitiesApi.update_agent"
  end
  # verify the required parameter 'agent_update' is set
  if @api_client.config.client_side_validation && agent_update.nil?
    fail ArgumentError, "Missing the required parameter 'agent_update' when calling AgentCapabilitiesApi.update_agent"
  end
  # resource path
  local_var_path = 'icc/v1/agents/{agentId}'.sub('{' + 'agentId' + '}', agent_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(agent_update)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'AgentUpdate', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["update_agent","update_agent_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["update_agent","update_agent_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:PUT, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'AgentRegistrationResponse201',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#update_agent\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#update_checkout_session(session_id, acp_update_checkout_session_request, opts = {}) ⇒ `InlineResponse20113`

Update Checkout Session ACP Modifies an active ACP checkout session and returns the updated session state with recalculated totals. Use this to: - Add, remove, or change quantities of cart items - Apply or remove discount codes - Update the buyer's shipping address or contact details - Trigger re-calculation of shipping costs and tax Only fields included in the request body are updated — omitted fields retain their current values. Idempotency: Supply an Idempotency-Key to safely retry updates without applying them twice.

Parameters:

session_id —
The unique identifier of the ACP checkout session to update. Obtained from the `id` field in the Create Session response.
acp_update_checkout_session_request —
Fields to update. All fields are optional — only included fields are changed. To replace the cart entirely, provide the full `items` array.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Client-generated unique key to ensure this request is processed exactly once. If a request with the same key was already processed, the original response is returned.
:accept_language (String) —
Preferred language for the response (e.g. `en-US`, `fr-FR`). Passed to the merchant backend for localized content.
:user_agent (String) —
Client user agent string identifying the AI agent platform and version.
:request_id (String) —
Unique request identifier for distributed tracing and debugging. Echoed back in the response headers.
:signature (String) —
Request signature for payload integrity verification.
:timestamp (String) —
ISO 8601 timestamp of when the request was generated. Used in conjunction with Signature for replay protection.
:api_version (String) —
ACP specification version the client is targeting (e.g. `2024-01-01`). When omitted, the latest supported version is assumed.

Returns:

(InlineResponse20113)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 2098

def update_checkout_session(session_id, acp_update_checkout_session_request, opts = {})
  data, status_code, headers = update_checkout_session_with_http_info(session_id, acp_update_checkout_session_request, opts)
  return data, status_code, headers
end

#update_checkout_session_with_http_info(session_id, acp_update_checkout_session_request, opts = {}) ⇒ `Array<(InlineResponse20113, Fixnum, Hash)>`

Update Checkout Session ACP Modifies an active ACP checkout session and returns the updated session state with recalculated totals. Use this to: - Add, remove, or change quantities of cart items - Apply or remove discount codes - Update the buyer's shipping address or contact details - Trigger re-calculation of shipping costs and tax Only fields included in the request body are updated — omitted fields retain their current values. Idempotency: Supply an `Idempotency-Key` to safely retry updates without applying them twice.

Parameters:

session_id —
The unique identifier of the ACP checkout session to update. Obtained from the `id` field in the Create Session response.
acp_update_checkout_session_request —
Fields to update. All fields are optional — only included fields are changed. To replace the cart entirely, provide the full `items` array.
opts (Hash) (defaults to: {}) —
the optional parameters

Options Hash (opts):

:idempotency_key (String) —
Client-generated unique key to ensure this request is processed exactly once. If a request with the same key was already processed, the original response is returned.
:accept_language (String) —
Preferred language for the response (e.g. `en-US`, `fr-FR`). Passed to the merchant backend for localized content.
:user_agent (String) —
Client user agent string identifying the AI agent platform and version.
:request_id (String) —
Unique request identifier for distributed tracing and debugging. Echoed back in the response headers.
:signature (String) —
Request signature for payload integrity verification.
:timestamp (String) —
ISO 8601 timestamp of when the request was generated. Used in conjunction with Signature for replay protection.
:api_version (String) —
ACP specification version the client is targeting (e.g. `2024-01-01`). When omitted, the latest supported version is assumed.

Returns:

(Array<(InlineResponse20113, Fixnum, Hash)>) —
InlineResponse20113 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 2116

def update_checkout_session_with_http_info(session_id, acp_update_checkout_session_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.update_checkout_session ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'session_id' is set
  if @api_client.config.client_side_validation && session_id.nil?
    fail ArgumentError, "Missing the required parameter 'session_id' when calling AgentCapabilitiesApi.update_checkout_session"
  end
  # verify the required parameter 'acp_update_checkout_session_request' is set
  if @api_client.config.client_side_validation && acp_update_checkout_session_request.nil?
    fail ArgumentError, "Missing the required parameter 'acp_update_checkout_session_request' when calling AgentCapabilitiesApi.update_checkout_session"
  end
  # resource path
  local_var_path = 'icc/v1/checkout_sessions/{session_id}'.sub('{' + 'session_id' + '}', session_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])
  header_params[:'Idempotency-Key'] = opts[:'idempotency_key'] if !opts[:'idempotency_key'].nil?
  header_params[:'Accept-Language'] = opts[:'accept_language'] if !opts[:'accept_language'].nil?
  header_params[:'User-Agent'] = opts[:'user_agent'] if !opts[:'user_agent'].nil?
  header_params[:'Request-Id'] = opts[:'request_id'] if !opts[:'request_id'].nil?
  header_params[:'Signature'] = opts[:'signature'] if !opts[:'signature'].nil?
  header_params[:'Timestamp'] = opts[:'timestamp'] if !opts[:'timestamp'].nil?
  header_params[:'API-Version'] = opts[:'api_version'] if !opts[:'api_version'].nil?

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(acp_update_checkout_session_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'AcpUpdateCheckoutSessionRequest', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["update_checkout_session","update_checkout_session_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["update_checkout_session","update_checkout_session_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:POST, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'InlineResponse20113',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#update_checkout_session\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

#update_purchase_intent(instruction_id, agentic_update_purchase_intent_request, opts = {}) ⇒ `AgenticCreatePurchaseIntentResponse200`

Update a purchase intent Update an existing purchase intent (instruction) identified by its instructionId. The agent calls this endpoint when the consumer modifies their order — for example, changing the quantity, updating mandates, switching payment instruments, or changing shipping details. The request body has the same structure as the initiate request. Returns the same instructionId (HTTP 200) on success, or PENDING (HTTP 202) with pendingEvents if additional cardholder authentication is required for the updated intent.

Parameters:

instruction_id —
Unique identifier for the purchase intent instruction.
agentic_update_purchase_intent_request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(AgenticCreatePurchaseIntentResponse200)

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 2199

def update_purchase_intent(instruction_id, agentic_update_purchase_intent_request, opts = {})
  data, status_code, headers = update_purchase_intent_with_http_info(instruction_id, agentic_update_purchase_intent_request, opts)
  return data, status_code, headers
end

#update_purchase_intent_with_http_info(instruction_id, agentic_update_purchase_intent_request, opts = {}) ⇒ `Array<(AgenticCreatePurchaseIntentResponse200, Fixnum, Hash)>`

Update a purchase intent Update an existing purchase intent (instruction) identified by its instructionId. The agent calls this endpoint when the consumer modifies their order — for example, changing the quantity, updating mandates, switching payment instruments, or changing shipping details. The request body has the same structure as the initiate request. Returns the same instructionId (HTTP 200) on success, or PENDING (HTTP 202) with pendingEvents if additional cardholder authentication is required for the updated intent.

Parameters:

instruction_id —
Unique identifier for the purchase intent instruction.
agentic_update_purchase_intent_request
opts (Hash) (defaults to: {}) —
the optional parameters

Returns:

(Array<(AgenticCreatePurchaseIntentResponse200, Fixnum, Hash)>) —
AgenticCreatePurchaseIntentResponse200 data, response status code and response headers

# File 'lib/cybersource_rest_client/api/agent_capabilities_api.rb', line 2210

def update_purchase_intent_with_http_info(instruction_id, agentic_update_purchase_intent_request, opts = {})

  if @api_client.config.debugging
      begin
        raise
            @api_client.config.logger.debug 'Calling API: AgentCapabilitiesApi.update_purchase_intent ...'
        rescue
            puts 'Cannot write to log'
        end
  end
  # verify the required parameter 'instruction_id' is set
  if @api_client.config.client_side_validation && instruction_id.nil?
    fail ArgumentError, "Missing the required parameter 'instruction_id' when calling AgentCapabilitiesApi.update_purchase_intent"
  end
  # verify the required parameter 'agentic_update_purchase_intent_request' is set
  if @api_client.config.client_side_validation && agentic_update_purchase_intent_request.nil?
    fail ArgumentError, "Missing the required parameter 'agentic_update_purchase_intent_request' when calling AgentCapabilitiesApi.update_purchase_intent"
  end
  # resource path
  local_var_path = 'icc/v1/instructions/{instructionId}'.sub('{' + 'instructionId' + '}', instruction_id.to_s)

  # query parameters
  query_params = {}

  # header parameters
  header_params = {}
  # HTTP header 'Accept' (if needed)
  header_params['Accept'] = @api_client.select_header_accept(['application/hal+json;charset=utf-8'])
  # HTTP header 'Content-Type'
  header_params['Content-Type'] = @api_client.select_header_content_type(['application/json;charset=utf-8'])

  # form parameters
  form_params = {}

  # http body (model)
  post_body = @api_client.object_to_http_body(agentic_update_purchase_intent_request)
  sdk_tracker = SdkTracker.new
  post_body = sdk_tracker.insert_developer_id_tracker(post_body, 'AgenticUpdatePurchaseIntentRequest', @api_client.config.host, @api_client.merchantconfig.defaultDeveloperId)
  inbound_mle_status = "mandatory"
  if MLEUtility.check_is_mle_for_API(@api_client.merchantconfig, inbound_mle_status, ["update_purchase_intent","update_purchase_intent_with_http_info"])
    begin
      post_body = MLEUtility.encrypt_request_payload(@api_client.merchantconfig, post_body)
    rescue
      raise
    end
  end

  is_response_mle_for_api = MLEUtility.check_is_response_mle_for_api(@api_client.merchantconfig, ["update_purchase_intent","update_purchase_intent_with_http_info"])

  auth_names = []
  data, status_code, headers = @api_client.call_api(:PUT, local_var_path,
    :header_params => header_params,
    :query_params => query_params,
    :form_params => form_params,
    :body => post_body,
    :auth_names => auth_names,
    :return_type => 'AgenticCreatePurchaseIntentResponse200',
    :isResponseMLEForApi => is_response_mle_for_api)
  if @api_client.config.debugging
    begin
    raise
        @api_client.config.logger.debug "API called: AgentCapabilitiesApi#update_purchase_intent\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
    rescue
        puts 'Cannot write to log'
    end
  end
  return data, status_code, headers
end

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(api_client = ApiClient.default, config) ⇒ AgentCapabilitiesApi

Instance Attribute Details

#api_client ⇒ Object

Instance Method Details

#activate_agent_key(agent_id, key_id, opts = {}) ⇒ AddAgentKeyResponse201

#activate_agent_key_with_http_info(agent_id, key_id, opts = {}) ⇒ Array<(AddAgentKeyResponse201, Fixnum, Hash)>

#add_agent_key(agent_id, key_request, opts = {}) ⇒ AddAgentKeyResponse201

#add_agent_key_with_http_info(agent_id, key_request, opts = {}) ⇒ Array<(AddAgentKeyResponse201, Fixnum, Hash)>

#cancel_checkout(session_id, opts = {}) ⇒ InlineResponse20018

#cancel_checkout_with_http_info(session_id, opts = {}) ⇒ Array<(InlineResponse20018, Fixnum, Hash)>

#cancel_purchase_intent(instruction_id, agentic_cancel_purchase_intent_request, opts = {}) ⇒ AgenticCreatePurchaseIntentResponse200

#cancel_purchase_intent_with_http_info(instruction_id, agentic_cancel_purchase_intent_request, opts = {}) ⇒ Array<(AgenticCreatePurchaseIntentResponse200, Fixnum, Hash)>

#complete_checkout(session_id, acp_complete_checkout_request, opts = {}) ⇒ InlineResponse20017

#complete_checkout_with_http_info(session_id, acp_complete_checkout_request, opts = {}) ⇒ Array<(InlineResponse20017, Fixnum, Hash)>

#confirm_transaction_events(instruction_id, agentic_confirm_transaction_events_request, opts = {}) ⇒ AgenticConfirmTransactionEventsResponse202

#confirm_transaction_events_with_http_info(instruction_id, agentic_confirm_transaction_events_request, opts = {}) ⇒ Array<(AgenticConfirmTransactionEventsResponse202, Fixnum, Hash)>

#create_checkout_session(acp_create_checkout_session_request, opts = {}) ⇒ InlineResponse20113

#create_checkout_session_with_http_info(acp_create_checkout_session_request, opts = {}) ⇒ Array<(InlineResponse20113, Fixnum, Hash)>

#deactivate_agent_key(agent_id, key_id, opts = {}) ⇒ nil

#deactivate_agent_key_with_http_info(agent_id, key_id, opts = {}) ⇒ Array<(nil, Fixnum, Hash)>

#enroll_card(agentic_card_enrollment_request, opts = {}) ⇒ AgenticCardEnrollmentResponse200

#enroll_card_with_http_info(agentic_card_enrollment_request, opts = {}) ⇒ Array<(AgenticCardEnrollmentResponse200, Fixnum, Hash)>

#get_agent(agent_id, opts = {}) ⇒ AgentRegistrationResponse201

#get_agent_key(agent_id, key_id, opts = {}) ⇒ AddAgentKeyResponse201

#get_agent_key_with_http_info(agent_id, key_id, opts = {}) ⇒ Array<(AddAgentKeyResponse201, Fixnum, Hash)>

#get_agent_with_http_info(agent_id, opts = {}) ⇒ Array<(AgentRegistrationResponse201, Fixnum, Hash)>

#get_checkout_session(session_id, acp_get_checkout_session_request, opts = {}) ⇒ InlineResponse20113

#get_checkout_session_with_http_info(session_id, acp_get_checkout_session_request, opts = {}) ⇒ Array<(InlineResponse20113, Fixnum, Hash)>

#initiate_purchase_intent(agentic_create_purchase_intent_request, opts = {}) ⇒ AgenticCreatePurchaseIntentResponse200

#initiate_purchase_intent_with_http_info(agentic_create_purchase_intent_request, opts = {}) ⇒ Array<(AgenticCreatePurchaseIntentResponse200, Fixnum, Hash)>

#list_agent_keys(agent_id, opts = {}) ⇒ ListAgentKeysResponse200

#list_agent_keys_with_http_info(agent_id, opts = {}) ⇒ Array<(ListAgentKeysResponse200, Fixnum, Hash)>

#register_agent(agent_request, opts = {}) ⇒ AgentRegistrationResponse201

#register_agent_with_http_info(agent_request, opts = {}) ⇒ Array<(AgentRegistrationResponse201, Fixnum, Hash)>

#retrieve_payment_credentials(instruction_id, agentic_retrieve_payment_credentials_request, opts = {}) ⇒ AgenticRetrievePaymentCredentialsResponse200

#retrieve_payment_credentials_with_http_info(instruction_id, agentic_retrieve_payment_credentials_request, opts = {}) ⇒ Array<(AgenticRetrievePaymentCredentialsResponse200, Fixnum, Hash)>

#ucp_cancel_checkout(session_id, opts = {}) ⇒ InlineResponse20114

#ucp_cancel_checkout_with_http_info(session_id, opts = {}) ⇒ Array<(InlineResponse20114, Fixnum, Hash)>

#ucp_complete_checkout(session_id, opts = {}) ⇒ InlineResponse20114

#ucp_complete_checkout_with_http_info(session_id, opts = {}) ⇒ Array<(InlineResponse20114, Fixnum, Hash)>

#ucp_create_checkout_session(ucp_create_checkout_session_request, opts = {}) ⇒ InlineResponse20114

#ucp_create_checkout_session_with_http_info(ucp_create_checkout_session_request, opts = {}) ⇒ Array<(InlineResponse20114, Fixnum, Hash)>

#ucp_get_checkout_session(session_id, ucp_get_checkout_session_request, opts = {}) ⇒ InlineResponse20114

#ucp_get_checkout_session_with_http_info(session_id, ucp_get_checkout_session_request, opts = {}) ⇒ Array<(InlineResponse20114, Fixnum, Hash)>

#ucp_update_checkout_session(session_id, ucp_update_checkout_session_request, opts = {}) ⇒ InlineResponse20114

#ucp_update_checkout_session_with_http_info(session_id, ucp_update_checkout_session_request, opts = {}) ⇒ Array<(InlineResponse20114, Fixnum, Hash)>

#update_agent(agent_id, agent_update, opts = {}) ⇒ AgentRegistrationResponse201

#update_agent_key(agent_id, key_id, key_update, opts = {}) ⇒ AddAgentKeyResponse201

#update_agent_key_with_http_info(agent_id, key_id, key_update, opts = {}) ⇒ Array<(AddAgentKeyResponse201, Fixnum, Hash)>

#update_agent_with_http_info(agent_id, agent_update, opts = {}) ⇒ Array<(AgentRegistrationResponse201, Fixnum, Hash)>

#update_checkout_session(session_id, acp_update_checkout_session_request, opts = {}) ⇒ InlineResponse20113

#update_checkout_session_with_http_info(session_id, acp_update_checkout_session_request, opts = {}) ⇒ Array<(InlineResponse20113, Fixnum, Hash)>

#update_purchase_intent(instruction_id, agentic_update_purchase_intent_request, opts = {}) ⇒ AgenticCreatePurchaseIntentResponse200

#update_purchase_intent_with_http_info(instruction_id, agentic_update_purchase_intent_request, opts = {}) ⇒ Array<(AgenticCreatePurchaseIntentResponse200, Fixnum, Hash)>

#initialize(api_client = ApiClient.default, config) ⇒ `AgentCapabilitiesApi`

#api_client ⇒ `Object`

#activate_agent_key(agent_id, key_id, opts = {}) ⇒ `AddAgentKeyResponse201`

#activate_agent_key_with_http_info(agent_id, key_id, opts = {}) ⇒ `Array<(AddAgentKeyResponse201, Fixnum, Hash)>`

#add_agent_key(agent_id, key_request, opts = {}) ⇒ `AddAgentKeyResponse201`

#add_agent_key_with_http_info(agent_id, key_request, opts = {}) ⇒ `Array<(AddAgentKeyResponse201, Fixnum, Hash)>`

#cancel_checkout(session_id, opts = {}) ⇒ `InlineResponse20018`

#cancel_checkout_with_http_info(session_id, opts = {}) ⇒ `Array<(InlineResponse20018, Fixnum, Hash)>`

#cancel_purchase_intent(instruction_id, agentic_cancel_purchase_intent_request, opts = {}) ⇒ `AgenticCreatePurchaseIntentResponse200`

#cancel_purchase_intent_with_http_info(instruction_id, agentic_cancel_purchase_intent_request, opts = {}) ⇒ `Array<(AgenticCreatePurchaseIntentResponse200, Fixnum, Hash)>`

#complete_checkout(session_id, acp_complete_checkout_request, opts = {}) ⇒ `InlineResponse20017`

#complete_checkout_with_http_info(session_id, acp_complete_checkout_request, opts = {}) ⇒ `Array<(InlineResponse20017, Fixnum, Hash)>`

#confirm_transaction_events(instruction_id, agentic_confirm_transaction_events_request, opts = {}) ⇒ `AgenticConfirmTransactionEventsResponse202`

#confirm_transaction_events_with_http_info(instruction_id, agentic_confirm_transaction_events_request, opts = {}) ⇒ `Array<(AgenticConfirmTransactionEventsResponse202, Fixnum, Hash)>`

#create_checkout_session(acp_create_checkout_session_request, opts = {}) ⇒ `InlineResponse20113`

#create_checkout_session_with_http_info(acp_create_checkout_session_request, opts = {}) ⇒ `Array<(InlineResponse20113, Fixnum, Hash)>`

#deactivate_agent_key(agent_id, key_id, opts = {}) ⇒ `nil`

#deactivate_agent_key_with_http_info(agent_id, key_id, opts = {}) ⇒ `Array<(nil, Fixnum, Hash)>`

#enroll_card(agentic_card_enrollment_request, opts = {}) ⇒ `AgenticCardEnrollmentResponse200`

#enroll_card_with_http_info(agentic_card_enrollment_request, opts = {}) ⇒ `Array<(AgenticCardEnrollmentResponse200, Fixnum, Hash)>`

#get_agent(agent_id, opts = {}) ⇒ `AgentRegistrationResponse201`

#get_agent_key(agent_id, key_id, opts = {}) ⇒ `AddAgentKeyResponse201`

#get_agent_key_with_http_info(agent_id, key_id, opts = {}) ⇒ `Array<(AddAgentKeyResponse201, Fixnum, Hash)>`

#get_agent_with_http_info(agent_id, opts = {}) ⇒ `Array<(AgentRegistrationResponse201, Fixnum, Hash)>`

#get_checkout_session(session_id, acp_get_checkout_session_request, opts = {}) ⇒ `InlineResponse20113`

#get_checkout_session_with_http_info(session_id, acp_get_checkout_session_request, opts = {}) ⇒ `Array<(InlineResponse20113, Fixnum, Hash)>`

#initiate_purchase_intent(agentic_create_purchase_intent_request, opts = {}) ⇒ `AgenticCreatePurchaseIntentResponse200`

#initiate_purchase_intent_with_http_info(agentic_create_purchase_intent_request, opts = {}) ⇒ `Array<(AgenticCreatePurchaseIntentResponse200, Fixnum, Hash)>`

#list_agent_keys(agent_id, opts = {}) ⇒ `ListAgentKeysResponse200`

#list_agent_keys_with_http_info(agent_id, opts = {}) ⇒ `Array<(ListAgentKeysResponse200, Fixnum, Hash)>`

#register_agent(agent_request, opts = {}) ⇒ `AgentRegistrationResponse201`

#register_agent_with_http_info(agent_request, opts = {}) ⇒ `Array<(AgentRegistrationResponse201, Fixnum, Hash)>`

#retrieve_payment_credentials(instruction_id, agentic_retrieve_payment_credentials_request, opts = {}) ⇒ `AgenticRetrievePaymentCredentialsResponse200`

#retrieve_payment_credentials_with_http_info(instruction_id, agentic_retrieve_payment_credentials_request, opts = {}) ⇒ `Array<(AgenticRetrievePaymentCredentialsResponse200, Fixnum, Hash)>`

#ucp_cancel_checkout(session_id, opts = {}) ⇒ `InlineResponse20114`

#ucp_cancel_checkout_with_http_info(session_id, opts = {}) ⇒ `Array<(InlineResponse20114, Fixnum, Hash)>`

#ucp_complete_checkout(session_id, opts = {}) ⇒ `InlineResponse20114`

#ucp_complete_checkout_with_http_info(session_id, opts = {}) ⇒ `Array<(InlineResponse20114, Fixnum, Hash)>`

#ucp_create_checkout_session(ucp_create_checkout_session_request, opts = {}) ⇒ `InlineResponse20114`

#ucp_create_checkout_session_with_http_info(ucp_create_checkout_session_request, opts = {}) ⇒ `Array<(InlineResponse20114, Fixnum, Hash)>`

#ucp_get_checkout_session(session_id, ucp_get_checkout_session_request, opts = {}) ⇒ `InlineResponse20114`

#ucp_get_checkout_session_with_http_info(session_id, ucp_get_checkout_session_request, opts = {}) ⇒ `Array<(InlineResponse20114, Fixnum, Hash)>`

#ucp_update_checkout_session(session_id, ucp_update_checkout_session_request, opts = {}) ⇒ `InlineResponse20114`

#ucp_update_checkout_session_with_http_info(session_id, ucp_update_checkout_session_request, opts = {}) ⇒ `Array<(InlineResponse20114, Fixnum, Hash)>`

#update_agent(agent_id, agent_update, opts = {}) ⇒ `AgentRegistrationResponse201`

#update_agent_key(agent_id, key_id, key_update, opts = {}) ⇒ `AddAgentKeyResponse201`

#update_agent_key_with_http_info(agent_id, key_id, key_update, opts = {}) ⇒ `Array<(AddAgentKeyResponse201, Fixnum, Hash)>`

#update_agent_with_http_info(agent_id, agent_update, opts = {}) ⇒ `Array<(AgentRegistrationResponse201, Fixnum, Hash)>`

#update_checkout_session(session_id, acp_update_checkout_session_request, opts = {}) ⇒ `InlineResponse20113`

#update_checkout_session_with_http_info(session_id, acp_update_checkout_session_request, opts = {}) ⇒ `Array<(InlineResponse20113, Fixnum, Hash)>`

#update_purchase_intent(instruction_id, agentic_update_purchase_intent_request, opts = {}) ⇒ `AgenticCreatePurchaseIntentResponse200`

#update_purchase_intent_with_http_info(instruction_id, agentic_update_purchase_intent_request, opts = {}) ⇒ `Array<(AgenticCreatePurchaseIntentResponse200, Fixnum, Hash)>`