Worldline Acquiring Python SDK

Introduction

The Python SDK helps you to communicate with the Worldline Acquiring API. Its primary features are:

  • convenient Python library for the API calls and responses

    • marshals Python request objects to HTTP requests

    • unmarshals HTTP responses to Python response objects or Python exceptions

  • handling of all the details concerning authentication

  • handling of required metadata

See the Worldline Acquiring Documentation for more information on how to use the SDK.

Structure of this repository

This repository consists out of four main components:

  1. The source code of the SDK itself: /worldline/acquiring/sdk/

  2. The source code of the SDK unit tests: /tests/unit/

  3. The source code of the SDK integration tests: /tests/integration/

Note that the source code of the unit tests and integration tests can only be found on GitHub.

Requirements

Python 3.7 or higher is required. In addition, the following packages are required:

These packages will be installed automatically if the SDK is installed manually or using pip following the below instructions.

Installation

To install the SDK using pip, execute the following command:

pip install acquiring-sdk-python

Alternatively, you can install the SDK from a source distribution file:

  1. Download the latest version of the Python SDK from GitHub. Choose the acquiring_sdk_python-x.y.z.tar.gz file from the releases page, where x.y.z is the version number.

  2. Execute the following command in the folder where the SDK was downloaded to:

    pip install acquiring_sdk_python-x.y.z.tar.gz

Uninstalling

After the Python SDK has been installed, it can be uninstalled using the following command:

pip uninstall acquiring-sdk-python

The required packages can be uninstalled in the same way.

Running tests

There are two types of tests: unit tests and integration tests. The unit tests will work out-of-the-box; for the integration tests some configuration is required. First, some environment variables need to be set:

  • acquiring.api.oauth2.clientId for the OAUth2 client id to use.

  • acquiring.api.oauth2.clientSecret for the OAuth2 client secret to use.

  • acquiring.api.merchantId for your merchant ID.

In addition, to run the proxy integration tests, the proxy URI, username and password should be set in the tests/resources/configuration.proxy.ini file.

In order to run the unit and integration tests, the mock backport and mockito are required. These can be installed using the following command:

pip install mock mockito

The following commands can now be executed from the tests directory to execute the tests:

  • Unit tests:

    python run_unit_tests.py

  • Integration tests:

    python run_integration_tests.py

  • Both unit and integration tests:

    python run_all_tests.py

API Reference

class worldline.acquiring.sdk.api_resource.ApiResource(parent: ApiResource | None = None, communicator: Communicator | None = None, path_context: Mapping[str, str] | None = None)[source]

Bases: object

Base class of all Worldline Acquiring platform API resources.

__init__(parent: ApiResource | None = None, communicator: Communicator | None = None, path_context: Mapping[str, str] | None = None)[source]

The parent and/or communicator must be given.

class worldline.acquiring.sdk.call_context.CallContext[source]

Bases: object

A call context can be used to send extra information with a request, and to receive extra information from a response.

Please note that this class is not thread-safe. Each request should get its own call context instance.

class worldline.acquiring.sdk.client.Client(communicator: Communicator)[source]

Bases: ApiResource, LoggingCapable, ObfuscationCapable

Worldline Acquiring platform client.

Thread-safe.

__abstractmethods__ = frozenset({})
__annotations__ = {}
__enter__()[source]
__exit__(exc_type, exc_val, exc_tb)[source]
__init__(communicator: Communicator)[source]
Parameters:

communicator – worldline.acquiring.sdk.communicator.Communicator

close() → None[source]

Releases any system resources associated with this object.

close_expired_connections() → None[source]

Utility method that delegates the call to this client’s communicator.

close_idle_connections(idle_time: timedelta) → None[source]

Utility method that delegates the call to this client’s communicator.

Parameters:

idle_time – a datetime.timedelta object indicating the idle time

disable_logging() → None[source]

Turns off logging.

enable_logging(communicator_logger: CommunicatorLogger) → None[source]

Turns on logging using the given communicator logger.

Raises:

ValueError – If the given communicator logger is None.

set_body_obfuscator(body_obfuscator: BodyObfuscator) → None[source]

Sets the current body obfuscator to use.

set_header_obfuscator(header_obfuscator: HeaderObfuscator) → None[source]

Sets the current header obfuscator to use.

v1() → V1Client[source]
class worldline.acquiring.sdk.communicator.Communicator(api_endpoint: str | ParseResult, connection: Connection, authenticator: Authenticator, metadata_provider: MetadataProvider, marshaller: Marshaller)[source]

Bases: LoggingCapable, ObfuscationCapable

Used to communicate with the Worldline Acquiring platform web services.

It contains all the logic to transform a request object to an HTTP request and an HTTP response to a response object.

__abstractmethods__ = frozenset({})
__annotations__ = {}
__enter__()[source]
__exit__(exc_type, exc_val, exc_tb)[source]
close() → None[source]

Releases any system resources associated with this object.

close_expired_connections() → None[source]

Utility method that delegates the call to this communicator’s connection if that’s an instance of PooledConnection. If not this method does nothing.

close_idle_connections(idle_time: timedelta) → None[source]

Utility method that delegates the call to this communicator’s connection if that’s an instance of PooledConnection. If not this method does nothing.

Parameters:

idle_time – a datetime.timedelta object indicating the idle time

delete(relative_path: str, request_headers: List[RequestHeader] | None, request_parameters: ParamRequest | None, response_type: Type[T], context: CallContext | None) → T[source]

Corresponds to the HTTP DELETE method.

Parameters:

  • relative_path – The path to call, relative to the base URI.

  • request_headers – An optional list of request headers.

  • request_parameters – An optional set of request parameters.

  • response_type – The type of response to return.

  • context – The optional call context to use.

Raises:

  • CommunicationException – when an exception occurred communicating with the Worldline Acquiring platform

  • ResponseException – when an error response was received from the Worldline Acquiring platform

delete_with_binary_response(relative_path: str, request_headers: List[RequestHeader] | None, request_parameters: ParamRequest | None, context: CallContext | None) → Tuple[Mapping[str, str], Iterable[bytes]][source]

Corresponds to the HTTP DELETE method.

Parameters:

  • relative_path – The path to call, relative to the base URI.

  • request_headers – An optional list of request headers.

  • request_parameters – An optional set of request parameters.

  • context – The optional call context to use.

Raises:

  • CommunicationException – when an exception occurred communicating with the Worldline Acquiring platform

  • ResponseException – when an error response was received from the Worldline Acquiring platform

disable_logging() → None[source]

Turns off logging.

enable_logging(communicator_logger: CommunicatorLogger) → None[source]

Turns on logging using the given communicator logger.

Raises:

ValueError – If the given communicator logger is None.

get(relative_path: str, request_headers: List[RequestHeader] | None, request_parameters: ParamRequest | None, response_type: Type[T], context: CallContext | None) → T[source]

Corresponds to the HTTP GET method.

Parameters:

  • relative_path – The path to call, relative to the base URI.

  • request_headers – An optional list of request headers.

  • request_parameters – An optional set of request parameters.

  • response_type – The type of response to return.

  • context – The optional call context to use.

Raises:

  • CommunicationException – when an exception occurred communicating with the Worldline Acquiring platform

  • ResponseException – when an error response was received from the Worldline Acquiring platform

get_with_binary_response(relative_path: str, request_headers: List[RequestHeader] | None, request_parameters: ParamRequest | None, context: CallContext | None) → Tuple[Mapping[str, str], Iterable[bytes]][source]

Corresponds to the HTTP GET method.

Parameters:

  • relative_path – The path to call, relative to the base URI.

  • request_headers – An optional list of request headers.

  • request_parameters – An optional set of request parameters.

  • context – The optional call context to use.

Raises:

  • CommunicationException – when an exception occurred communicating with the Worldline Acquiring platform

  • ResponseException – when an error response was received from the Worldline Acquiring platform

property marshaller: Marshaller
Returns:

The Marshaller object associated with this communicator. Never None.

post(relative_path: str, request_headers: List[RequestHeader] | None, request_parameters: ParamRequest | None, request_body: Any, response_type: Type[T], context: CallContext | None) → T[source]

Corresponds to the HTTP POST method.

Parameters:

  • relative_path – The path to call, relative to the base URI.

  • request_headers – An optional list of request headers.

  • request_parameters – An optional set of request parameters.

  • request_body – The optional request body to send.

  • response_type – The type of response to return.

  • context – The optional call context to use.

Raises:

  • CommunicationException – when an exception occurred communicating with the Worldline Acquiring platform

  • ResponseException – when an error response was received from the Worldline Acquiring platform

post_with_binary_response(relative_path: str, request_headers: List[RequestHeader] | None, request_parameters: ParamRequest | None, request_body: Any, context: CallContext | None) → Tuple[Mapping[str, str], Iterable[bytes]][source]

Corresponds to the HTTP POST method.

Parameters:

  • relative_path – The path to call, relative to the base URI.

  • request_headers – An optional list of request headers.

  • request_parameters – An optional set of request parameters.

  • request_body – The optional request body to send.

  • context – The optional call context to use.

Raises:

  • CommunicationException – when an exception occurred communicating with the Worldline Acquiring platform

  • ResponseException – when an error response was received from the Worldline Acquiring platform

put(relative_path: str, request_headers: List[RequestHeader] | None, request_parameters: ParamRequest | None, request_body: Any, response_type: Type[T], context: CallContext | None) → T[source]

Corresponds to the HTTP PUT method.

Parameters:

  • relative_path – The path to call, relative to the base URI.

  • request_headers – An optional list of request headers.

  • request_parameters – An optional set of request parameters.

  • request_body – The optional request body to send.

  • response_type – The type of response to return.

  • context – The optional call context to use.

Raises:

  • CommunicationException – when an exception occurred communicating with the Worldline Acquiring platform

  • ResponseException – when an error response was received from the Worldline Acquiring platform

put_with_binary_response(relative_path: str, request_headers: List[RequestHeader] | None, request_parameters: ParamRequest | None, request_body: Any, context: CallContext | None) → Tuple[Mapping[str, str], Iterable[bytes]][source]

Corresponds to the HTTP PUT method.

Parameters:

  • relative_path – The path to call, relative to the base URI.

  • request_headers – An optional list of request headers.

  • request_parameters – An optional set of request parameters.

  • request_body – The optional request body to send.

  • context – The optional call context to use.

Raises:

  • CommunicationException – when an exception occurred communicating with the Worldline Acquiring platform

  • ResponseException – when an error response was received from the Worldline Acquiring platform

set_body_obfuscator(body_obfuscator: BodyObfuscator) → None[source]

Sets the current body obfuscator to use.

set_header_obfuscator(header_obfuscator: HeaderObfuscator) → None[source]

Sets the current header obfuscator to use.

class worldline.acquiring.sdk.communicator_configuration.CommunicatorConfiguration(properties: ConfigParser | None = None, api_endpoint: str | ParseResult | None = None, authorization_id: str | None = None, authorization_secret: str | None = None, oauth2_client_id: str | None = None, oauth2_client_secret: str | None = None, oauth2_token_uri: str | None = None, oauth2_scopes: str | None = None, authorization_type: str | None = None, connect_timeout: int | None = None, socket_timeout: int | None = None, max_connections: int | None = None, proxy_configuration: ProxyConfiguration | None = None, integrator: str | None = None, shopping_cart_extension: ShoppingCartExtension | None = None)[source]

Bases: object

Configuration for the communicator.

DEFAULT_MAX_CONNECTIONS = 10
__annotations__ = {'_CommunicatorConfiguration__api_endpoint': typing.Optional[urllib.parse.ParseResult], '_CommunicatorConfiguration__authorization_id': typing.Optional[str], '_CommunicatorConfiguration__authorization_secret': typing.Optional[str], '_CommunicatorConfiguration__authorization_type': typing.Optional[str], '_CommunicatorConfiguration__connect_timeout': typing.Optional[int], '_CommunicatorConfiguration__integrator': typing.Optional[str], '_CommunicatorConfiguration__max_connections': typing.Optional[int], '_CommunicatorConfiguration__oauth2_scopes': typing.Optional[str], '_CommunicatorConfiguration__oauth2_token_uri': typing.Optional[str], '_CommunicatorConfiguration__proxy_configuration': typing.Optional[worldline.acquiring.sdk.proxy_configuration.ProxyConfiguration], '_CommunicatorConfiguration__shopping_cart_extension': typing.Optional[worldline.acquiring.sdk.domain.shopping_cart_extension.ShoppingCartExtension], '_CommunicatorConfiguration__socket_timeout': typing.Optional[int], '__api_endpoint': 'Optional[ParseResult]', '__authorization_id': 'Optional[str]', '__authorization_secret': 'Optional[str]', '__authorization_type': 'Optional[str]', '__connect_timeout': 'Optional[int]', '__integrator': 'Optional[str]', '__max_connections': 'Optional[int]', '__oauth2_scopes': 'Optional[str]', '__oauth2_token_uri': 'Optional[str]', '__proxy_configuration': 'Optional[ProxyConfiguration]', '__shopping_cart_extension': 'Optional[ShoppingCartExtension]', '__socket_timeout': 'Optional[int]'}
__init__(properties: ConfigParser | None = None, api_endpoint: str | ParseResult | None = None, authorization_id: str | None = None, authorization_secret: str | None = None, oauth2_client_id: str | None = None, oauth2_client_secret: str | None = None, oauth2_token_uri: str | None = None, oauth2_scopes: str | None = None, authorization_type: str | None = None, connect_timeout: int | None = None, socket_timeout: int | None = None, max_connections: int | None = None, proxy_configuration: ProxyConfiguration | None = None, integrator: str | None = None, shopping_cart_extension: ShoppingCartExtension | None = None)[source]
Parameters:

  • properties – a ConfigParser.ConfigParser object containing configuration data

  • connect_timeout – connection timeout for the network communication in seconds

  • socket_timeout – socket timeout for the network communication in seconds

  • max_connections – The maximum number of connections in the connection pool

property api_endpoint: ParseResult | None

The Worldline Acquiring platform API endpoint URI.

property authorization_id: str | None

An id used for authorization. The meaning of this id is different for each authorization type. For instance, for OAuth2 this is the client id.

property authorization_secret: str | None

A secret used for authorization. The meaning of this secret is different for each authorization type. For instance, for OAuth2 this is the client secret.

property authorization_type: str | None
property connect_timeout: int | None

Connection timeout for the underlying network communication in seconds

property integrator: str | None
property max_connections: int | None
property oauth2_client_id: str | None

The OAuth2 client id.

This property is an alias for authorization_id

property oauth2_client_secret: str | None

The OAuth2 client secret.

This property is an alias for authorization_secret

property oauth2_scopes: str | None
property oauth2_token_uri: str | None
property proxy_configuration: ProxyConfiguration | None
property shopping_cart_extension: ShoppingCartExtension | None
property socket_timeout: int | None

Socket timeout for the underlying network communication in seconds

class worldline.acquiring.sdk.factory.Factory[source]

Bases: object

Worldline Acquiring platform factory for several SDK components.

static create_client_from_communicator(communicator: Communicator) → Client[source]

Create a Client based on the settings stored in the Communicator argument

static create_client_from_configuration(communicator_configuration: CommunicatorConfiguration, metadata_provider: MetadataProvider | None = None, connection: Connection | None = None, authenticator: Authenticator | None = None, marshaller: Marshaller | None = None) → Client[source]

Create a Client based on the configuration stored in the CommunicatorConfiguration argument

static create_client_from_file(configuration_file_name: str | bytes, authorization_id: str, authorization_secret: str, metadata_provider: MetadataProvider | None = None, connection: Connection | None = None, authenticator: Authenticator | None = None, marshaller: Marshaller | None = None) → Client[source]

Creates a Client based on the configuration values in configuration_file_name, authorization_id and authorization_secret.

static create_communicator_from_configuration(communicator_configuration: CommunicatorConfiguration, metadata_provider: MetadataProvider | None = None, connection: Connection | None = None, authenticator: Authenticator | None = None, marshaller: Marshaller | None = None) → Communicator[source]

Creates a Communicator based on the configuration stored in the CommunicatorConfiguration argument

static create_communicator_from_file(configuration_file_name: str | bytes, authorization_id: str, authorization_secret: str, metadata_provider: MetadataProvider | None = None, connection: Connection | None = None, authenticator: Authenticator | None = None, marshaller: Marshaller | None = None) → Communicator[source]

Creates a Communicator based on the configuration values in configuration_file_name, api_id_key and authorization_secret.

static create_configuration(configuration_file_name: str | bytes, authorization_id: str, authorization_secret: str) → CommunicatorConfiguration[source]

Creates a CommunicatorConfiguration based on the configuration values in configuration_file_name, authorization_id and authorization_secret.

class worldline.acquiring.sdk.proxy_configuration.ProxyConfiguration(host: str, port: int, scheme: str = 'http', username: str | None = None, password: str | None = None)[source]

Bases: object

HTTP proxy configuration.

Can be initialised directly from a host and port or can be constructed from a uri using fromuri

__str__()[source]

Return a proxy string in the form scheme://username:password@host:port or scheme://host:port if authentication is absent

Supports HTTP Basic Auth

static from_uri(uri: str, username: str | None = None, password: str | None = None) → ProxyConfiguration[source]

Constructs a ProxyConfiguration from a URI; if username and/or password are given they will be used instead of corresponding data in the URI

property host: str
property password: str | None
property port: int
property scheme: str
property username: str | None
class worldline.acquiring.sdk.authentication.authenticator.Authenticator[source]

Bases: ABC

Used to authenticate requests to the Worldline Acquiring platform.

__abstractmethods__ = frozenset({'get_authorization'})
__annotations__ = {}
abstractmethod get_authorization(http_method: str, resource_uri: ParseResult, request_headers: Sequence[RequestHeader] | None) → str[source]

Returns a value that can be used for the “Authorization” header.

Parameters:

  • http_method – The HTTP method.

  • resource_uri – The URI of the resource.

  • request_headers – A sequence of RequestHeaders. This sequence may not be modified and may not contain headers with the same name.

class worldline.acquiring.sdk.authentication.authorization_type.AuthorizationType[source]

Bases: object

AUTHORIZATION_TYPES = ['OAuth2']
OAUTH2 = 'OAuth2'
static get_authorization(name: str) → str[source]
class worldline.acquiring.sdk.authentication.oauth2_authenticator.OAuth2Authenticator(communicator_configuration: CommunicatorConfiguration)[source]

Bases: Authenticator

OAuth2 Authenticator implementation.

__abstractmethods__ = frozenset({})
__annotations__ = {}
__init__(communicator_configuration: CommunicatorConfiguration)[source]

Constructs a new OAuth2Authenticator instance using the provided CommunicatorConfiguration.

Parameters:

communicator_configuration – The configuration object containing the OAuth2 client id, client secret and token URI, connection timeout, and socket timeout. None of these can be None or empty, and the timeout values must be positive.

get_authorization(http_method: str | None, resource_uri: ParseResult | None, request_headers: Sequence[RequestHeader] | None) → str[source]

Returns a value that can be used for the “Authorization” header.

Parameters:

  • http_method – The HTTP method.

  • resource_uri – The URI of the resource.

  • request_headers – A sequence of RequestHeaders. This sequence may not be modified and may not contain headers with the same name.

exception worldline.acquiring.sdk.authentication.oauth2_exception.OAuth2Exception(message: str | None = None)[source]

Bases: RuntimeError

Indicates an exception regarding the authorization with the Worldline OAuth2 Authorization Server.

class worldline.acquiring.sdk.authentication.oauth2_scopes.OAuth2Scopes[source]

Bases: object

static all() → Set[str][source]

Returns all available scopes.

static for_api_version(api_version: str) → Set[str][source]

Returns all scopes needed for all operations of the given API version.

static for_filtered_operations(operation_filter: Callable[[str, str], bool]) → Set[str][source]

Returns all scopes needed for the operations that pass the given filter. The first argument to the filter is the API version, the second is the operation id.

static for_operation(api_version: str, operation_id: str) → Set[str][source]

Returns all scopes needed for the given operation of the given API version.

static for_operations(api_version: str, *operation_ids: str) → Set[str][source]

Returns all scopes needed for the given operations of the given API version.

exception worldline.acquiring.sdk.communication.communication_exception.CommunicationException(exception: Exception)[source]

Bases: RuntimeError

Indicates an exception regarding the communication with the Worldline Acquiring platform such as a connection exception.

class worldline.acquiring.sdk.communication.connection.Connection[source]

Bases: LoggingCapable, ObfuscationCapable, ABC

Represents a connection to the Worldline Acquiring platform server.

__abstractmethods__ = frozenset({'delete', 'disable_logging', 'enable_logging', 'get', 'post', 'put', 'set_body_obfuscator', 'set_header_obfuscator'})
__annotations__ = {}
close() → None[source]

Releases any system resources associated with this object.

abstractmethod delete(url: str | ParseResult, request_headers: Sequence[RequestHeader]) → Tuple[int, Mapping[str, str], Iterable[bytes]][source]

Send a DELETE request to the Worldline Acquiring platform and return the response.

Parameters:

  • url – The URI to call, including any necessary query parameters.

  • request_headers – An optional sequence of request headers.

Returns:

The response from the Worldline Acquiring platform as a tuple with the status code, headers and a generator of body chunks

Raises:

CommunicationException – when an exception occurred communicating with the Worldline Acquiring platform

abstractmethod get(url: str | ParseResult, request_headers: Sequence[RequestHeader]) → Tuple[int, Mapping[str, str], Iterable[bytes]][source]

Send a GET request to the Worldline Acquiring platform and return the response.

Parameters:

  • url – The URI to call, including any necessary query parameters.

  • request_headers – An optional sequence of request headers.

Returns:

The response from the Worldline Acquiring platform as a tuple with the status code, headers and a generator of body chunks

Raises:

CommunicationException – when an exception occurred communicating with the Worldline Acquiring platform

abstractmethod post(url: str | ParseResult, request_headers: Sequence[RequestHeader], body: str | MultipartFormDataObject | None) → Tuple[int, Mapping[str, str], Iterable[bytes]][source]

Send a POST request to the Worldline Acquiring platform and return the response.

Parameters:

  • url – The URI to call, including any necessary query parameters.

  • request_headers – An optional sequence of request headers.

  • body – The optional body to send.

Returns:

The response from the Worldline Acquiring platform as a tuple with the status code, headers and a generator of body chunks

Raises:

CommunicationException – when an exception occurred communicating with the Worldline Acquiring platform

abstractmethod put(url: str | ParseResult, request_headers: Sequence[RequestHeader], body: str | MultipartFormDataObject | None) → Tuple[int, Mapping[str, str], Iterable[bytes]][source]

Send a PUT request to the Worldline Acquiring platform and return the response.

Parameters:

  • url – The URI to call, including any necessary query parameters.

  • request_headers – An optional sequence of request headers.

  • body – The optional body to send.

Returns:

The response from the Worldline Acquiring platform as a tuple with the status code, headers and a generator of body chunks

Raises:

CommunicationException – when an exception occurred communicating with the Worldline Acquiring platform

class worldline.acquiring.sdk.communication.default_connection.DefaultConnection(connect_timeout: int, socket_timeout: int, max_connections: int = 10, proxy_configuration: ProxyConfiguration | None = None)[source]

Bases: PooledConnection

Provides an HTTP request interface, thread-safe

Parameters:

  • connect_timeout – timeout in seconds before a pending connection is dropped

  • socket_timeout – timeout in seconds before dropping an established connection. This is the time the server is allowed for a response

  • max_connections – the maximum number of connections in the connection pool

  • proxy_configuration – ProxyConfiguration object that contains data about proxy settings if present. It should be writeable as string and have a scheme attribute.

Use the methods get, delete, post and put to perform the corresponding HTTP request. Alternatively you can use request with the request method as the first parameter.

URI, headers and body should be given on a per-request basis.

__abstractmethods__ = frozenset({})
__annotations__ = {}
__enter__()[source]
__exit__(exc_type, exc_val, exc_tb)[source]
close() → None[source]

Explicitly closes the connection

close_expired_connections() → None[source]

Closes all expired HTTP connections.

close_idle_connections(idle_time: timedelta) → None[source]
Parameters:

idle_time – a datetime.timedelta object indicating the idle time

property connect_timeout: int | None

Connection timeout in seconds

delete(url: str | ParseResult, request_headers: Sequence[RequestHeader]) → Tuple[int, Mapping[str, str], Iterable[bytes]][source]

Perform a request to the server given by url

Parameters:

  • url – the url to the server, given as a parsed url

  • request_headers – a sequence containing RequestHeader objects representing the request headers

disable_logging() → None[source]

Turns off logging.

enable_logging(communicator_logger: CommunicatorLogger) → None[source]

Turns on logging using the given communicator logger.

Raises:

ValueError – If the given communicator logger is None.

get(url: str | ParseResult, request_headers: Sequence[RequestHeader]) → Tuple[int, Mapping[str, str], Iterable[bytes]][source]

Perform a request to the server given by url

Parameters:

  • url – the url to the server, given as a parsed url

  • request_headers – a sequence containing RequestHeader objects representing the request headers

post(url: str | ParseResult, request_headers: Sequence[RequestHeader], body: str | MultipartFormDataObject | None) → Tuple[int, Mapping[str, str], Iterable[bytes]][source]

Perform a request to the server given by url

Parameters:

  • url – the url to the server, given as a parsed url

  • request_headers – a sequence containing RequestHeader objects representing the request headers

  • body – the request body

put(url: str | ParseResult, request_headers: Sequence[RequestHeader], body: str | MultipartFormDataObject | None) → Tuple[int, Mapping[str, str], Iterable[bytes]][source]

Perform a request to the server given by url

Parameters:

  • url – the url to the server, given as a parsed url

  • request_headers – a sequence containing RequestHeader objects representing the request headers

  • body – the request body

set_body_obfuscator(body_obfuscator: BodyObfuscator) → None[source]

Sets the current body obfuscator to use.

set_header_obfuscator(header_obfuscator: HeaderObfuscator) → None[source]

Sets the current header obfuscator to use.

property socket_timeout: int | None

Socket timeout in seconds

class worldline.acquiring.sdk.communication.metadata_provider.MetadataProvider(integrator: str | None, shopping_cart_extension: ShoppingCartExtension | None = None, additional_request_headers: Sequence[RequestHeader] | None = ())[source]

Bases: object

Provides meta info about the server.

__annotations__ = {'_MetadataProvider__metadata_headers': typing.Sequence[worldline.acquiring.sdk.communication.request_header.RequestHeader]}
property metadata_headers: Sequence[RequestHeader]
Returns:

The server related headers containing the metadata to be associated with the request (if any). This will always contain at least an automatically generated header X-WL-ServerMetaInfo.

prohibited_headers = ('Authorization', 'Content-Type', 'Date', 'X-WL-ServerMetaInfo')
class worldline.acquiring.sdk.communication.multipart_form_data_object.MultipartFormDataObject[source]

Bases: object

A representation of a multipart/form-data object.

add_file(parameter_name: str, uploadable_file: UploadableFile) → None[source]
add_value(parameter_name: str, value: str) → None[source]
property boundary: str
property content_type: str
property files: Mapping[str, UploadableFile]
property values: Mapping[str, str]
class worldline.acquiring.sdk.communication.multipart_form_data_request.MultipartFormDataRequest[source]

Bases: ABC

A representation of a multipart/form-data request.

__abstractmethods__ = frozenset({'to_multipart_form_data_object'})
__annotations__ = {}
abstractmethod to_multipart_form_data_object() → MultipartFormDataObject[source]
Returns:

worldline.acquiring.sdk.communication.MultipartFormDataObject

exception worldline.acquiring.sdk.communication.not_found_exception.NotFoundException(exception: Exception, message: str)[source]

Bases: RuntimeError

Indicates an exception that occurs when the requested resource is not found. In normal usage of the SDK, this exception should not occur, however it is possible. For example when path parameters are set with invalid values.

class worldline.acquiring.sdk.communication.param_request.ParamRequest[source]

Bases: ABC

Represents a set of request parameters.

__abstractmethods__ = frozenset({'to_request_parameters'})
__annotations__ = {}
abstractmethod to_request_parameters() → List[RequestParam][source]
Returns:

list[worldline.acquiring.sdk.communication.RequestParam] representing the HTTP request parameters

class worldline.acquiring.sdk.communication.pooled_connection.PooledConnection[source]

Bases: Connection, ABC

Represents a pooled connection to the Worldline Acquiring platform server. Instead of setting up a new HTTP connection for each request, this connection uses a pool of HTTP connections.

__abstractmethods__ = frozenset({'close_expired_connections', 'close_idle_connections', 'delete', 'disable_logging', 'enable_logging', 'get', 'post', 'put', 'set_body_obfuscator', 'set_header_obfuscator'})
__annotations__ = {}
abstractmethod close_expired_connections() → None[source]

Closes all expired HTTP connections.

abstractmethod close_idle_connections(idle_time: timedelta) → None[source]

Closes all HTTP connections that have been idle for the specified time. This should also include all expired HTTP connections.

Parameters:

idle_time – a datetime.timedelta object indicating the idle time

class worldline.acquiring.sdk.communication.request_header.RequestHeader(name: str, value: str | None)[source]

Bases: object

A single request header. Immutable.

property name: str
Returns:

The header name.

property value: str | None
Returns:

The un-encoded value.

worldline.acquiring.sdk.communication.request_header.get_header(headers: Sequence[RequestHeader] | Mapping[str, str] | None, header_name: str) → RequestHeader | None[source]
Returns:

The header with the given name, or None if there was no such header.

worldline.acquiring.sdk.communication.request_header.get_header_value(headers: Sequence[RequestHeader] | Mapping[str, str] | None, header_name: str) → str | None[source]
Returns:

The value of the header with the given name, or None if there was no such header.

class worldline.acquiring.sdk.communication.request_param.RequestParam(name: str, value: str | None)[source]

Bases: object

A single request parameter. Immutable.

property name: str
Returns:

The parameter name.

property value: str | None
Returns:

The un-encoded value.

exception worldline.acquiring.sdk.communication.response_exception.ResponseException(status: int, body: str | None, headers: Mapping[str, str] | None)[source]

Bases: RuntimeError

Thrown when a response was received from the Worldline Acquiring platform which indicates an error.

property body: str | None
Returns:

The raw response body that was returned by the Worldline Acquiring platform.

get_header(header_name: str) → Tuple[str, str] | None[source]
Returns:

The header with the given name, or None if there was no such header.

get_header_value(header_name: str) → str | None[source]
Returns:

The value header with the given name, or None if there was no such header.

property headers: Mapping[str, str]
Returns:

The headers that were returned by the Worldline Acquiring platform. Never None.

property status_code: int
Returns:

The HTTP status code that was returned by the Worldline Acquiring platform.

worldline.acquiring.sdk.communication.response_header.get_disposition_filename(headers: Mapping[str, str] | None) → str | None[source]
Returns:

The value of the filename parameter of the Content-Disposition header, or None if there was no such header or parameter.

worldline.acquiring.sdk.communication.response_header.get_header(headers: Mapping[str, str] | None, header_name: str) → Tuple[str, str] | None[source]
Returns:

The header with the given name as a tuple with the name and value, or None if there was no such header.

worldline.acquiring.sdk.communication.response_header.get_header_value(headers: Mapping[str, str] | None, header_name: str) → str | None[source]
Returns:

The value of the header with the given name, or None if there was no such header.

class worldline.acquiring.sdk.domain.data_object.DataObject[source]

Bases: object

static format_date(d: date) → str[source]
static format_datetime(dt: datetime) → str[source]
from_dictionary(dictionary: dict) → DataObject[source]
static parse_date(s: str) → date[source]
static parse_datetime(s: str) → datetime[source]
to_dictionary() → dict[source]
class worldline.acquiring.sdk.domain.shopping_cart_extension.ShoppingCartExtension(creator: str, name: str, version: str, extension_id: str | None = None)[source]

Bases: DataObject

__annotations__ = {}
static create_from_dictionary(dictionary: dict) → ShoppingCartExtension[source]
property creator: str
property extension_id: str | None
from_dictionary(dictionary: dict) → ShoppingCartExtension[source]
property name: str
to_dictionary() → dict[source]
property version: str
class worldline.acquiring.sdk.domain.uploadable_file.UploadableFile(file_name: str, content: Any, content_type: str, content_length: int = -1)[source]

Bases: object

A file that can be uploaded.

The allowed forms of content are defined by the Connection implementation. The default implementation supports strings, file descriptors and io.BytesIO objects.

property content: Any
Returns:

The file’s content.

property content_length: int
Returns:

The file’s content length, or -1 if not known.

property content_type: str
Returns:

The file’s content type.

property file_name: str
Returns:

The name of the file.

class worldline.acquiring.sdk.json.default_marshaller.DefaultMarshaller[source]

Bases: Marshaller

Marshaller implementation based on json.

__abstractmethods__ = frozenset({})
__annotations__ = {}
static instance() → DefaultMarshaller[source]
marshal(request_object: Any) → str[source]

Marshal a request object to a JSON string.

Parameters:

request_object – the object to marshal into a serialized JSON string

Returns:

the serialized JSON string of the request_object

unmarshal(response_json: str | bytes | None, type_class: Type[T]) → T[source]

Unmarshal a JSON string to a response object.

Parameters:

  • response_json – the json body that should be unmarshalled

  • type_class – The class to which the response_json should be unmarshalled

Raises:

MarshallerSyntaxException – if the JSON is not a valid representation for an object of the given type

class worldline.acquiring.sdk.json.marshaller.Marshaller[source]

Bases: ABC

Used to marshal and unmarshal Worldline Acquiring platform request and response objects to and from JSON.

__abstractmethods__ = frozenset({'marshal', 'unmarshal'})
__annotations__ = {}
abstractmethod marshal(request_object: Any) → str[source]

Marshal a request object to a JSON string.

Parameters:

request_object – the object to marshal into a serialized JSON string

Returns:

the serialized JSON string of the request_object

abstractmethod unmarshal(response_json: str | bytes | None, type_class: Type[T]) → T | None[source]

Unmarshal a JSON string to a response object.

Parameters:

  • response_json – the json body that should be unmarshalled

  • type_class – The class to which the response_json should be unmarshalled

Raises:

MarshallerSyntaxException – if the JSON is not a valid representation for an object of the given type

exception worldline.acquiring.sdk.json.marshaller_syntax_exception.MarshallerSyntaxException(cause: Exception | None = None)[source]

Bases: RuntimeError

Thrown when a JSON string cannot be converted to a response object.

class worldline.acquiring.sdk.log.body_obfuscator.BodyObfuscator(additional_rules: Mapping[str, Callable[[str], str]] | None = None)[source]

Bases: object

A class that can be used to obfuscate properties in JSON bodies.

__annotations__ = {'_BodyObfuscator__obfuscation_rules': typing.Dict[str, typing.Callable[[str], str]], '_BodyObfuscator__property_pattern': typing.Pattern[~AnyStr]}
__init__(additional_rules: Mapping[str, Callable[[str], str]] | None = None)[source]

Creates a new body obfuscator. This will contain some pre-defined obfuscation rules, as well as any provided custom rules

Parameters:

additional_rules – An optional mapping from property names to obfuscation rules, where an obfuscation rule is a function that obfuscates a single string,

static default_body_obfuscator() → BodyObfuscator[source]
obfuscate_body(body: str | bytes | None, charset: str | None = None) → str | None[source]

Obfuscates the body from the given stream as necessary. :param body: The body to obfuscate, as string or bytes. :param charset: The charset to use to read the body bytes.

class worldline.acquiring.sdk.log.communicator_logger.CommunicatorLogger[source]

Bases: ABC

Used to log messages from communicators.

__abstractmethods__ = frozenset({'log'})
__annotations__ = {}
abstractmethod log(message: str, thrown: Exception | None = None) → None[source]

Logs a throwable with an accompanying message.

Parameters:

  • message – The message accompanying the throwable.

  • thrown – The throwable to log.

log_request(request_log_message: RequestLogMessage) → None[source]

Logs a request message object

log_response(response_log_message: ResponseLogMessage) → None[source]

Logs a response message object

class worldline.acquiring.sdk.log.header_obfuscator.HeaderObfuscator(additional_rules: Mapping[str, Callable[[str], str]] | None = None)[source]

Bases: object

A class that can be used to obfuscate headers.

__annotations__ = {'_HeaderObfuscator__obfuscation_rules': typing.Dict[str, typing.Callable[[str], str]]}
__init__(additional_rules: Mapping[str, Callable[[str], str]] | None = None)[source]

Creates a new header obfuscator. This will contain some pre-defined obfuscation rules, as well as any provided custom rules

Parameters:

additional_rules – An optional mapping from property names to obfuscation rules, where an obfuscation rule is a function that obfuscates a single string,

static default_header_obfuscator() → HeaderObfuscator[source]
obfuscate_header(header_name: str, value: str) → str[source]

Obfuscates the value for the given header as necessary.

class worldline.acquiring.sdk.log.log_message.LogMessage(request_id: str, body_obfuscator: BodyObfuscator = <worldline.acquiring.sdk.log.body_obfuscator.BodyObfuscator object>, header_obfuscator: HeaderObfuscator = <worldline.acquiring.sdk.log.header_obfuscator.HeaderObfuscator object>)[source]

Bases: ABC

A utility class to build log messages.

__abstractmethods__ = frozenset({'get_message'})
__annotations__ = {'_LogMessage__body': typing.Optional[str], '_LogMessage__body_obfuscator': <class 'worldline.acquiring.sdk.log.body_obfuscator.BodyObfuscator'>, '_LogMessage__content_type': typing.Optional[str], '_LogMessage__header_list': typing.List[typing.Tuple[str, str]], '_LogMessage__header_obfuscator': <class 'worldline.acquiring.sdk.log.header_obfuscator.HeaderObfuscator'>, '_LogMessage__headers': <class 'str'>, '_LogMessage__request_id': <class 'str'>, '__body': 'Optional[str]', '__body_obfuscator': 'BodyObfuscator', '__content_type': 'Optional[str]', '__header_list': 'List[Tuple[str, str]]', '__header_obfuscator': 'HeaderObfuscator', '__headers': 'str', '__request_id': 'str'}
add_header(name: str, value: str | None) → None[source]
property body: str | None
property content_type: str | None
static empty_if_none(value: str | None) → str[source]
get_header_list() → Sequence[Tuple[str, str]][source]
abstractmethod get_message() → str[source]
property headers: str
property request_id: str
set_binary_body(content_type: str | None) → None[source]
set_body(body: str | bytes | None, content_type: str | None, charset: str | None = None) → None[source]
class worldline.acquiring.sdk.log.logging_capable.LoggingCapable[source]

Bases: ABC

Classes that extend this class have support for log messages from communicators.

__abstractmethods__ = frozenset({'disable_logging', 'enable_logging'})
__annotations__ = {}
abstractmethod disable_logging() → None[source]

Turns off logging.

abstractmethod enable_logging(communicator_logger: CommunicatorLogger) → None[source]

Turns on logging using the given communicator logger.

Raises:

ValueError – If the given communicator logger is None.

class worldline.acquiring.sdk.log.obfuscation_capable.ObfuscationCapable[source]

Bases: ABC

Classes that extend this class support obfuscating bodies and headers.

__abstractmethods__ = frozenset({'set_body_obfuscator', 'set_header_obfuscator'})
__annotations__ = {}
abstractmethod set_body_obfuscator(body_obfuscator: BodyObfuscator) → None[source]

Sets the current body obfuscator to use.

abstractmethod set_header_obfuscator(header_obfuscator: HeaderObfuscator) → None[source]

Sets the current header obfuscator to use.

worldline.acquiring.sdk.log.obfuscation_rule.obfuscate_all() → Callable[[str], str][source]

Returns an obfuscation rule (function) that will replace all characters with *

worldline.acquiring.sdk.log.obfuscation_rule.obfuscate_all_but_first(count: int) → Callable[[str], str][source]

Returns an obfuscation rule (function) that will keep a fixed number of characters at the start, then replaces all other characters with *

worldline.acquiring.sdk.log.obfuscation_rule.obfuscate_all_but_last(count: int) → Callable[[str], str][source]

Returns an obfuscation rule that will keep a fixed number of characters at the end, then replaces all other characters with *

worldline.acquiring.sdk.log.obfuscation_rule.obfuscate_with_fixed_length(fixed_length: int) → Callable[[str], str][source]

Returns an obfuscation rule (function) that will replace values with a fixed length string containing only *

class worldline.acquiring.sdk.log.python_communicator_logger.PythonCommunicatorLogger(logger: Logger, log_level: int, error_log_level: int | None = None)[source]

Bases: CommunicatorLogger

A communicator logger that is backed by the log library.

__abstractmethods__ = frozenset({})
__annotations__ = {}
__init__(logger: Logger, log_level: int, error_log_level: int | None = None)[source]

Logs messages to the argument logger using the argument log_level. If absent, the error_log_level will be equal to the log_level. Note that if the CommunicatorLogger’s log level is lower than the argument logger’s log level (e.g. the CommunicatorLogger is given log.INFO as level and the argument logger has a level of log.WARNING), then nothing will be logged to the logger.

Parameters:

  • logger – the logger to log to

  • log_level – the log level that will be used for non-error messages logged via the CommunicatorLogger

  • error_log_level – the log level that will be used for error messages logged via the CommunicatorLogger.

log(message: str, thrown: Exception | None = None) → None[source]

Log a message to the underlying logger. If thrown is absent, the message will be logged with the CommunicatorLogger’s log_level, if a thrown object is provided, the message and exception will be logged with the CommunicatorLogger’s error_log_level.

Parameters:

  • message – the message to be logged

  • thrown – an optional throwable object

class worldline.acquiring.sdk.log.request_log_message.RequestLogMessage(request_id: str, method: str, uri: str, body_obfuscator: BodyObfuscator = <worldline.acquiring.sdk.log.body_obfuscator.BodyObfuscator object>, header_obfuscator: HeaderObfuscator = <worldline.acquiring.sdk.log.header_obfuscator.HeaderObfuscator object>)[source]

Bases: LogMessage

A utility class to build request log messages.

__abstractmethods__ = frozenset({})
__annotations__ = {}
get_message() → str[source]
class worldline.acquiring.sdk.log.response_log_message.ResponseLogMessage(request_id: str, status_code: int, duration: int = -1, body_obfuscator: BodyObfuscator = <worldline.acquiring.sdk.log.body_obfuscator.BodyObfuscator object>, header_obfuscator: HeaderObfuscator = <worldline.acquiring.sdk.log.header_obfuscator.HeaderObfuscator object>)[source]

Bases: LogMessage

A utility class to build request log messages.

__abstractmethods__ = frozenset({})
__annotations__ = {}
get_duration() → int[source]
get_message() → str[source]
get_status_code() → int[source]
class worldline.acquiring.sdk.log.sys_out_communicator_logger.SysOutCommunicatorLogger[source]

Bases: CommunicatorLogger

A communicator logger that prints its message to sys.stdout It includes a timestamp in yyyy-MM-ddTHH:mm:ss format in the system time zone.

__abstractmethods__ = frozenset({})
__annotations__ = {}
static instance() → SysOutCommunicatorLogger[source]
log(message: str, thrown: Exception | None = None) → None[source]

Logs a throwable with an accompanying message.

Parameters:

  • message – The message accompanying the throwable.

  • thrown – The throwable to log.

exception worldline.acquiring.sdk.v1.api_exception.ApiException(status_code: int, response_body: str, type: str | None, title: str | None, status: int | None, detail: str | None, instance: str | None, message: str = 'The Worldline Acquiring platform returned an error response')[source]

Bases: RuntimeError

Represents an error response from the Worldline Acquiring platform.

property detail: str | None
Returns:

The detail received from the Worldline Acquiring platform if available.

property instance: str | None
Returns:

The instance received from the Worldline Acquiring platform if available.

property response_body: str
Returns:

The raw response body that was returned by the Worldline Acquiring platform.

property status: int | None
Returns:

The status received from the Worldline Acquiring platform if available.

property status_code: int
Returns:

The HTTP status code that was returned by the Worldline Acquiring platform.

property title: str | None
Returns:

The title received from the Worldline Acquiring platform if available.

property type: str | None
Returns:

The type received from the Worldline Acquiring platform if available.

exception worldline.acquiring.sdk.v1.authorization_exception.AuthorizationException(status_code: int, response_body: str, type: str | None, title: str | None, status: int | None, detail: str | None, instance: str | None, message: str = 'The Worldline Acquiring platform returned an API authorization error response')[source]

Bases: ApiException

Represents an error response from the Worldline Acquiring platform when API authorization failed.

__annotations__ = {}
worldline.acquiring.sdk.v1.exception_factory.create_exception(status_code: int, body: str, error_object: Any, context: CallContext | None) → Exception[source]

Return a raisable API exception based on the error object given

exception worldline.acquiring.sdk.v1.platform_exception.PlatformException(status_code: int, response_body: str, type: str | None, title: str | None, status: int | None, detail: str | None, instance: str | None, message: str = 'The Worldline Acquiring platform returned an error response')[source]

Bases: ApiException

Represents an error response from the Worldline Acquiring platform when something went wrong at the Worldline Acquiring platform or further downstream.

__annotations__ = {}
exception worldline.acquiring.sdk.v1.reference_exception.ReferenceException(status_code: int, response_body: str, type: str | None, title: str | None, status: int | None, detail: str | None, instance: str | None, message: str = 'The Worldline Acquiring platform returned a reference error response')[source]

Bases: ApiException

Represents an error response from the Worldline Acquiring platform when a non-existing or removed object is trying to be accessed.

__annotations__ = {}
class worldline.acquiring.sdk.v1.v1_client.V1Client(parent: ApiResource, path_context: Mapping[str, str] | None)[source]

Bases: ApiResource

V1 client.

Thread-safe.

__annotations__ = {}
__init__(parent: ApiResource, path_context: Mapping[str, str] | None)[source]
Parameters:
acquirer(acquirer_id: str) → AcquirerClient[source]

Resource /processing/v1/{acquirerId}

Parameters:

acquirer_id – str

Returns:

worldline.acquiring.sdk.v1.acquirer.acquirer_client.AcquirerClient

dispute_documents() → DisputeDocumentsClient[source]

Resource /dispute-management/v1/documents

Returns:

worldline.acquiring.sdk.v1.disputedocuments.dispute_documents_client.DisputeDocumentsClient

dispute_entries() → DisputeEntriesClient[source]

Resource /dispute-management/v1/dispute-entries/search

Returns:

worldline.acquiring.sdk.v1.disputeentries.dispute_entries_client.DisputeEntriesClient

dispute_management() → DisputeManagementClient[source]

Resource /dispute-management/v1/disputes/search

Returns:

worldline.acquiring.sdk.v1.disputemanagement.dispute_management_client.DisputeManagementClient

ping() → PingClient[source]

Resource /services/v1/ping

Returns:

worldline.acquiring.sdk.v1.ping.ping_client.PingClient

exception worldline.acquiring.sdk.v1.validation_exception.ValidationException(status_code: int, response_body: str, type: str | None, title: str | None, status: int | None, detail: str | None, instance: str | None, message: str = 'The Worldline Acquiring platform returned an incorrect request error response')[source]

Bases: ApiException

Represents an error response from the Worldline Acquiring platform when validation of requests failed.

__annotations__ = {}
class worldline.acquiring.sdk.v1.acquirer.acquirer_client.AcquirerClient(parent: ApiResource, path_context: Mapping[str, str] | None)[source]

Bases: ApiResource

Acquirer client. Thread-safe.

__annotations__ = {}
__init__(parent: ApiResource, path_context: Mapping[str, str] | None)[source]
Parameters:
merchant(merchant_id: str) → MerchantClient[source]

Resource /processing/v1/{acquirerId}/{merchantId}

Parameters:

merchant_id – str

Returns:

worldline.acquiring.sdk.v1.acquirer.merchant.merchant_client.MerchantClient

class worldline.acquiring.sdk.v1.acquirer.merchant.merchant_client.MerchantClient(parent: ApiResource, path_context: Mapping[str, str] | None)[source]

Bases: ApiResource

Merchant client. Thread-safe.

__annotations__ = {}
__init__(parent: ApiResource, path_context: Mapping[str, str] | None)[source]
Parameters:
account_verifications() → AccountVerificationsClient[source]

Resource /processing/v1/{acquirerId}/{merchantId}/account-verifications

Returns:

worldline.acquiring.sdk.v1.acquirer.merchant.accountverifications.account_verifications_client.AccountVerificationsClient

balance_inquiries() → BalanceInquiriesClient[source]

Resource /processing/v1/{acquirerId}/{merchantId}/balance-inquiries

Returns:

worldline.acquiring.sdk.v1.acquirer.merchant.balanceinquiries.balance_inquiries_client.BalanceInquiriesClient

card_payments() → CardPaymentsClient[source]

Resource /processing/v1/{acquirerId}/{merchantId}/payments

Returns:

worldline.acquiring.sdk.v1.acquirer.merchant.cardpayments.card_payments_client.CardPaymentsClient

card_refunds() → CardRefundsClient[source]

Resource /processing/v1/{acquirerId}/{merchantId}/refunds

Returns:

worldline.acquiring.sdk.v1.acquirer.merchant.cardrefunds.card_refunds_client.CardRefundsClient

dynamic_currency_conversion() → DynamicCurrencyConversionClient[source]

Resource /services/v1/{acquirerId}/{merchantId}/dcc-rates

Returns:

worldline.acquiring.sdk.v1.acquirer.merchant.dynamiccurrencyconversion.dynamic_currency_conversion_client.DynamicCurrencyConversionClient

technical_reversals() → TechnicalReversalsClient[source]

Resource /processing/v1/{acquirerId}/{merchantId}/operations/{operationId}/reverse

Returns:

worldline.acquiring.sdk.v1.acquirer.merchant.technicalreversals.technical_reversals_client.TechnicalReversalsClient

class worldline.acquiring.sdk.v1.acquirer.merchant.accountverifications.account_verifications_client.AccountVerificationsClient(parent: ApiResource, path_context: Mapping[str, str] | None)[source]

Bases: ApiResource

AccountVerifications client. Thread-safe.

__annotations__ = {}
__init__(parent: ApiResource, path_context: Mapping[str, str] | None)[source]
Parameters:
process_account_verification(body: ApiAccountVerificationRequest, context: CallContext | None = None) → ApiAccountVerificationResponse[source]

Resource /processing/v1/{acquirerId}/{merchantId}/account-verifications - Verify account

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Account-Verifications/operation/processAccountVerification

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.api_account_verification_response.ApiAccountVerificationResponse

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

class worldline.acquiring.sdk.v1.acquirer.merchant.balanceinquiries.balance_inquiries_client.BalanceInquiriesClient(parent: ApiResource, path_context: Mapping[str, str] | None)[source]

Bases: ApiResource

BalanceInquiries client. Thread-safe.

__annotations__ = {}
__init__(parent: ApiResource, path_context: Mapping[str, str] | None)[source]
Parameters:
process_balance_inquiry(body: ApiBalanceInquiryRequest, context: CallContext | None = None) → ApiBalanceInquiryResponse[source]

Resource /processing/v1/{acquirerId}/{merchantId}/balance-inquiries - Balance inquiry

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Balance-Inquiries/operation/processBalanceInquiry

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.api_balance_inquiry_response.ApiBalanceInquiryResponse

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

class worldline.acquiring.sdk.v1.acquirer.merchant.cardpayments.card_payments_client.CardPaymentsClient(parent: ApiResource, path_context: Mapping[str, str] | None)[source]

Bases: ApiResource

CardPayments client. Thread-safe.

__annotations__ = {}
__init__(parent: ApiResource, path_context: Mapping[str, str] | None)[source]
Parameters:
create_refund(payment_id: str, body: ApiPaymentRefundRequest, context: CallContext | None = None) → ApiActionResponseForRefund[source]

Resource /processing/v1/{acquirerId}/{merchantId}/payments/{paymentId}/refunds - Refund card payment

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Card-Payments/operation/createRefund

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.api_action_response_for_refund.ApiActionResponseForRefund

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

get_payment_status(payment_id: str, query: GetPaymentStatusParams, context: CallContext | None = None) → ApiPaymentResource[source]

Resource /processing/v1/{acquirerId}/{merchantId}/payments/{paymentId} - Retrieve payment

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Card-Payments/operation/getPaymentStatus

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.api_payment_resource.ApiPaymentResource

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

increment_payment(payment_id: str, body: ApiIncrementRequest, context: CallContext | None = None) → ApiIncrementResponse[source]

Resource /processing/v1/{acquirerId}/{merchantId}/payments/{paymentId}/increments - Increment authorization

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Card-Payments/operation/incrementPayment

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.api_increment_response.ApiIncrementResponse

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

process_payment(body: ApiPaymentRequest, context: CallContext | None = None) → ApiPaymentResponse[source]

Resource /processing/v1/{acquirerId}/{merchantId}/payments - Create payment

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Card-Payments/operation/processPayment

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.api_payment_response.ApiPaymentResponse

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

reverse_authorization(payment_id: str, body: ApiPaymentReversalRequest, context: CallContext | None = None) → ApiReversalResponse[source]

Resource /processing/v1/{acquirerId}/{merchantId}/payments/{paymentId}/authorization-reversals - Reverse authorization

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Card-Payments/operation/reverseAuthorization

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.api_reversal_response.ApiReversalResponse

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

simple_capture_of_payment(payment_id: str, body: ApiCaptureRequest, context: CallContext | None = None) → ApiActionResponse[source]

Resource /processing/v1/{acquirerId}/{merchantId}/payments/{paymentId}/captures - Capture payment

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Card-Payments/operation/simpleCaptureOfPayment

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.api_action_response.ApiActionResponse

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

class worldline.acquiring.sdk.v1.acquirer.merchant.cardpayments.get_payment_status_params.GetPaymentStatusParams[source]

Bases: ParamRequest

Query parameters for Retrieve payment

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Card-Payments/operation/getPaymentStatus

__abstractmethods__ = frozenset({})
__annotations__ = {'_GetPaymentStatusParams__return_operations': typing.Optional[bool], '__return_operations': 'Optional[bool]'}
property return_operations: bool | None
If true, the response will contain the operations of the payment. False by default.

Type: bool

to_request_parameters() → List[RequestParam][source]
Returns:

list[RequestParam]

class worldline.acquiring.sdk.v1.acquirer.merchant.cardrefunds.card_refunds_client.CardRefundsClient(parent: ApiResource, path_context: Mapping[str, str] | None)[source]

Bases: ApiResource

CardRefunds client. Thread-safe.

__annotations__ = {}
__init__(parent: ApiResource, path_context: Mapping[str, str] | None)[source]
Parameters:
capture_refund(refund_id: str, body: ApiCaptureRequestForRefund, context: CallContext | None = None) → ApiActionResponseForRefund[source]

Resource /processing/v1/{acquirerId}/{merchantId}/refunds/{refundId}/captures - Capture refund

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Card-Refunds/operation/captureRefund

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.api_action_response_for_refund.ApiActionResponseForRefund

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

get_refund(refund_id: str, query: GetRefundParams, context: CallContext | None = None) → ApiRefundResource[source]

Resource /processing/v1/{acquirerId}/{merchantId}/refunds/{refundId} - Retrieve card refund

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Card-Refunds/operation/getRefund

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.api_refund_resource.ApiRefundResource

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

process_standalone_refund(body: ApiRefundRequest, context: CallContext | None = None) → ApiRefundResponse[source]

Resource /processing/v1/{acquirerId}/{merchantId}/refunds - Create standalone card refund

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Card-Refunds/operation/processStandaloneRefund

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.api_refund_response.ApiRefundResponse

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

reverse_refund_authorization(refund_id: str, body: ApiRefundReversalRequest, context: CallContext | None = None) → ApiActionResponseForRefund[source]

Resource /processing/v1/{acquirerId}/{merchantId}/refunds/{refundId}/authorization-reversals - Reverse refund authorization

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Card-Refunds/operation/reverseRefundAuthorization

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.api_action_response_for_refund.ApiActionResponseForRefund

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

class worldline.acquiring.sdk.v1.acquirer.merchant.cardrefunds.get_refund_params.GetRefundParams[source]

Bases: ParamRequest

Query parameters for Retrieve card refund

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Card-Refunds/operation/getRefund

__abstractmethods__ = frozenset({})
__annotations__ = {'_GetRefundParams__return_operations': typing.Optional[bool], '__return_operations': 'Optional[bool]'}
property return_operations: bool | None
If true, the response will contain the operations of the payment. False by default.

Type: bool

to_request_parameters() → List[RequestParam][source]
Returns:

list[RequestParam]

class worldline.acquiring.sdk.v1.acquirer.merchant.dynamiccurrencyconversion.dynamic_currency_conversion_client.DynamicCurrencyConversionClient(parent: ApiResource, path_context: Mapping[str, str] | None)[source]

Bases: ApiResource

DynamicCurrencyConversion client. Thread-safe.

__annotations__ = {}
__init__(parent: ApiResource, path_context: Mapping[str, str] | None)[source]
Parameters:
request_dcc_rate(body: GetDccRateRequest, context: CallContext | None = None) → GetDccRateResponse[source]

Resource /services/v1/{acquirerId}/{merchantId}/dcc-rates - Request DCC rate

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Dynamic-Currency-Conversion/operation/requestDccRate

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.get_dcc_rate_response.GetDccRateResponse

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

class worldline.acquiring.sdk.v1.acquirer.merchant.technicalreversals.technical_reversals_client.TechnicalReversalsClient(parent: ApiResource, path_context: Mapping[str, str] | None)[source]

Bases: ApiResource

TechnicalReversals client. Thread-safe.

__annotations__ = {}
__init__(parent: ApiResource, path_context: Mapping[str, str] | None)[source]
Parameters:
technical_reversal(operation_id: str, body: ApiTechnicalReversalRequest, context: CallContext | None = None) → ApiTechnicalReversalResponse[source]

Resource /processing/v1/{acquirerId}/{merchantId}/operations/{operationId}/reverse - Technical reversal

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Technical-Reversals/operation/technicalReversal

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.api_technical_reversal_response.ApiTechnicalReversalResponse

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

class worldline.acquiring.sdk.v1.disputedocuments.dispute_documents_client.DisputeDocumentsClient(parent: ApiResource, path_context: Mapping[str, str] | None)[source]

Bases: ApiResource

DisputeDocuments client. Thread-safe.

__annotations__ = {}
__init__(parent: ApiResource, path_context: Mapping[str, str] | None)[source]
Parameters:
get_dispute_document(dispute_id: str, document_id: str, context: CallContext | None = None) → Tuple[Mapping[str, str], Iterable[bytes]][source]

Resource /dispute-management/v1/disputes/{disputeId}/documents/{documentId} - Retrieve Dispute Document

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Dispute-Documents/operation/getDisputeDocument

Parameters:
Returns:

Tuple[Mapping[str, str], Iterable[bytes]]

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

upload_dispute_document(body: UploadDisputeDocumentRequest, context: CallContext | None = None) → UploadDocumentResponse[source]

Resource /dispute-management/v1/documents - Upload Dispute Document

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Dispute-Documents/operation/uploadDisputeDocument

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.upload_document_response.UploadDocumentResponse

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

class worldline.acquiring.sdk.v1.disputedocuments.upload_dispute_document_request.UploadDisputeDocumentRequest[source]

Bases: MultipartFormDataRequest

Multipart/form-data parameters for Upload Dispute Document

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Dispute-Documents/operation/uploadDisputeDocument

__abstractmethods__ = frozenset({})
__annotations__ = {'_UploadDisputeDocumentRequest__file': typing.Optional[worldline.acquiring.sdk.domain.uploadable_file.UploadableFile], '__file': 'Optional[UploadableFile]'}
property file: UploadableFile | None
The file to upload as evidence. The file must be provided in the multipart form data of the request.

Type: worldline.acquiring.sdk.domain.uploadable_file.UploadableFile

to_multipart_form_data_object() → MultipartFormDataObject[source]
Returns:

worldline.acquiring.sdk.communication.multipart_form_data_object.MultipartFormDataObject

class worldline.acquiring.sdk.v1.disputeentries.dispute_entries_client.DisputeEntriesClient(parent: ApiResource, path_context: Mapping[str, str] | None)[source]

Bases: ApiResource

DisputeEntries client. Thread-safe.

__annotations__ = {}
__init__(parent: ApiResource, path_context: Mapping[str, str] | None)[source]
Parameters:
search_dispute_entries(body: SearchDisputeEntriesRequest, context: CallContext | None = None) → DisputeEntryResources[source]

Resource /dispute-management/v1/dispute-entries/search - Search Dispute Entries

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Dispute-Entries/operation/searchDisputeEntries

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.dispute_entry_resources.DisputeEntryResources

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

class worldline.acquiring.sdk.v1.disputemanagement.dispute_management_client.DisputeManagementClient(parent: ApiResource, path_context: Mapping[str, str] | None)[source]

Bases: ApiResource

DisputeManagement client. Thread-safe.

__annotations__ = {}
__init__(parent: ApiResource, path_context: Mapping[str, str] | None)[source]
Parameters:
accept_dispute_liability(dispute_id: str, body: AcceptDisputeLiabilityRequest, context: CallContext | None = None) → DisputeResponse[source]

Resource /dispute-management/v1/disputes/{disputeId}/accept - Accept Liability

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Dispute-Management/operation/acceptDisputeLiability

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.dispute_response.DisputeResponse

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

get_dispute(dispute_id: str, query: GetDisputeParams, context: CallContext | None = None) → DisputeResponse[source]

Resource /dispute-management/v1/disputes/{disputeId} - Retrieve Dispute

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Dispute-Management/operation/getDispute

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.dispute_response.DisputeResponse

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

search_disputes(body: SearchDisputesRequest, context: CallContext | None = None) → SearchDisputesResponse[source]

Resource /dispute-management/v1/disputes/search - Search Disputes

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Dispute-Management/operation/searchDisputes

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.search_disputes_response.SearchDisputesResponse

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

submit_evidence(dispute_id: str, body: SubmitEvidenceRequest, context: CallContext | None = None) → DisputeResponse[source]

Resource /dispute-management/v1/disputes/{disputeId}/submit-evidence - Submit Evidence

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Dispute-Management/operation/submitEvidence

Parameters:
Returns:

worldline.acquiring.sdk.v1.domain.dispute_response.DisputeResponse

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

class worldline.acquiring.sdk.v1.disputemanagement.get_dispute_params.GetDisputeParams[source]

Bases: ParamRequest

Query parameters for Retrieve Dispute

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Dispute-Management/operation/getDispute

__abstractmethods__ = frozenset({})
__annotations__ = {'_GetDisputeParams__include_entries': typing.Optional[bool], '__include_entries': 'Optional[bool]'}
property include_entries: bool | None
If true, the response will include the full history of dispute entries related to the dispute. False by default.

Type: bool

to_request_parameters() → List[RequestParam][source]
Returns:

list[RequestParam]

class worldline.acquiring.sdk.v1.domain.accept_dispute_liability_request.AcceptDisputeLiabilityRequest[source]

Bases: DataObject

__annotations__ = {'_AcceptDisputeLiabilityRequest__include_entries': typing.Optional[bool], '_AcceptDisputeLiabilityRequest__message_text': typing.Optional[str], '_AcceptDisputeLiabilityRequest__user_id': typing.Optional[str]}
from_dictionary(dictionary: dict) → AcceptDisputeLiabilityRequest[source]
property include_entries: bool | None
If true, the response will include the full history of dispute entries related to the dispute. False by default.

Type: bool

property message_text: str | None
The message text of the dispute entry, if applicable. This is typically used for communication entries to provide the content of the message sent by the acquirer to the merchant or vice versa.

Type: str

to_dictionary() → dict[source]
property user_id: str | None
The unique identifier of the user that triggered the dispute entry, if applicable.

Type: str

class worldline.acquiring.sdk.v1.domain.additional_response_data.AdditionalResponseData[source]

Bases: DataObject

__annotations__ = {'_AdditionalResponseData__merchant_advice_code': typing.Optional[str], '_AdditionalResponseData__merchant_advice_code_description': typing.Optional[str]}
from_dictionary(dictionary: dict) → AdditionalResponseData[source]
property merchant_advice_code: str | None
Merchant advice code as returned by the scheme, usually returned upon rejection. Known possible values at the time of writing this documentation are:

  • 01 - New Account Information Available

  • 02 - Try Again Later

  • 03 - Do Not Try Again

  • 04 - Token requirements not fulfilled for this token type

  • 05 - Negotiated value not provided

  • 21 - Payment Cancellation

  • 22 - Merchant does not qualify for product code

  • 24 - Retry after 1 hour

  • 25 - Retry after 24 hours

  • 26 - Retry after 2 days

  • 27 - Retry after 4 days

  • 28 - Retry after 6 days

  • 29 - Retry after 8 days

  • 30 - Retry after 10 days

  • 40 - Consumer non-reloadable prepaid card

  • 41 - Consumer single-use virtual card number

  • 42 - Sanctions Scoring Service: Score Exceeds Applicable Threshold Value

  • 43 - Consumer multi-use virtual card number Note: In case new values are added and returned by the schemes, they will be returned as is. We will maintain the above list on a best-effort basis.

Type: str

property merchant_advice_code_description: str | None
Human readable description of the merchant advice code. Note: In case the merchant advice code is unknown (unmapped), the system returns Unknown.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.address_verification_data.AddressVerificationData[source]

Bases: DataObject

__annotations__ = {'_AddressVerificationData__cardholder_address': typing.Optional[str], '_AddressVerificationData__cardholder_postal_code': typing.Optional[str]}
property cardholder_address: str | None
Cardholder street address

Type: str

property cardholder_postal_code: str | None
Cardholder postal code

Type: str

from_dictionary(dictionary: dict) → AddressVerificationData[source]
to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.aes_ukpt_pin_encryption_data.AesUkptPinEncryptionData[source]

Bases: PinEncryptionData

PIN_ENCRYPTION_TYPE = 'AES_UKPT'
__annotations__ = {'_AesUkptPinEncryptionData__key_generation': typing.Optional[int], '_AesUkptPinEncryptionData__random_value': typing.Optional[str], '__key_generation': 'Optional[int]', '__random_value': 'Optional[str]'}
from_dictionary(dictionary: dict) → AesUkptPinEncryptionData[source]
property key_generation: int | None
Generation/Version of the master key that was agreed with the partner

Type: int

property pin_encryption_type: str
Possible values are: AES_UKPT, DUKPT, ZPK.

Type: str

property random_value: str | None
16-byte binary random value to derive the PIN encryption session key

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.amount_breakdown_data.AmountBreakdownData[source]

Bases: DataObject

__annotations__ = {'_AmountBreakdownData__cashback_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_AmountBreakdownData__tip_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData]}
property cashback_amount: AmountData | None
Optional amount of cashback for card-present transactions.

The amount specified is included in the total transaction amount, the information is provided for data enrichment and reconciliation purposes.

Only supported in some regions with restrictions, depending on local regulation and card scheme rules. Please check with your Worldline contact if you are allowed to use this field.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

from_dictionary(dictionary: dict) → AmountBreakdownData[source]
property tip_amount: AmountData | None
Optional amount of tip.

The amount specified is included in the total transaction amount, the information is provided for data enrichment and reconciliation purposes.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.amount_data.AmountData[source]

Bases: DataObject

__annotations__ = {'_AmountData__amount': typing.Optional[int], '_AmountData__currency_code': typing.Optional[str], '_AmountData__number_of_decimals': typing.Optional[int]}
property amount: int | None
Amount of transaction formatted according to card scheme specifications. E.g. 100 for 1.00 EUR.

Type: int

property currency_code: str | None
Alpha-numeric ISO 4217 currency code for transaction, e.g. EUR

Type: str

from_dictionary(dictionary: dict) → AmountData[source]
property number_of_decimals: int | None
Number of decimals in the amount

Type: int

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.api_account_verification_request.ApiAccountVerificationRequest[source]

Bases: DataObject

__annotations__ = {'_ApiAccountVerificationRequest__card_payment_data': typing.Optional[worldline.acquiring.sdk.v1.domain.card_payment_data_for_verification.CardPaymentDataForVerification], '_ApiAccountVerificationRequest__merchant': typing.Optional[worldline.acquiring.sdk.v1.domain.merchant_data.MerchantData], '_ApiAccountVerificationRequest__operation_id': typing.Optional[str], '_ApiAccountVerificationRequest__references': typing.Optional[worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences], '_ApiAccountVerificationRequest__terminal_data': typing.Optional[worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData], '_ApiAccountVerificationRequest__transaction_timestamp': typing.Optional[datetime.datetime]}
property card_payment_data: CardPaymentDataForVerification | None
Card data

Type: worldline.acquiring.sdk.v1.domain.card_payment_data_for_verification.CardPaymentDataForVerification

from_dictionary(dictionary: dict) → ApiAccountVerificationRequest[source]
property merchant: MerchantData | None
Merchant Data

Type: worldline.acquiring.sdk.v1.domain.merchant_data.MerchantData

property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property references: PaymentReferences | None
Payment References

Type: worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences

property terminal_data: TerminalData | None

Type: worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData

to_dictionary() → dict[source]
property transaction_timestamp: datetime | None
Timestamp of transaction in ISO 8601 format (YYYY-MM-DDThh:mm:ss+TZD)
It can be expressed in merchant time zone (ex: 2023-10-10T08:00+02:00) or in UTC (ex: 2023-10-10T08:00Z)

Type: datetime

class worldline.acquiring.sdk.v1.domain.api_account_verification_response.ApiAccountVerificationResponse[source]

Bases: DataObject

__annotations__ = {'_ApiAccountVerificationResponse__additional_response_data': typing.Optional[worldline.acquiring.sdk.v1.domain.additional_response_data.AdditionalResponseData], '_ApiAccountVerificationResponse__authorization_code': typing.Optional[str], '_ApiAccountVerificationResponse__card_payment_data': typing.Optional[worldline.acquiring.sdk.v1.domain.card_payment_data_for_response.CardPaymentDataForResponse], '_ApiAccountVerificationResponse__operation_id': typing.Optional[str], '_ApiAccountVerificationResponse__references': typing.Optional[worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses], '_ApiAccountVerificationResponse__responder': typing.Optional[str], '_ApiAccountVerificationResponse__response_code': typing.Optional[str], '_ApiAccountVerificationResponse__response_code_category': typing.Optional[str], '_ApiAccountVerificationResponse__response_code_description': typing.Optional[str]}
property additional_response_data: AdditionalResponseData | None
Additional response data

Type: worldline.acquiring.sdk.v1.domain.additional_response_data.AdditionalResponseData

property authorization_code: str | None
Authorization approval code

Type: str

property card_payment_data: CardPaymentDataForResponse | None

Type: worldline.acquiring.sdk.v1.domain.card_payment_data_for_response.CardPaymentDataForResponse

from_dictionary(dictionary: dict) → ApiAccountVerificationResponse[source]
property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property references: ApiReferencesForResponses | None
A set of references returned in responses

Type: worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses

property responder: str | None
The party that originated the response Possible values are:

  • WORLDLINE

  • ISSUER

  • SCHEME

  • PARTNER

Type: str

property response_code: str | None
Numeric response code, e.g. 0, 5

Type: str

property response_code_category: str | None
Category of response code.
Possible values are:

  • APPROVED

  • PARTIALLY_APPROVED

  • DECLINED

Type: str

property response_code_description: str | None
Description of the response code

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.api_action_response.ApiActionResponse[source]

Bases: DataObject

__annotations__ = {'_ApiActionResponse__additional_response_data': typing.Optional[worldline.acquiring.sdk.v1.domain.additional_response_data.AdditionalResponseData], '_ApiActionResponse__operation_id': typing.Optional[str], '_ApiActionResponse__payment': typing.Optional[worldline.acquiring.sdk.v1.domain.api_payment_summary_for_response.ApiPaymentSummaryForResponse], '_ApiActionResponse__responder': typing.Optional[str], '_ApiActionResponse__response_code': typing.Optional[str], '_ApiActionResponse__response_code_category': typing.Optional[str], '_ApiActionResponse__response_code_description': typing.Optional[str]}
property additional_response_data: AdditionalResponseData | None
Additional response data

Type: worldline.acquiring.sdk.v1.domain.additional_response_data.AdditionalResponseData

from_dictionary(dictionary: dict) → ApiActionResponse[source]
property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property payment: ApiPaymentSummaryForResponse | None
A summary of the payment used for responses

Type: worldline.acquiring.sdk.v1.domain.api_payment_summary_for_response.ApiPaymentSummaryForResponse

property responder: str | None
The party that originated the response Possible values are:

  • WORLDLINE

  • ISSUER

  • SCHEME

  • PARTNER

Type: str

property response_code: str | None
Numeric response code, e.g. 0, 5

Type: str

property response_code_category: str | None
Category of response code.
Possible values are:

  • APPROVED

  • PARTIALLY_APPROVED

  • DECLINED

Type: str

property response_code_description: str | None
Description of the response code

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.api_action_response_for_refund.ApiActionResponseForRefund[source]

Bases: DataObject

__annotations__ = {'_ApiActionResponseForRefund__additional_response_data': typing.Optional[worldline.acquiring.sdk.v1.domain.additional_response_data.AdditionalResponseData], '_ApiActionResponseForRefund__operation_id': typing.Optional[str], '_ApiActionResponseForRefund__refund': typing.Optional[worldline.acquiring.sdk.v1.domain.api_refund_summary_for_response.ApiRefundSummaryForResponse], '_ApiActionResponseForRefund__responder': typing.Optional[str], '_ApiActionResponseForRefund__response_code': typing.Optional[str], '_ApiActionResponseForRefund__response_code_category': typing.Optional[str], '_ApiActionResponseForRefund__response_code_description': typing.Optional[str]}
property additional_response_data: AdditionalResponseData | None
Additional response data

Type: worldline.acquiring.sdk.v1.domain.additional_response_data.AdditionalResponseData

from_dictionary(dictionary: dict) → ApiActionResponseForRefund[source]
property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property refund: ApiRefundSummaryForResponse | None
A summary of the refund used for responses

Type: worldline.acquiring.sdk.v1.domain.api_refund_summary_for_response.ApiRefundSummaryForResponse

property responder: str | None
The party that originated the response Possible values are:

  • WORLDLINE

  • ISSUER

  • SCHEME

  • PARTNER

Type: str

property response_code: str | None
Numeric response code, e.g. 0, 5

Type: str

property response_code_category: str | None
Category of response code.
Possible values are:

  • APPROVED

  • PARTIALLY_APPROVED

  • DECLINED

Type: str

property response_code_description: str | None
Description of the response code

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.api_balance_inquiry_request.ApiBalanceInquiryRequest[source]

Bases: DataObject

__annotations__ = {'_ApiBalanceInquiryRequest__card_payment_data': typing.Optional[worldline.acquiring.sdk.v1.domain.card_payment_data_for_balance_inquiry.CardPaymentDataForBalanceInquiry], '_ApiBalanceInquiryRequest__merchant': typing.Optional[worldline.acquiring.sdk.v1.domain.merchant_data.MerchantData], '_ApiBalanceInquiryRequest__operation_id': typing.Optional[str], '_ApiBalanceInquiryRequest__references': typing.Optional[worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences], '_ApiBalanceInquiryRequest__terminal_data': typing.Optional[worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData], '_ApiBalanceInquiryRequest__transaction_timestamp': typing.Optional[datetime.datetime]}
property card_payment_data: CardPaymentDataForBalanceInquiry | None
Card data

Type: worldline.acquiring.sdk.v1.domain.card_payment_data_for_balance_inquiry.CardPaymentDataForBalanceInquiry

from_dictionary(dictionary: dict) → ApiBalanceInquiryRequest[source]
property merchant: MerchantData | None
Merchant Data

Type: worldline.acquiring.sdk.v1.domain.merchant_data.MerchantData

property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property references: PaymentReferences | None
Payment References

Type: worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences

property terminal_data: TerminalData | None

Type: worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData

to_dictionary() → dict[source]
property transaction_timestamp: datetime | None
Timestamp of transaction in ISO 8601 format (YYYY-MM-DDThh:mm:ss+TZD)
It can be expressed in merchant time zone (ex: 2023-10-10T08:00+02:00) or in UTC (ex: 2023-10-10T08:00Z)

Type: datetime

class worldline.acquiring.sdk.v1.domain.api_balance_inquiry_response.ApiBalanceInquiryResponse[source]

Bases: DataObject

__annotations__ = {'_ApiBalanceInquiryResponse__additional_response_data': typing.Optional[worldline.acquiring.sdk.v1.domain.additional_response_data.AdditionalResponseData], '_ApiBalanceInquiryResponse__authorization_code': typing.Optional[str], '_ApiBalanceInquiryResponse__available_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_ApiBalanceInquiryResponse__card_payment_data': typing.Optional[worldline.acquiring.sdk.v1.domain.card_payment_data_for_response.CardPaymentDataForResponse], '_ApiBalanceInquiryResponse__operation_id': typing.Optional[str], '_ApiBalanceInquiryResponse__references': typing.Optional[worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses], '_ApiBalanceInquiryResponse__responder': typing.Optional[str], '_ApiBalanceInquiryResponse__response_code': typing.Optional[str], '_ApiBalanceInquiryResponse__response_code_category': typing.Optional[str], '_ApiBalanceInquiryResponse__response_code_description': typing.Optional[str]}
property additional_response_data: AdditionalResponseData | None
Additional response data

Type: worldline.acquiring.sdk.v1.domain.additional_response_data.AdditionalResponseData

property authorization_code: str | None
Authorization approval code

Type: str

property available_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

property card_payment_data: CardPaymentDataForResponse | None

Type: worldline.acquiring.sdk.v1.domain.card_payment_data_for_response.CardPaymentDataForResponse

from_dictionary(dictionary: dict) → ApiBalanceInquiryResponse[source]
property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property references: ApiReferencesForResponses | None
A set of references returned in responses

Type: worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses

property responder: str | None
The party that originated the response Possible values are:

  • WORLDLINE

  • ISSUER

  • SCHEME

  • PARTNER

Type: str

property response_code: str | None
Numeric response code, e.g. 0, 5

Type: str

property response_code_category: str | None
Category of response code.
Possible values are:

  • APPROVED

  • PARTIALLY_APPROVED

  • DECLINED

Type: str

property response_code_description: str | None
Description of the response code

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.api_capture_request.ApiCaptureRequest[source]

Bases: DataObject

__annotations__ = {'_ApiCaptureRequest__amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_ApiCaptureRequest__capture_amount_breakdown_data': typing.Optional[worldline.acquiring.sdk.v1.domain.capture_amount_breakdown_data.CaptureAmountBreakdownData], '_ApiCaptureRequest__capture_point_of_sale_data': typing.Optional[worldline.acquiring.sdk.v1.domain.capture_point_of_sale_data.CapturePointOfSaleData], '_ApiCaptureRequest__capture_sequence_number': typing.Optional[int], '_ApiCaptureRequest__dynamic_currency_conversion': typing.Optional[worldline.acquiring.sdk.v1.domain.dcc_data.DccData], '_ApiCaptureRequest__is_final': typing.Optional[bool], '_ApiCaptureRequest__marketplace_data': typing.Optional[worldline.acquiring.sdk.v1.domain.marketplace_data.MarketplaceData], '_ApiCaptureRequest__operation_id': typing.Optional[str], '_ApiCaptureRequest__references': typing.Optional[worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences], '_ApiCaptureRequest__terminal_data': typing.Optional[worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData], '_ApiCaptureRequest__transaction_timestamp': typing.Optional[datetime.datetime]}
property amount: AmountData | None
Amount to capture. If not provided, the full amount will be captured.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

property capture_amount_breakdown_data: CaptureAmountBreakdownData | None
Additional data regarding the breakdown of the capture amount. This can include amounts such as tip. The amounts specified are included in the total capture amount, the information is provided for data enrichment and reconciliation purposes.

Type: worldline.acquiring.sdk.v1.domain.capture_amount_breakdown_data.CaptureAmountBreakdownData

property capture_point_of_sale_data: CapturePointOfSaleData | None

Type: worldline.acquiring.sdk.v1.domain.capture_point_of_sale_data.CapturePointOfSaleData

property capture_sequence_number: int | None
The index of the partial capture. Not needed for full capture.

Type: int

property dynamic_currency_conversion: DccData | None
Dynamic Currency Conversion (DCC) rate data from DCC lookup response.
Mandatory for DCC transactions.

Type: worldline.acquiring.sdk.v1.domain.dcc_data.DccData

from_dictionary(dictionary: dict) → ApiCaptureRequest[source]
property is_final: bool | None
Indicates whether this partial capture is the final one. When set to true, the part of the authorization that was not captured is released. Not needed for a full capture.

Note: the default value of false is not intuitive. Please send always a value and don’t rely on the default, it might change with the next major API version

Type: bool

property marketplace_data: MarketplaceData | None
Additional data for marketplace transactions. Required when capturing VISA payments on behalf of sellers that are located in a different region than the marketplace. We advise marketplaces to always provide this data to ensure optimal processing of the transactions.

Type: worldline.acquiring.sdk.v1.domain.marketplace_data.MarketplaceData

property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property references: PaymentReferences | None
Payment References

Type: worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences

property terminal_data: TerminalData | None

Type: worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData

to_dictionary() → dict[source]
property transaction_timestamp: datetime | None
Timestamp of transaction in ISO 8601 format (YYYY-MM-DDThh:mm:ss+TZD)
It can be expressed in merchant time zone (ex: 2023-10-10T08:00+02:00) or in UTC (ex: 2023-10-10T08:00Z)

Type: datetime

class worldline.acquiring.sdk.v1.domain.api_capture_request_for_refund.ApiCaptureRequestForRefund[source]

Bases: DataObject

__annotations__ = {'_ApiCaptureRequestForRefund__capture_point_of_sale_data': typing.Optional[worldline.acquiring.sdk.v1.domain.capture_point_of_sale_data.CapturePointOfSaleData], '_ApiCaptureRequestForRefund__operation_id': typing.Optional[str], '_ApiCaptureRequestForRefund__references': typing.Optional[worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences], '_ApiCaptureRequestForRefund__terminal_data': typing.Optional[worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData], '_ApiCaptureRequestForRefund__transaction_timestamp': typing.Optional[datetime.datetime]}
property capture_point_of_sale_data: CapturePointOfSaleData | None

Type: worldline.acquiring.sdk.v1.domain.capture_point_of_sale_data.CapturePointOfSaleData

from_dictionary(dictionary: dict) → ApiCaptureRequestForRefund[source]
property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property references: PaymentReferences | None
Payment References

Type: worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences

property terminal_data: TerminalData | None

Type: worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData

to_dictionary() → dict[source]
property transaction_timestamp: datetime | None
Timestamp of transaction in ISO 8601 format (YYYY-MM-DDThh:mm:ss+TZD)
It can be expressed in merchant time zone (ex: 2023-10-10T08:00+02:00) or in UTC (ex: 2023-10-10T08:00Z)

Type: datetime

class worldline.acquiring.sdk.v1.domain.api_increment_request.ApiIncrementRequest[source]

Bases: DataObject

__annotations__ = {'_ApiIncrementRequest__dynamic_currency_conversion': typing.Optional[worldline.acquiring.sdk.v1.domain.dcc_data.DccData], '_ApiIncrementRequest__increment_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_ApiIncrementRequest__operation_id': typing.Optional[str], '_ApiIncrementRequest__terminal_data': typing.Optional[worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData], '_ApiIncrementRequest__transaction_timestamp': typing.Optional[datetime.datetime]}
property dynamic_currency_conversion: DccData | None
Dynamic Currency Conversion (DCC) rate data from DCC lookup response.
Mandatory for DCC transactions.

Type: worldline.acquiring.sdk.v1.domain.dcc_data.DccData

from_dictionary(dictionary: dict) → ApiIncrementRequest[source]
property increment_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property terminal_data: TerminalData | None

Type: worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData

to_dictionary() → dict[source]
property transaction_timestamp: datetime | None
Timestamp of transaction in ISO 8601 format (YYYY-MM-DDThh:mm:ss+TZD)
It can be expressed in merchant time zone (ex: 2023-10-10T08:00+02:00) or in UTC (ex: 2023-10-10T08:00Z)

Type: datetime

class worldline.acquiring.sdk.v1.domain.api_increment_response.ApiIncrementResponse[source]

Bases: ApiActionResponse

__annotations__ = {'_ApiIncrementResponse__authorization_code': typing.Optional[str], '_ApiIncrementResponse__total_authorized_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData]}
property authorization_code: str | None
Authorization approval code

Type: str

from_dictionary(dictionary: dict) → ApiIncrementResponse[source]
to_dictionary() → dict[source]
property total_authorized_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

class worldline.acquiring.sdk.v1.domain.api_payment_error_response.ApiPaymentErrorResponse[source]

Bases: DataObject

__annotations__ = {'_ApiPaymentErrorResponse__detail': typing.Optional[str], '_ApiPaymentErrorResponse__instance': typing.Optional[str], '_ApiPaymentErrorResponse__request_id': typing.Optional[str], '_ApiPaymentErrorResponse__status': typing.Optional[int], '_ApiPaymentErrorResponse__title': typing.Optional[str], '_ApiPaymentErrorResponse__type': typing.Optional[str]}
property detail: str | None
Any relevant details about the error.
May include suggestions for handling it. Can be an empty string if no extra details are available.

Type: str

from_dictionary(dictionary: dict) → ApiPaymentErrorResponse[source]
property instance: str | None
A URI reference that identifies the specific occurrence of the error.
It may or may not yield further information if dereferenced.

Type: str

property request_id: str | None
The unique Worldline identifier for the request that resulted in this response.

Type: str

property status: int | None
The HTTP status code of this error response.
Included to aid those frameworks that have a hard time working with anything other than the body of an HTTP response.

Type: int

property title: str | None
The human-readable version of the error.

Type: str

to_dictionary() → dict[source]
property type: str | None
The type of the error.
This is what you should match against when implementing error handling.
It is in the form of a URL that identifies the error type.

Type: str

class worldline.acquiring.sdk.v1.domain.api_payment_refund_request.ApiPaymentRefundRequest[source]

Bases: DataObject

__annotations__ = {'_ApiPaymentRefundRequest__amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_ApiPaymentRefundRequest__capture_immediately': typing.Optional[bool], '_ApiPaymentRefundRequest__dynamic_currency_conversion': typing.Optional[worldline.acquiring.sdk.v1.domain.dcc_data.DccData], '_ApiPaymentRefundRequest__operation_id': typing.Optional[str], '_ApiPaymentRefundRequest__references': typing.Optional[worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences], '_ApiPaymentRefundRequest__terminal_data': typing.Optional[worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData], '_ApiPaymentRefundRequest__transaction_timestamp': typing.Optional[datetime.datetime]}
property amount: AmountData | None
Amount to refund. If not provided, the full amount will be refunded.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

property capture_immediately: bool | None
If true the transaction will be authorized and captured immediately

Type: bool

property dynamic_currency_conversion: DccData | None
Dynamic Currency Conversion (DCC) rate data from DCC lookup response.
Mandatory for DCC transactions.

Type: worldline.acquiring.sdk.v1.domain.dcc_data.DccData

from_dictionary(dictionary: dict) → ApiPaymentRefundRequest[source]
property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property references: PaymentReferences | None
Payment References

Type: worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences

property terminal_data: TerminalData | None

Type: worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData

to_dictionary() → dict[source]
property transaction_timestamp: datetime | None
Timestamp of transaction in ISO 8601 format (YYYY-MM-DDThh:mm:ss+TZD)
It can be expressed in merchant time zone (ex: 2023-10-10T08:00+02:00) or in UTC (ex: 2023-10-10T08:00Z)

Type: datetime

class worldline.acquiring.sdk.v1.domain.api_payment_request.ApiPaymentRequest[source]

Bases: DataObject

__annotations__ = {'_ApiPaymentRequest__amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_ApiPaymentRequest__amount_breakdown_data': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_breakdown_data.AmountBreakdownData], '_ApiPaymentRequest__authorization_type': typing.Optional[str], '_ApiPaymentRequest__card_payment_data': typing.Optional[worldline.acquiring.sdk.v1.domain.card_payment_data.CardPaymentData], '_ApiPaymentRequest__dynamic_currency_conversion': typing.Optional[worldline.acquiring.sdk.v1.domain.dcc_data.DccData], '_ApiPaymentRequest__merchant': typing.Optional[worldline.acquiring.sdk.v1.domain.merchant_data.MerchantData], '_ApiPaymentRequest__operation_id': typing.Optional[str], '_ApiPaymentRequest__references': typing.Optional[worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences], '_ApiPaymentRequest__terminal_data': typing.Optional[worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData], '_ApiPaymentRequest__transaction_timestamp': typing.Optional[datetime.datetime]}
property amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

property amount_breakdown_data: AmountBreakdownData | None
Additional data regarding the breakdown of the transaction amount. This can include amounts such as tip or cashback. The amounts specified are included in the total transaction amount, the information is provided for data enrichment and reconciliation purposes.

Type: worldline.acquiring.sdk.v1.domain.amount_breakdown_data.AmountBreakdownData

property authorization_type: str | None
The type of authorization

Type: str

property card_payment_data: CardPaymentData | None
Card data

Type: worldline.acquiring.sdk.v1.domain.card_payment_data.CardPaymentData

property dynamic_currency_conversion: DccData | None
Dynamic Currency Conversion (DCC) rate data from DCC lookup response.
Mandatory for DCC transactions.

Type: worldline.acquiring.sdk.v1.domain.dcc_data.DccData

from_dictionary(dictionary: dict) → ApiPaymentRequest[source]
property merchant: MerchantData | None
Merchant Data

Type: worldline.acquiring.sdk.v1.domain.merchant_data.MerchantData

property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property references: PaymentReferences | None
Payment References

Type: worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences

property terminal_data: TerminalData | None

Type: worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData

to_dictionary() → dict[source]
property transaction_timestamp: datetime | None
Timestamp of transaction in ISO 8601 format (YYYY-MM-DDThh:mm:ss+TZD)
It can be expressed in merchant time zone (ex: 2023-10-10T08:00+02:00) or in UTC (ex: 2023-10-10T08:00Z)

Type: datetime

class worldline.acquiring.sdk.v1.domain.api_payment_resource.ApiPaymentResource[source]

Bases: DataObject

__annotations__ = {'_ApiPaymentResource__card_payment_data': typing.Optional[worldline.acquiring.sdk.v1.domain.card_payment_data_for_resource.CardPaymentDataForResource], '_ApiPaymentResource__initial_authorization_code': typing.Optional[str], '_ApiPaymentResource__operations': typing.Optional[typing.List[worldline.acquiring.sdk.v1.domain.sub_operation.SubOperation]], '_ApiPaymentResource__payment_id': typing.Optional[str], '_ApiPaymentResource__references': typing.Optional[worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses], '_ApiPaymentResource__status': typing.Optional[str], '_ApiPaymentResource__status_timestamp': typing.Optional[datetime.datetime], '_ApiPaymentResource__total_authorized_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData]}
property card_payment_data: CardPaymentDataForResource | None

Type: worldline.acquiring.sdk.v1.domain.card_payment_data_for_resource.CardPaymentDataForResource

from_dictionary(dictionary: dict) → ApiPaymentResource[source]
property initial_authorization_code: str | None
Authorization approval code

Type: str

property operations: List[SubOperation] | None

Type: list[worldline.acquiring.sdk.v1.domain.sub_operation.SubOperation]

property payment_id: str | None
The unique identifier of the payment, generated by Worldline. Use it to retrieve the payment and in all follow-up operations such as authorize, capture, reverse and refund.

Type: str

property references: ApiReferencesForResponses | None
A set of references returned in responses

Type: worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses

property status: str | None
The status of the payment, refund or credit transfer
Possible values are:

  • AUTHORIZED

  • NOT_AUTHORIZED

  • PENDING

  • PENDING_CAPTURE

  • CONFIRMED

  • REVERSED

  • CANCELLED

Type: str

property status_timestamp: datetime | None
Timestamp of the status in format yyyy-MM-ddTHH:mm:ssZ

Type: datetime

to_dictionary() → dict[source]
property total_authorized_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

class worldline.acquiring.sdk.v1.domain.api_payment_response.ApiPaymentResponse[source]

Bases: DataObject

__annotations__ = {'_ApiPaymentResponse__additional_response_data': typing.Optional[worldline.acquiring.sdk.v1.domain.additional_response_data.AdditionalResponseData], '_ApiPaymentResponse__card_payment_data': typing.Optional[worldline.acquiring.sdk.v1.domain.card_payment_data_for_response.CardPaymentDataForResponse], '_ApiPaymentResponse__initial_authorization_code': typing.Optional[str], '_ApiPaymentResponse__operation_id': typing.Optional[str], '_ApiPaymentResponse__payment_id': typing.Optional[str], '_ApiPaymentResponse__references': typing.Optional[worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses], '_ApiPaymentResponse__responder': typing.Optional[str], '_ApiPaymentResponse__response_code': typing.Optional[str], '_ApiPaymentResponse__response_code_category': typing.Optional[str], '_ApiPaymentResponse__response_code_description': typing.Optional[str], '_ApiPaymentResponse__status': typing.Optional[str], '_ApiPaymentResponse__status_timestamp': typing.Optional[datetime.datetime], '_ApiPaymentResponse__total_authorized_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData]}
property additional_response_data: AdditionalResponseData | None
Additional response data

Type: worldline.acquiring.sdk.v1.domain.additional_response_data.AdditionalResponseData

property card_payment_data: CardPaymentDataForResponse | None

Type: worldline.acquiring.sdk.v1.domain.card_payment_data_for_response.CardPaymentDataForResponse

from_dictionary(dictionary: dict) → ApiPaymentResponse[source]
property initial_authorization_code: str | None
Authorization approval code

Type: str

property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property payment_id: str | None
The unique identifier of the payment, generated by Worldline. Use it to retrieve the payment and in all follow-up operations such as authorize, capture, reverse and refund.

Type: str

property references: ApiReferencesForResponses | None
A set of references returned in responses

Type: worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses

property responder: str | None
The party that originated the response Possible values are:

  • WORLDLINE

  • ISSUER

  • SCHEME

  • PARTNER

Type: str

property response_code: str | None
Numeric response code, e.g. 0, 5

Type: str

property response_code_category: str | None
Category of response code.
Possible values are:

  • APPROVED

  • PARTIALLY_APPROVED

  • DECLINED

Type: str

property response_code_description: str | None
Description of the response code

Type: str

property status: str | None
The status of the payment, refund or credit transfer
Possible values are:

  • AUTHORIZED

  • NOT_AUTHORIZED

  • PENDING

  • PENDING_CAPTURE

  • CONFIRMED

  • REVERSED

  • CANCELLED

Type: str

property status_timestamp: datetime | None
Timestamp of the status in format yyyy-MM-ddTHH:mm:ssZ

Type: datetime

to_dictionary() → dict[source]
property total_authorized_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

class worldline.acquiring.sdk.v1.domain.api_payment_reversal_request.ApiPaymentReversalRequest[source]

Bases: DataObject

__annotations__ = {'_ApiPaymentReversalRequest__dynamic_currency_conversion': typing.Optional[worldline.acquiring.sdk.v1.domain.dcc_data.DccData], '_ApiPaymentReversalRequest__operation_id': typing.Optional[str], '_ApiPaymentReversalRequest__reversal_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_ApiPaymentReversalRequest__terminal_data': typing.Optional[worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData], '_ApiPaymentReversalRequest__transaction_timestamp': typing.Optional[datetime.datetime]}
property dynamic_currency_conversion: DccData | None
Dynamic Currency Conversion (DCC) rate data from DCC lookup response.
Mandatory for DCC transactions.

Type: worldline.acquiring.sdk.v1.domain.dcc_data.DccData

from_dictionary(dictionary: dict) → ApiPaymentReversalRequest[source]
property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property reversal_amount: AmountData | None
Amount to reverse. If not provided, the full amount will be reversed.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

property terminal_data: TerminalData | None

Type: worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData

to_dictionary() → dict[source]
property transaction_timestamp: datetime | None
Timestamp of transaction in ISO 8601 format (YYYY-MM-DDThh:mm:ss+TZD)
It can be expressed in merchant time zone (ex: 2023-10-10T08:00+02:00) or in UTC (ex: 2023-10-10T08:00Z)

Type: datetime

class worldline.acquiring.sdk.v1.domain.api_payment_summary_for_response.ApiPaymentSummaryForResponse[source]

Bases: DataObject

__annotations__ = {'_ApiPaymentSummaryForResponse__payment_id': typing.Optional[str], '_ApiPaymentSummaryForResponse__references': typing.Optional[worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses], '_ApiPaymentSummaryForResponse__status': typing.Optional[str], '_ApiPaymentSummaryForResponse__status_timestamp': typing.Optional[datetime.datetime]}
from_dictionary(dictionary: dict) → ApiPaymentSummaryForResponse[source]
property payment_id: str | None
The unique identifier of the payment, generated by Worldline. Use it to retrieve the payment and in all follow-up operations such as authorize, capture, reverse and refund.

Type: str

property references: ApiReferencesForResponses | None
A set of references returned in responses

Type: worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses

property status: str | None
The status of the payment, refund or credit transfer
Possible values are:

  • AUTHORIZED

  • NOT_AUTHORIZED

  • PENDING

  • PENDING_CAPTURE

  • CONFIRMED

  • REVERSED

  • CANCELLED

Type: str

property status_timestamp: datetime | None
Timestamp of the status in format yyyy-MM-ddTHH:mm:ssZ

Type: datetime

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses[source]

Bases: DataObject

__annotations__ = {'_ApiReferencesForResponses__payment_account_reference': typing.Optional[str], '_ApiReferencesForResponses__retrieval_reference_number': typing.Optional[str], '_ApiReferencesForResponses__scheme_transaction_id': typing.Optional[str], '_ApiReferencesForResponses__scheme_transaction_link_id': typing.Optional[str]}
from_dictionary(dictionary: dict) → ApiReferencesForResponses[source]
property payment_account_reference: str | None
(PAR) Unique identifier associated with a specific cardholder PAN

Type: str

property retrieval_reference_number: str | None
Retrieval reference number (RRN) for transaction

Type: str

property scheme_transaction_id: str | None
ID assigned by the scheme to identify a transaction through its whole lifecycle.

Type: str

A unique transaction identifier generated by Mastercard to provide consistent linking of related transaction activity throughout the transaction lifecycle.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.api_refund_request.ApiRefundRequest[source]

Bases: DataObject

__annotations__ = {'_ApiRefundRequest__amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_ApiRefundRequest__card_payment_data': typing.Optional[worldline.acquiring.sdk.v1.domain.card_payment_data_for_refund.CardPaymentDataForRefund], '_ApiRefundRequest__dynamic_currency_conversion': typing.Optional[worldline.acquiring.sdk.v1.domain.dcc_data.DccData], '_ApiRefundRequest__merchant': typing.Optional[worldline.acquiring.sdk.v1.domain.merchant_data.MerchantData], '_ApiRefundRequest__operation_id': typing.Optional[str], '_ApiRefundRequest__references': typing.Optional[worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences], '_ApiRefundRequest__terminal_data': typing.Optional[worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData], '_ApiRefundRequest__transaction_timestamp': typing.Optional[datetime.datetime]}
property amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

property card_payment_data: CardPaymentDataForRefund | None
Card data for refund

Type: worldline.acquiring.sdk.v1.domain.card_payment_data_for_refund.CardPaymentDataForRefund

property dynamic_currency_conversion: DccData | None
Dynamic Currency Conversion (DCC) rate data from DCC lookup response.
Mandatory for DCC transactions.

Type: worldline.acquiring.sdk.v1.domain.dcc_data.DccData

from_dictionary(dictionary: dict) → ApiRefundRequest[source]
property merchant: MerchantData | None
Merchant Data

Type: worldline.acquiring.sdk.v1.domain.merchant_data.MerchantData

property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property references: PaymentReferences | None
Payment References

Type: worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences

property terminal_data: TerminalData | None

Type: worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData

to_dictionary() → dict[source]
property transaction_timestamp: datetime | None
Timestamp of transaction in ISO 8601 format (YYYY-MM-DDThh:mm:ss+TZD)
It can be expressed in merchant time zone (ex: 2023-10-10T08:00+02:00) or in UTC (ex: 2023-10-10T08:00Z)

Type: datetime

class worldline.acquiring.sdk.v1.domain.api_refund_resource.ApiRefundResource[source]

Bases: DataObject

__annotations__ = {'_ApiRefundResource__card_payment_data': typing.Optional[worldline.acquiring.sdk.v1.domain.card_payment_data_for_resource.CardPaymentDataForResource], '_ApiRefundResource__initial_authorization_code': typing.Optional[str], '_ApiRefundResource__operations': typing.Optional[typing.List[worldline.acquiring.sdk.v1.domain.sub_operation_for_refund.SubOperationForRefund]], '_ApiRefundResource__referenced_payment_id': typing.Optional[str], '_ApiRefundResource__references': typing.Optional[worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses], '_ApiRefundResource__refund_id': typing.Optional[str], '_ApiRefundResource__status': typing.Optional[str], '_ApiRefundResource__status_timestamp': typing.Optional[datetime.datetime], '_ApiRefundResource__total_authorized_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData]}
property card_payment_data: CardPaymentDataForResource | None

Type: worldline.acquiring.sdk.v1.domain.card_payment_data_for_resource.CardPaymentDataForResource

from_dictionary(dictionary: dict) → ApiRefundResource[source]
property initial_authorization_code: str | None
Authorization approval code

Type: str

property operations: List[SubOperationForRefund] | None

Type: list[worldline.acquiring.sdk.v1.domain.sub_operation_for_refund.SubOperationForRefund]

property referenced_payment_id: str | None
The identifier of the payment referenced by this refund.

Type: str

property references: ApiReferencesForResponses | None
A set of references returned in responses

Type: worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses

property refund_id: str | None
The unique identifier of the refund, generated by Worldline. It is returned both for a standalone refund and for a refund created on a payment. Use it to retrieve the refund and in all follow-up operations such as capture and reverse.

Type: str

property status: str | None
The status of the payment, refund or credit transfer
Possible values are:

  • AUTHORIZED

  • NOT_AUTHORIZED

  • PENDING

  • PENDING_CAPTURE

  • CONFIRMED

  • REVERSED

  • CANCELLED

Type: str

property status_timestamp: datetime | None
Timestamp of the status in format yyyy-MM-ddTHH:mm:ssZ

Type: datetime

to_dictionary() → dict[source]
property total_authorized_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

class worldline.acquiring.sdk.v1.domain.api_refund_response.ApiRefundResponse[source]

Bases: DataObject

__annotations__ = {'_ApiRefundResponse__additional_response_data': typing.Optional[worldline.acquiring.sdk.v1.domain.additional_response_data.AdditionalResponseData], '_ApiRefundResponse__authorization_code': typing.Optional[str], '_ApiRefundResponse__card_payment_data': typing.Optional[worldline.acquiring.sdk.v1.domain.card_payment_data_for_response.CardPaymentDataForResponse], '_ApiRefundResponse__emv_data': typing.Optional[typing.List[worldline.acquiring.sdk.v1.domain.emv_data_item.EmvDataItem]], '_ApiRefundResponse__operation_id': typing.Optional[str], '_ApiRefundResponse__referenced_payment_id': typing.Optional[str], '_ApiRefundResponse__references': typing.Optional[worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses], '_ApiRefundResponse__refund_id': typing.Optional[str], '_ApiRefundResponse__responder': typing.Optional[str], '_ApiRefundResponse__response_code': typing.Optional[str], '_ApiRefundResponse__response_code_category': typing.Optional[str], '_ApiRefundResponse__response_code_description': typing.Optional[str], '_ApiRefundResponse__status': typing.Optional[str], '_ApiRefundResponse__status_timestamp': typing.Optional[datetime.datetime], '_ApiRefundResponse__total_authorized_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData]}
property additional_response_data: AdditionalResponseData | None
Additional response data

Type: worldline.acquiring.sdk.v1.domain.additional_response_data.AdditionalResponseData

property authorization_code: str | None
Authorization approval code

Type: str

property card_payment_data: CardPaymentDataForResponse | None

Type: worldline.acquiring.sdk.v1.domain.card_payment_data_for_response.CardPaymentDataForResponse

property emv_data: List[EmvDataItem] | None
EMV data of the card as tag/value pairs. It is needed when cardEntryMode is CHIP or CONTACTLESS.

Type: list[worldline.acquiring.sdk.v1.domain.emv_data_item.EmvDataItem]

from_dictionary(dictionary: dict) → ApiRefundResponse[source]
property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property referenced_payment_id: str | None
The identifier of the payment referenced by this refund.

Type: str

property references: ApiReferencesForResponses | None
A set of references returned in responses

Type: worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses

property refund_id: str | None
The unique identifier of the refund, generated by Worldline. It is returned both for a standalone refund and for a refund created on a payment. Use it to retrieve the refund and in all follow-up operations such as capture and reverse.

Type: str

property responder: str | None
The party that originated the response Possible values are:

  • WORLDLINE

  • ISSUER

  • SCHEME

  • PARTNER

Type: str

property response_code: str | None
Numeric response code, e.g. 0, 5

Type: str

property response_code_category: str | None
Category of response code.
Possible values are:

  • APPROVED

  • PARTIALLY_APPROVED

  • DECLINED

Type: str

property response_code_description: str | None
Description of the response code

Type: str

property status: str | None
The status of the payment, refund or credit transfer
Possible values are:

  • AUTHORIZED

  • NOT_AUTHORIZED

  • PENDING

  • PENDING_CAPTURE

  • CONFIRMED

  • REVERSED

  • CANCELLED

Type: str

property status_timestamp: datetime | None
Timestamp of the status in format yyyy-MM-ddTHH:mm:ssZ

Type: datetime

to_dictionary() → dict[source]
property total_authorized_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

class worldline.acquiring.sdk.v1.domain.api_refund_reversal_request.ApiRefundReversalRequest[source]

Bases: DataObject

__annotations__ = {'_ApiRefundReversalRequest__operation_id': typing.Optional[str], '_ApiRefundReversalRequest__terminal_data': typing.Optional[worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData], '_ApiRefundReversalRequest__transaction_timestamp': typing.Optional[datetime.datetime]}
from_dictionary(dictionary: dict) → ApiRefundReversalRequest[source]
property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property terminal_data: TerminalData | None

Type: worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData

to_dictionary() → dict[source]
property transaction_timestamp: datetime | None
Timestamp of transaction in ISO 8601 format (YYYY-MM-DDThh:mm:ss+TZD)
It can be expressed in merchant time zone (ex: 2023-10-10T08:00+02:00) or in UTC (ex: 2023-10-10T08:00Z)

Type: datetime

class worldline.acquiring.sdk.v1.domain.api_refund_summary_for_response.ApiRefundSummaryForResponse[source]

Bases: DataObject

__annotations__ = {'_ApiRefundSummaryForResponse__references': typing.Optional[worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses], '_ApiRefundSummaryForResponse__refund_id': typing.Optional[str], '_ApiRefundSummaryForResponse__status': typing.Optional[str], '_ApiRefundSummaryForResponse__status_timestamp': typing.Optional[datetime.datetime]}
from_dictionary(dictionary: dict) → ApiRefundSummaryForResponse[source]
property references: ApiReferencesForResponses | None
A set of references returned in responses

Type: worldline.acquiring.sdk.v1.domain.api_references_for_responses.ApiReferencesForResponses

property refund_id: str | None
The unique identifier of the refund, generated by Worldline. It is returned both for a standalone refund and for a refund created on a payment. Use it to retrieve the refund and in all follow-up operations such as capture and reverse.

Type: str

property status: str | None
The status of the payment, refund or credit transfer
Possible values are:

  • AUTHORIZED

  • NOT_AUTHORIZED

  • PENDING

  • PENDING_CAPTURE

  • CONFIRMED

  • REVERSED

  • CANCELLED

Type: str

property status_timestamp: datetime | None
Timestamp of the status in format yyyy-MM-ddTHH:mm:ssZ

Type: datetime

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.api_reversal_response.ApiReversalResponse[source]

Bases: ApiActionResponse

__annotations__ = {'_ApiReversalResponse__total_authorized_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData]}
from_dictionary(dictionary: dict) → ApiReversalResponse[source]
to_dictionary() → dict[source]
property total_authorized_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

class worldline.acquiring.sdk.v1.domain.api_technical_reversal_request.ApiTechnicalReversalRequest[source]

Bases: DataObject

__annotations__ = {'_ApiTechnicalReversalRequest__operation_id': typing.Optional[str], '_ApiTechnicalReversalRequest__reason': typing.Optional[str], '_ApiTechnicalReversalRequest__terminal_data': typing.Optional[worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData], '_ApiTechnicalReversalRequest__transaction_timestamp': typing.Optional[datetime.datetime]}
from_dictionary(dictionary: dict) → ApiTechnicalReversalRequest[source]
property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property reason: str | None
Reason for reversal

Type: str

property terminal_data: TerminalData | None

Type: worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData

to_dictionary() → dict[source]
property transaction_timestamp: datetime | None
Timestamp of transaction in ISO 8601 format (YYYY-MM-DDThh:mm:ss+TZD)
It can be expressed in merchant time zone (ex: 2023-10-10T08:00+02:00) or in UTC (ex: 2023-10-10T08:00Z)

Type: datetime

class worldline.acquiring.sdk.v1.domain.api_technical_reversal_response.ApiTechnicalReversalResponse[source]

Bases: DataObject

__annotations__ = {'_ApiTechnicalReversalResponse__operation_id': typing.Optional[str], '_ApiTechnicalReversalResponse__responder': typing.Optional[str], '_ApiTechnicalReversalResponse__response_code': typing.Optional[str], '_ApiTechnicalReversalResponse__response_code_category': typing.Optional[str], '_ApiTechnicalReversalResponse__response_code_description': typing.Optional[str]}
from_dictionary(dictionary: dict) → ApiTechnicalReversalResponse[source]
property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property responder: str | None
The party that originated the response Possible values are:

  • WORLDLINE

  • ISSUER

  • SCHEME

  • PARTNER

Type: str

property response_code: str | None
Numeric response code, e.g. 0, 5

Type: str

property response_code_category: str | None
Category of response code.
Possible values are:

  • APPROVED

  • PARTIALLY_APPROVED

  • DECLINED

Type: str

property response_code_description: str | None
Description of the response code

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.by_acquirer_ids.ByAcquirerIds[source]

Bases: MerchantScope

MERCHANT_SCOPE_TYPE = 'BY_ACQUIRER_IDS'
__annotations__ = {'_ByAcquirerIds__acquirer_ids': typing.Optional[typing.List[str]], '__acquirer_ids': 'Optional[List[str]]'}
property acquirer_ids: List[str] | None

Type: list[str]

from_dictionary(dictionary: dict) → ByAcquirerIds[source]
property merchant_scope_type: str
Possible values are: BY_ACQUIRER_IDS, BY_MERCHANT_ROOT_IDS, BY_MERCHANT_IDS.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.by_merchant_ids.ByMerchantIds[source]

Bases: MerchantScope

MERCHANT_SCOPE_TYPE = 'BY_MERCHANT_IDS'
__annotations__ = {'_ByMerchantIds__merchant_ids': typing.Optional[typing.List[worldline.acquiring.sdk.v1.domain.merchant_id_item.MerchantIdItem]], '__merchant_ids': 'Optional[List[MerchantIdItem]]'}
from_dictionary(dictionary: dict) → ByMerchantIds[source]
property merchant_ids: List[MerchantIdItem] | None

Type: list[worldline.acquiring.sdk.v1.domain.merchant_id_item.MerchantIdItem]

property merchant_scope_type: str
Possible values are: BY_ACQUIRER_IDS, BY_MERCHANT_ROOT_IDS, BY_MERCHANT_IDS.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.by_merchant_root_ids.ByMerchantRootIds[source]

Bases: MerchantScope

MERCHANT_SCOPE_TYPE = 'BY_MERCHANT_ROOT_IDS'
__annotations__ = {'_ByMerchantRootIds__merchant_root_ids': typing.Optional[typing.List[worldline.acquiring.sdk.v1.domain.merchant_root_id_item.MerchantRootIdItem]], '__merchant_root_ids': 'Optional[List[MerchantRootIdItem]]'}
from_dictionary(dictionary: dict) → ByMerchantRootIds[source]
property merchant_root_ids: List[MerchantRootIdItem] | None

Type: list[worldline.acquiring.sdk.v1.domain.merchant_root_id_item.MerchantRootIdItem]

property merchant_scope_type: str
Possible values are: BY_ACQUIRER_IDS, BY_MERCHANT_ROOT_IDS, BY_MERCHANT_IDS.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.capture_amount_breakdown_data.CaptureAmountBreakdownData[source]

Bases: DataObject

__annotations__ = {'_CaptureAmountBreakdownData__tip_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData]}
from_dictionary(dictionary: dict) → CaptureAmountBreakdownData[source]
property tip_amount: AmountData | None
Optional amount of tip.

The amount specified is included in the total capture amount, the information is provided for data enrichment and reconciliation purposes.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.capture_point_of_sale_data.CapturePointOfSaleData[source]

Bases: DataObject

__annotations__ = {'_CapturePointOfSaleData__emv_data': typing.Optional[typing.List[worldline.acquiring.sdk.v1.domain.emv_data_item.EmvDataItem]]}
property emv_data: List[EmvDataItem] | None
EMV data of the card as tag/value pairs.

Type: list[worldline.acquiring.sdk.v1.domain.emv_data_item.EmvDataItem]

from_dictionary(dictionary: dict) → CapturePointOfSaleData[source]
to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.card_data_for_dcc.CardDataForDcc[source]

Bases: DataObject

__annotations__ = {'_CardDataForDcc__bin': typing.Optional[str], '_CardDataForDcc__brand': typing.Optional[str], '_CardDataForDcc__card_country_code': typing.Optional[str], '_CardDataForDcc__card_entry_mode': typing.Optional[str]}
property bin: str | None
Used to determine the currency of the card. The first 12 digits of the card number. The BIN number is on the first 6 or 8 digits. Some issuers are using subranges for different countries on digits 9-12.

Type: str

property brand: str | None
The card brand

Type: str

property card_country_code: str | None
The ISO 3166 country code of the card

Type: str

property card_entry_mode: str | None
Card entry mode used in the transaction

Type: str

from_dictionary(dictionary: dict) → CardDataForDcc[source]
to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.card_on_file_data.CardOnFileData[source]

Bases: DataObject

__annotations__ = {'_CardOnFileData__initial_card_on_file_data': typing.Optional[worldline.acquiring.sdk.v1.domain.initial_card_on_file_data.InitialCardOnFileData], '_CardOnFileData__is_initial_transaction': typing.Optional[bool], '_CardOnFileData__subsequent_card_on_file_data': typing.Optional[worldline.acquiring.sdk.v1.domain.subsequent_card_on_file_data.SubsequentCardOnFileData]}
from_dictionary(dictionary: dict) → CardOnFileData[source]
property initial_card_on_file_data: InitialCardOnFileData | None
When card data is stored you need to flag its purpose using transactionType and the intended futureUse of the card data.

Type: worldline.acquiring.sdk.v1.domain.initial_card_on_file_data.InitialCardOnFileData

property is_initial_transaction: bool | None
Indicate whether this is the initial Card on File transaction or not

Type: bool

property subsequent_card_on_file_data: SubsequentCardOnFileData | None
When you are using stored card you need to again specify the transactionType. All values are supported when the MERCHANT is the initiator of the transaction. When the CARDHOLDER is the initiator of the transaction, only UNSCHEDULED_CARD_ON_FILE is supported. For all cases when the MERCHANT is the initiator of the transaction, the initialSchemeTransactionId property is mandatory. In case of MASTERCARD transactions, the initialSchemeTransactionLinkId should also be provided to support better linking of related transaction activity.

Type: worldline.acquiring.sdk.v1.domain.subsequent_card_on_file_data.SubsequentCardOnFileData

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.card_payment_data.CardPaymentData[source]

Bases: DataObject

__annotations__ = {'_CardPaymentData__allow_partial_approval': typing.Optional[bool], '_CardPaymentData__brand': typing.Optional[str], '_CardPaymentData__brand_selector': typing.Optional[str], '_CardPaymentData__capture_immediately': typing.Optional[bool], '_CardPaymentData__card_data': typing.Optional[worldline.acquiring.sdk.v1.domain.plain_card_data.PlainCardData], '_CardPaymentData__card_entry_mode': typing.Optional[str], '_CardPaymentData__card_on_file_data': typing.Optional[worldline.acquiring.sdk.v1.domain.card_on_file_data.CardOnFileData], '_CardPaymentData__cardholder_verification_method': typing.Optional[str], '_CardPaymentData__ecommerce_data': typing.Optional[worldline.acquiring.sdk.v1.domain.e_commerce_data.ECommerceData], '_CardPaymentData__network_token_data': typing.Optional[worldline.acquiring.sdk.v1.domain.network_token_data.NetworkTokenData], '_CardPaymentData__point_of_sale_data': typing.Optional[worldline.acquiring.sdk.v1.domain.point_of_sale_data.PointOfSaleData], '_CardPaymentData__service_location_data': typing.Optional[worldline.acquiring.sdk.v1.domain.service_location_data.ServiceLocationData], '_CardPaymentData__wallet_id': typing.Optional[str]}
property allow_partial_approval: bool | None
Indicate whether you allow partial approval or not

Type: bool

property brand: str | None
The card brand

Type: str

property brand_selector: str | None
The party responsible for the brand selection.

Type: str

property capture_immediately: bool | None
If true the transaction will be authorized and captured immediately

Type: bool

property card_data: PlainCardData | None
Card data in plain text

Type: worldline.acquiring.sdk.v1.domain.plain_card_data.PlainCardData

property card_entry_mode: str | None
Card entry mode used in the transaction

Type: str

property card_on_file_data: CardOnFileData | None
Card data can be kept on file to support various use cases. It requires you to flag the transaction correctly.

Type: worldline.acquiring.sdk.v1.domain.card_on_file_data.CardOnFileData

property cardholder_verification_method: str | None
Method used by the terminal or the e-commerce website to verify that the customer is the legitimate cardholder (a.k.a. CVM)

  • NONE: no cardholder verification performed

  • CARD_SECURITY_CODE: the customer provided the card verification value (3 or 4 digits)

  • THREE_DS: the customer completed an additional verification step with the card issuer

  • SIGNATURE: the terminal prompted for a signature

  • ONLINE_PIN: the terminal verifies the PIN online with the card issuer

  • OFFLINE_PIN: the terminal verified the PIN with the EMV chip on the card

  • CARDHOLDER_DEVICE: the cardholder device prompted the cardholder for authentication (a.k.a. CDCVM). Mainly used in transactions where digital wallets are involved

Type: str

property ecommerce_data: ECommerceData | None
Request data for eCommerce transactions

Type: worldline.acquiring.sdk.v1.domain.e_commerce_data.ECommerceData

from_dictionary(dictionary: dict) → CardPaymentData[source]
property network_token_data: NetworkTokenData | None

Type: worldline.acquiring.sdk.v1.domain.network_token_data.NetworkTokenData

property point_of_sale_data: PointOfSaleData | None
Request data for Point Of Sale (POS) or “in person” Transaction

Type: worldline.acquiring.sdk.v1.domain.point_of_sale_data.PointOfSaleData

property service_location_data: ServiceLocationData | None
Request data object to describe the location where the cardholder received the service. Note: You should either provide the address or the geo coordinates.

Type: worldline.acquiring.sdk.v1.domain.service_location_data.ServiceLocationData

to_dictionary() → dict[source]
property wallet_id: str | None
Type of wallet, values are assigned by card schemes, e.g.

  • 101 for MasterPass in eCommerce

  • 102 for MasterPass NFC

  • 103 for Apple Pay

  • 216 for Google Pay

  • 217 for Samsung Pay

  • 327 to indicate the usage of Network tokens in the transaction

Type: str

class worldline.acquiring.sdk.v1.domain.card_payment_data_for_balance_inquiry.CardPaymentDataForBalanceInquiry[source]

Bases: DataObject

__annotations__ = {'_CardPaymentDataForBalanceInquiry__brand': typing.Optional[str], '_CardPaymentDataForBalanceInquiry__brand_selector': typing.Optional[str], '_CardPaymentDataForBalanceInquiry__card_data': typing.Optional[worldline.acquiring.sdk.v1.domain.plain_card_data.PlainCardData], '_CardPaymentDataForBalanceInquiry__card_entry_mode': typing.Optional[str], '_CardPaymentDataForBalanceInquiry__cardholder_verification_method': typing.Optional[str], '_CardPaymentDataForBalanceInquiry__ecommerce_data': typing.Optional[worldline.acquiring.sdk.v1.domain.e_commerce_data.ECommerceData], '_CardPaymentDataForBalanceInquiry__point_of_sale_data': typing.Optional[worldline.acquiring.sdk.v1.domain.point_of_sale_data.PointOfSaleData], '_CardPaymentDataForBalanceInquiry__wallet_id': typing.Optional[str]}
property brand: str | None
The card brand

Type: str

property brand_selector: str | None
The party responsible for the brand selection.

Type: str

property card_data: PlainCardData | None
Card data in plain text

Type: worldline.acquiring.sdk.v1.domain.plain_card_data.PlainCardData

property card_entry_mode: str | None
Card entry mode used in the transaction

Type: str

property cardholder_verification_method: str | None
Method used by the terminal or the e-commerce website to verify that the customer is the legitimate cardholder (a.k.a. CVM)

  • NONE: no cardholder verification performed

  • CARD_SECURITY_CODE: the customer provided the card verification value (3 or 4 digits)

  • THREE_DS: the customer completed an additional verification step with the card issuer

  • SIGNATURE: the terminal prompted for a signature

  • ONLINE_PIN: the terminal verifies the PIN online with the card issuer

  • OFFLINE_PIN: the terminal verified the PIN with the EMV chip on the card

  • CARDHOLDER_DEVICE: the cardholder device prompted the cardholder for authentication (a.k.a. CDCVM). Mainly used in transactions where digital wallets are involved

Type: str

property ecommerce_data: ECommerceData | None
Request data for eCommerce transactions

Type: worldline.acquiring.sdk.v1.domain.e_commerce_data.ECommerceData

from_dictionary(dictionary: dict) → CardPaymentDataForBalanceInquiry[source]
property point_of_sale_data: PointOfSaleData | None
Request data for Point Of Sale (POS) or “in person” Transaction

Type: worldline.acquiring.sdk.v1.domain.point_of_sale_data.PointOfSaleData

to_dictionary() → dict[source]
property wallet_id: str | None
Type of wallet, values are assigned by card schemes, e.g.

  • 101 for MasterPass in eCommerce

  • 102 for MasterPass NFC

  • 103 for Apple Pay

  • 216 for Google Pay

  • 217 for Samsung Pay

  • 327 to indicate the usage of Network tokens in the transaction

Type: str

class worldline.acquiring.sdk.v1.domain.card_payment_data_for_refund.CardPaymentDataForRefund[source]

Bases: DataObject

__annotations__ = {'_CardPaymentDataForRefund__brand': typing.Optional[str], '_CardPaymentDataForRefund__brand_selector': typing.Optional[str], '_CardPaymentDataForRefund__capture_immediately': typing.Optional[bool], '_CardPaymentDataForRefund__card_data': typing.Optional[worldline.acquiring.sdk.v1.domain.plain_card_data.PlainCardData], '_CardPaymentDataForRefund__card_entry_mode': typing.Optional[str], '_CardPaymentDataForRefund__cardholder_verification_method': typing.Optional[str], '_CardPaymentDataForRefund__network_token_data': typing.Optional[worldline.acquiring.sdk.v1.domain.network_token_data.NetworkTokenData], '_CardPaymentDataForRefund__original_transaction_references': typing.Optional[worldline.acquiring.sdk.v1.domain.original_transaction_references.OriginalTransactionReferences], '_CardPaymentDataForRefund__point_of_sale_data': typing.Optional[worldline.acquiring.sdk.v1.domain.point_of_sale_data.PointOfSaleData], '_CardPaymentDataForRefund__wallet_id': typing.Optional[str]}
property brand: str | None
The card brand

Type: str

property brand_selector: str | None
The party responsible for the brand selection.

Type: str

property capture_immediately: bool | None
If true the transaction will be authorized and captured immediately

Type: bool

property card_data: PlainCardData | None
Card data in plain text

Type: worldline.acquiring.sdk.v1.domain.plain_card_data.PlainCardData

property card_entry_mode: str | None
Card entry mode used in the transaction

Type: str

property cardholder_verification_method: str | None
Method used by the terminal or the e-commerce website to verify that the customer is the legitimate cardholder (a.k.a. CVM)

  • NONE: no cardholder verification performed

  • CARD_SECURITY_CODE: the customer provided the card verification value (3 or 4 digits)

  • THREE_DS: the customer completed an additional verification step with the card issuer

  • SIGNATURE: the terminal prompted for a signature

  • ONLINE_PIN: the terminal verifies the PIN online with the card issuer

  • OFFLINE_PIN: the terminal verified the PIN with the EMV chip on the card

  • CARDHOLDER_DEVICE: the cardholder device prompted the cardholder for authentication (a.k.a. CDCVM). Mainly used in transactions where digital wallets are involved

Type: str

from_dictionary(dictionary: dict) → CardPaymentDataForRefund[source]
property network_token_data: NetworkTokenData | None

Type: worldline.acquiring.sdk.v1.domain.network_token_data.NetworkTokenData

property original_transaction_references: OriginalTransactionReferences | None
References to the original transaction

Type: worldline.acquiring.sdk.v1.domain.original_transaction_references.OriginalTransactionReferences

property point_of_sale_data: PointOfSaleData | None
Request data for Point Of Sale (POS) or “in person” Transaction

Type: worldline.acquiring.sdk.v1.domain.point_of_sale_data.PointOfSaleData

to_dictionary() → dict[source]
property wallet_id: str | None
Type of wallet, values are assigned by card schemes, e.g.

  • 101 for MasterPass in eCommerce

  • 102 for MasterPass NFC

  • 103 for Apple Pay

  • 216 for Google Pay

  • 217 for Samsung Pay

  • 327 to indicate the usage of Network tokens in the transaction

Type: str

class worldline.acquiring.sdk.v1.domain.card_payment_data_for_resource.CardPaymentDataForResource[source]

Bases: DataObject

__annotations__ = {'_CardPaymentDataForResource__brand': typing.Optional[str]}
property brand: str | None
The card brand

Type: str

from_dictionary(dictionary: dict) → CardPaymentDataForResource[source]
to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.card_payment_data_for_response.CardPaymentDataForResponse[source]

Bases: DataObject

__annotations__ = {'_CardPaymentDataForResponse__brand': typing.Optional[str], '_CardPaymentDataForResponse__ecommerce_data': typing.Optional[worldline.acquiring.sdk.v1.domain.e_commerce_data_for_response.ECommerceDataForResponse], '_CardPaymentDataForResponse__point_of_sale_data': typing.Optional[worldline.acquiring.sdk.v1.domain.point_of_sale_data_for_response.PointOfSaleDataForResponse]}
property brand: str | None
The card brand

Type: str

property ecommerce_data: ECommerceDataForResponse | None

Type: worldline.acquiring.sdk.v1.domain.e_commerce_data_for_response.ECommerceDataForResponse

from_dictionary(dictionary: dict) → CardPaymentDataForResponse[source]
property point_of_sale_data: PointOfSaleDataForResponse | None

Type: worldline.acquiring.sdk.v1.domain.point_of_sale_data_for_response.PointOfSaleDataForResponse

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.card_payment_data_for_verification.CardPaymentDataForVerification[source]

Bases: DataObject

__annotations__ = {'_CardPaymentDataForVerification__brand': typing.Optional[str], '_CardPaymentDataForVerification__brand_selector': typing.Optional[str], '_CardPaymentDataForVerification__card_data': typing.Optional[worldline.acquiring.sdk.v1.domain.plain_card_data.PlainCardData], '_CardPaymentDataForVerification__card_entry_mode': typing.Optional[str], '_CardPaymentDataForVerification__card_on_file_data': typing.Optional[worldline.acquiring.sdk.v1.domain.card_on_file_data.CardOnFileData], '_CardPaymentDataForVerification__cardholder_verification_method': typing.Optional[str], '_CardPaymentDataForVerification__ecommerce_data': typing.Optional[worldline.acquiring.sdk.v1.domain.e_commerce_data_for_account_verification.ECommerceDataForAccountVerification], '_CardPaymentDataForVerification__network_token_data': typing.Optional[worldline.acquiring.sdk.v1.domain.network_token_data.NetworkTokenData], '_CardPaymentDataForVerification__point_of_sale_data': typing.Optional[worldline.acquiring.sdk.v1.domain.point_of_sale_data.PointOfSaleData], '_CardPaymentDataForVerification__wallet_id': typing.Optional[str]}
property brand: str | None
The card brand

Type: str

property brand_selector: str | None
The party responsible for the brand selection.

Type: str

property card_data: PlainCardData | None
Card data in plain text

Type: worldline.acquiring.sdk.v1.domain.plain_card_data.PlainCardData

property card_entry_mode: str | None
Card entry mode used in the transaction

Type: str

property card_on_file_data: CardOnFileData | None
Card data can be kept on file to support various use cases. It requires you to flag the transaction correctly.

Type: worldline.acquiring.sdk.v1.domain.card_on_file_data.CardOnFileData

property cardholder_verification_method: str | None
Method used by the terminal or the e-commerce website to verify that the customer is the legitimate cardholder (a.k.a. CVM)

  • NONE: no cardholder verification performed

  • CARD_SECURITY_CODE: the customer provided the card verification value (3 or 4 digits)

  • THREE_DS: the customer completed an additional verification step with the card issuer

  • SIGNATURE: the terminal prompted for a signature

  • ONLINE_PIN: the terminal verifies the PIN online with the card issuer

  • OFFLINE_PIN: the terminal verified the PIN with the EMV chip on the card

  • CARDHOLDER_DEVICE: the cardholder device prompted the cardholder for authentication (a.k.a. CDCVM). Mainly used in transactions where digital wallets are involved

Type: str

property ecommerce_data: ECommerceDataForAccountVerification | None
Request data for eCommerce transactions

Type: worldline.acquiring.sdk.v1.domain.e_commerce_data_for_account_verification.ECommerceDataForAccountVerification

from_dictionary(dictionary: dict) → CardPaymentDataForVerification[source]
property network_token_data: NetworkTokenData | None

Type: worldline.acquiring.sdk.v1.domain.network_token_data.NetworkTokenData

property point_of_sale_data: PointOfSaleData | None
Request data for Point Of Sale (POS) or “in person” Transaction

Type: worldline.acquiring.sdk.v1.domain.point_of_sale_data.PointOfSaleData

to_dictionary() → dict[source]
property wallet_id: str | None
Type of wallet, values are assigned by card schemes, e.g.

  • 101 for MasterPass in eCommerce

  • 102 for MasterPass NFC

  • 103 for Apple Pay

  • 216 for Google Pay

  • 217 for Samsung Pay

  • 327 to indicate the usage of Network tokens in the transaction

Type: str

class worldline.acquiring.sdk.v1.domain.customer_service_data.CustomerServiceData[source]

Bases: DataObject

__annotations__ = {'_CustomerServiceData__customer_service_email': typing.Optional[str], '_CustomerServiceData__customer_service_phone_number': typing.Optional[str], '_CustomerServiceData__customer_service_url': typing.Optional[str]}
property customer_service_email: str | None
Submerchant’s customer service email address. Applicable only for Amex transactions but this field could be set for other scheme transactions too. Mandatory for all card not present transactions processed through Bambora.

Type: str

property customer_service_phone_number: str | None
Submerchant’s customer service phone number that can be used for transaction inquiries. Applicable for MasterCard transactions but this field could be set for other scheme transactions too. Optional for all card not present transactions. Either CustomerServiceUrl or CustomerServicePhoneNumber is mandatory for card present transactions.

Type: str

property customer_service_url: str | None
Submerchant’s customer service portal URL Applicable for MasterCard transactions but this field could be set for other scheme transactions too. Mandatory for all card not present transactions processed through Bambora. Either CustomerServiceUrl or CustomerServicePhoneNumber is mandatory for card present transactions.

Type: str

from_dictionary(dictionary: dict) → CustomerServiceData[source]
to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.date_range.DateRange[source]

Bases: DataObject

__annotations__ = {'_DateRange__greater_equal': typing.Optional[datetime.date], '_DateRange__lower_equal': typing.Optional[datetime.date]}
from_dictionary(dictionary: dict) → DateRange[source]
property greater_equal: date | None
A date value that can be used in search criteria to filter results to only include items with a date greater than or equal to the specified value (equal or after). The date is in ISO 8601 format.

Type: date

property lower_equal: date | None
A date value that can be used in search criteria to filter results to only include items with a date lower than the specified value (equal or before). The date is in ISO 8601 format.

Type: date

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.date_time_range.DateTimeRange[source]

Bases: DataObject

__annotations__ = {'_DateTimeRange__greater': typing.Optional[str], '_DateTimeRange__greater_equal': typing.Optional[str], '_DateTimeRange__lower': typing.Optional[str], '_DateTimeRange__lower_equal': typing.Optional[str]}
from_dictionary(dictionary: dict) → DateTimeRange[source]
property greater: str | None
A date-time value that can be used in search criteria to filter results to only include items with a date-time greater to the specified value (after). The date-time is in ISO 8601 format, but without the timezone designator.

Type: str

property greater_equal: str | None
A date-time value that can be used in search criteria to filter results to only include items with a date-time greater than or equal to the specified value (equal or after). The date-time is in ISO 8601 format, but without the timezone designator.

Type: str

property lower: str | None
A date-time value that can be used in search criteria to filter results to only include items with a date-time lower to the specified value (before). The date-time is in ISO 8601 format, but without the timezone designator.

Type: str

property lower_equal: str | None
A date-time value that can be used in search criteria to filter results to only include items with a date-time lower than or equal to the specified value (equal or before). The date-time is in ISO 8601 format, but without the timezone designator.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.dcc_data.DccData[source]

Bases: DataObject

__annotations__ = {'_DccData__amount': typing.Optional[int], '_DccData__conversion_rate': typing.Optional[float], '_DccData__currency_code': typing.Optional[str], '_DccData__number_of_decimals': typing.Optional[int]}
property amount: int | None
Amount of transaction formatted according to card scheme specifications. E.g. 100 for 1.00 EUR.

Type: int

property conversion_rate: float | None
Currency conversion rate in decimal notation.

Type: float

property currency_code: str | None
Alpha-numeric ISO 4217 currency code for transaction, e.g. EUR

Type: str

from_dictionary(dictionary: dict) → DccData[source]
property number_of_decimals: int | None
Number of decimals in the amount

Type: int

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.dcc_proposal.DccProposal[source]

Bases: DataObject

__annotations__ = {'_DccProposal__original_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_DccProposal__rate': typing.Optional[worldline.acquiring.sdk.v1.domain.rate_data.RateData], '_DccProposal__rate_reference_id': typing.Optional[str], '_DccProposal__resulting_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData]}
from_dictionary(dictionary: dict) → DccProposal[source]
property original_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

property rate: RateData | None

Type: worldline.acquiring.sdk.v1.domain.rate_data.RateData

property rate_reference_id: str | None
The rate reference ID

Type: str

property resulting_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.dispute_case.DisputeCase[source]

Bases: DataObject

__annotations__ = {'_DisputeCase__dispute_date_time_data': typing.Optional[worldline.acquiring.sdk.v1.domain.dispute_date_time_data.DisputeDateTimeData], '_DisputeCase__dispute_id': typing.Optional[str], '_DisputeCase__dispute_references': typing.Optional[worldline.acquiring.sdk.v1.domain.dispute_references.DisputeReferences], '_DisputeCase__dispute_stage': typing.Optional[str], '_DisputeCase__dispute_status': typing.Optional[str], '_DisputeCase__dispute_status_category': typing.Optional[str], '_DisputeCase__is_open': typing.Optional[bool], '_DisputeCase__merchant_balance_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.signed_amount_data.SignedAmountData], '_DisputeCase__merchant_data': typing.Optional[worldline.acquiring.sdk.v1.domain.dispute_merchant_data.DisputeMerchantData], '_DisputeCase__original_dispute_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_DisputeCase__original_transaction_data': typing.Optional[worldline.acquiring.sdk.v1.domain.original_transaction_data.OriginalTransactionData], '_DisputeCase__scheme_reason': typing.Optional[str], '_DisputeCase__scheme_reason_description': typing.Optional[str], '_DisputeCase__unified_category': typing.Optional[str], '_DisputeCase__unified_reason': typing.Optional[str]}
property dispute_date_time_data: DisputeDateTimeData | None
A set of date time fields related to the dispute case. Depending on the disputeStatus and disputeStage of the dispute, different date time fields are relevant. For example, when the disputeStatus is “EVIDENCE_REQUESTED”, the responseDueDate field indicates the deadline to respond to the dispute.

The closedDateTime field represents the date and time when the dispute was closed. This field is only returned for closed disputes. Disputes that are open too long are automatically closed.

Type: worldline.acquiring.sdk.v1.domain.dispute_date_time_data.DisputeDateTimeData

property dispute_id: str | None
The unique identifier for a dispute.

Type: str

property dispute_references: DisputeReferences | None
A set of references related to the dispute case.

Type: worldline.acquiring.sdk.v1.domain.dispute_references.DisputeReferences

property dispute_stage: str | None
The current stage in the lifecycle of the dispute.

Possible values are:

  • CREATED (The dispute case includes no dispute relevant information)

  • FRAUD (The dispute case is opened with a fraud report (Issuer cases only))

  • INQUIRY (Pre-dispute phase)

  • DISPUTE (The dispute case reached the dispute stage, which includes dispute and representment handling)

  • PRE_ARBITRATION (The dispute case is in the first stage of the case filing process, before escalation to arbitration)

  • ARBITRATION (The dispute case filing process escalated to the arbitration phase)

  • PRE_COMPLIANCE (The dispute case is in the first stage of the case filing process, before escalation to compliance)

  • COMPLIANCE (The dispute case filing process escalated to the compliance phase)

Type: str

property dispute_status: str | None
The current status of the dispute.

Possible values are:

  • For IN_PROGRESS dispute status category:

    • REVIEW_BY_ACQUIRER (Next action is on Acquirer side)

    • REVIEW_BY_ISSUER (Next action is on Issuer side)

    • REVIEW_BY_SCHEME (Next action is on Scheme side)

  • For NEEDS_RESPONSE dispute status category:

    • EVIDENCE_REQUESTED (Acquirer request evidence from merchant)

  • For WON dispute status category:

    • ISSUER_WITHDRAWN (Issuer withdraw the dispute and accept liability)

    • SUCCESSFUL_DEFENSE (Acquirer dispute defense was successful)

    • SCHEME_RULING (Dispute is escalated and scheme ruled in favor of Merchant)

  • For LOST dispute status category:

    • UNSUCCESSFUL_DEFENSE (Acquirer dispute defense was not successful)

    • UNANSWERED_EXPIRED (Dispute respond time expired, no further defense is possible)

    • ACCEPTED (Acquirer accepted liability)

    • SCHEME_RULING (Dispute is escalated and scheme ruled in favor of Issuer)

  • For CANCELLED dispute status category:

    • DISPUTE_CANCELLED (Issuer withdrew the dispute)

Type: str

property dispute_status_category: str | None
The category of the current status of the dispute.

Possible values are:

  • IN_PROGRESS (Dispute process is ongoing and has no final decision. The merchant currently waits for further status updates.)

  • NEEDS_RESPONSE (The merchant is contacted to provide supporting evidence documents before a deadline)

  • WON (Dispute case has been won)

  • LOST (Dispute case has been lost)

  • CANCELLED (Dispute has been withdrawn)

Type: str

from_dictionary(dictionary: dict) → DisputeCase[source]
property is_open: bool | None
Indicates whether the dispute is open or closed. An open dispute is a dispute that’s still in the process of being resolved, while a closed dispute is a dispute that has been resolved.

Type: bool

property merchant_balance_amount: SignedAmountData | None
Amount with an indicator whether it’s a debit or credit amount.

Type: worldline.acquiring.sdk.v1.domain.signed_amount_data.SignedAmountData

property merchant_data: DisputeMerchantData | None
Data related to the merchant involved in the dispute.

Type: worldline.acquiring.sdk.v1.domain.dispute_merchant_data.DisputeMerchantData

property original_dispute_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

property original_transaction_data: OriginalTransactionData | None
Data related to the original transaction that led to the dispute.

Type: worldline.acquiring.sdk.v1.domain.original_transaction_data.OriginalTransactionData

property scheme_reason: str | None
The reason provided by the card scheme for the dispute.

Type: str

property scheme_reason_description: str | None
The human readable description of the reason provided by the card scheme for the dispute.

Type: str

to_dictionary() → dict[source]
property unified_category: str | None
The unified category of the dispute, used for categorization and reporting purposes. Only present if a dispute was received.

Possible values are:

  • AUTHORIZATION_RELATED (authorization related disputes)

  • FRAUD_RELATED (fraud related disputes)

  • CONSUMER_DISPUTE (consumer initiated disputes)

  • PROCESSING_ERROR (error during the payment processing leads to a dispute)

  • OTHER (collection of diverse dispute reasons)

Type: str

property unified_reason: str | None
The unified reason for the dispute, used for categorization and reporting purposes. Only present if a dispute was received.

Possible values are:

  • FRAUDULENT_CARD_USAGE (Fraudulent use of card)

  • UNAUTHORIZED_TRANSACTION (No valid Issuer authorization)

  • GENERAL_PAYMENT_ERROR (General payment error)

  • INVALID_TRANSACTION_TYPE (Invalid transaction type)

  • INVALID_CURRENCY (Invalid currency)

  • INVALID_CARD_NUMBER (Invalid card number)

  • INVALID_AMOUNT (Invalid amount)

  • DUPLICATE_CHARGE_OR_PAID_BY_OTHER_MEANS (Duplicate charge or paid by other means)

  • GENERAL_CUSTOMER_DISPUTE (General customer dispute)

  • GOODS_OR_SERVICES_NOT_RECEIVED (Goods or services not received)

  • CANCELLED_SUBSCRIPTION (Cancelled subscription)

  • GOODS_OR_SERVICES_NOT_MATCHING_ORDER (Goods or services not matching order)

  • COUNTERFEIT_MERCHANDISE (Counterfeit merchandise)

  • DUE_REFUND_NOT_RECEIVED (Due refund not received)

  • CHARGE_NOT_ACCEPTED ((Subsequent) Charge not accepted)

  • OTHER (Other)

Type: str

class worldline.acquiring.sdk.v1.domain.dispute_case_with_entries.DisputeCaseWithEntries[source]

Bases: DisputeCase

__annotations__ = {'_DisputeCaseWithEntries__entries': typing.Optional[typing.List[worldline.acquiring.sdk.v1.domain.dispute_entry.DisputeEntry]]}
property entries: List[DisputeEntry] | None
A list of entries that were done against the dispute during its lifecycle.

Type: list[worldline.acquiring.sdk.v1.domain.dispute_entry.DisputeEntry]

from_dictionary(dictionary: dict) → DisputeCaseWithEntries[source]
to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.dispute_date_time_data.DisputeDateTimeData[source]

Bases: DataObject

__annotations__ = {'_DisputeDateTimeData__closed_date_time': typing.Optional[str], '_DisputeDateTimeData__last_status_changed_date_time': typing.Optional[str], '_DisputeDateTimeData__opened_date_time': typing.Optional[str], '_DisputeDateTimeData__response_due_date': typing.Optional[datetime.date]}
property closed_date_time: str | None
The date and time when the dispute was closed, in ISO 8601 format, but without the timezone designator. Only present if the dispute is closed.

Type: str

from_dictionary(dictionary: dict) → DisputeDateTimeData[source]
property last_status_changed_date_time: str | None
The date and time when the status of the dispute was last updated, in ISO 8601 format, but without the timezone designator. When the dispute case is first created the value will be equal to the OpenedDateTime property. As dispute process continues, this value changes.

Type: str

property opened_date_time: str | None
The date and time when the dispute was opened, in ISO 8601 format, but without the timezone designator.

Type: str

property response_due_date: date | None
The date when a response to the dispute is due. This field is typically relevant when the disputeStatus is “EVIDENCE_REQUESTED”, to indicate the deadline to respond to the dispute.

Type: date

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.dispute_document.DisputeDocument[source]

Bases: DataObject

__annotations__ = {'_DisputeDocument__document_id': typing.Optional[str], '_DisputeDocument__file_name': typing.Optional[str], '_DisputeDocument__mime_type': typing.Optional[str]}
property document_id: str | None
The unique identifier of a document submitted as evidence for the dispute case, if applicable.

Type: str

property file_name: str | None
The name of the file submitted as evidence for the dispute case, if applicable.

Type: str

from_dictionary(dictionary: dict) → DisputeDocument[source]
property mime_type: str | None
The MIME type of the file submitted as evidence for the dispute case, if applicable.

Possible values are:

  • application/pdf

  • image/jpeg

  • image/jpg

  • image/png

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.dispute_document_id_item.DisputeDocumentIdItem[source]

Bases: DataObject

__annotations__ = {'_DisputeDocumentIdItem__document_id': typing.Optional[str]}
property document_id: str | None
The unique identifier of a document submitted as evidence for the dispute case, if applicable.

Type: str

from_dictionary(dictionary: dict) → DisputeDocumentIdItem[source]
to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.dispute_entry.DisputeEntry[source]

Bases: DataObject

__annotations__ = {'_DisputeEntry__documents': typing.Optional[typing.List[worldline.acquiring.sdk.v1.domain.dispute_document.DisputeDocument]], '_DisputeEntry__elaboration': typing.Optional[str], '_DisputeEntry__entry_category': typing.Optional[str], '_DisputeEntry__entry_date_time': typing.Optional[str], '_DisputeEntry__entry_id': typing.Optional[str], '_DisputeEntry__entry_type': typing.Optional[str], '_DisputeEntry__entry_type_description': typing.Optional[str], '_DisputeEntry__message_text': typing.Optional[str], '_DisputeEntry__questionnaire': typing.Optional[str], '_DisputeEntry__response_due_date': typing.Optional[datetime.date], '_DisputeEntry__scheme_reason': typing.Optional[str], '_DisputeEntry__scheme_reason_description': typing.Optional[str], '_DisputeEntry__settlement_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_DisputeEntry__transaction_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_DisputeEntry__user_id': typing.Optional[str]}
property documents: List[DisputeDocument] | None
A list of documents related to the history entry.

Type: list[worldline.acquiring.sdk.v1.domain.dispute_document.DisputeDocument]

property elaboration: str | None
The long message text of the dispute entry, if applicable. This is typically used for communication entries to provide the content of the message sent by the acquirer to the merchant or vice versa. This field can contain a more detailed message than the messageText property.

Type: str

property entry_category: str | None
The category of the dispute entry.

Possible values are:

  • DISPUTE (Transaction which drives the scheme dispute processing flow)

  • COMMUNICATION (Conversational and informational messages which are exchanged in the communication between Acquirer and Merchant)

  • EVIDENCE (Merchant response to Acquirer Evidence Request (including liability acceptance))

  • POSTING (Notification about upcoming Merchant account adjustments, executed by the Acquirer)

Type: str

property entry_date_time: str | None
The date and time when the dispute entry was made, in ISO 8601 format, but without the timezone designator.

Type: str

property entry_id: str | None
The unique identifier for an dispute entry.

Type: str

property entry_type: str | None
The type of the dispute entry. The values for this field depend on the value of the EntryCategory field.

Possible values are:

  • For DISPUTE entry Category:

    • Iss-Dsp (Issuer dispute (full/partial))

    • Iss-DspRev (Issuer reversed dispute)

    • Iss-ArbDsp (Issuer Arbitration dispute (full/partial))

    • Iss-PArb (Issuer Pre-Arbitration (full/partial))

    • Iss-PComp (Issuer Pre-Compliance)

    • Iss-Arb (Issuer Arbitration)

    • ‘Iss-Comp’ (Issuer Compliance)

    • Acq-PArb (Acquirer Pre-Arbitration (full/partial))

    • Acq-PComp (Acquirer Pre-Compliance)

    • Acq-Arb (Acquirer Arbitration)

    • Acq-Comp (Acquirer Compliance)

    • Acq-DspDecline (Acquirer Declines Dispute (full/partial))

    • Acq-ArbDspDecline (Acquirer Declines Arbitration Dispute (full/partial))

    • Acq-PArbDecline (Acquirer Declines Pre-Arbitration (full/partial))

    • Acq-PCompDecline (Acquirer Declines Pre-Compliance (full/partial))

    • Iss-PArbDecline (Issuer Declines Pre-Arbitration (full/partial))

    • Iss-PCompDecline (Issuer Declines Pre-Compliance (full/partial))

    • Acq-MchLost (Dispute case is lost, Liability on Acquirer)

    • Acq-MchWon (Dispute case is won, Liability on Issuer)

  • For COMMUNICATION entryCategory:

    • Acq-MsgToMch (Acquirer sent a message to the Merchant)

    • Mch-MsgToAcq (Merchant sent a message to the Acquirer)

  • For EVIDENCE entryCategory:

    • Acq-EvidenceReq (Acquirer request evidence from Merchant)

    • Acq-EvidenceRej (Acquirer reject the evidence submitted by the Merchant)

    • Mch-Evidence (Merchant submitted evidence)

    • Mch-Accept (Merchant accepted liability)

  • For POSTING entryCategory:

    • Acq-CreditAdj (Acquirer credited the Merchant)

    • Acq-DebitAdj (Acquirer debited the Merchant)

Type: str

property entry_type_description: str | None
The human readable description of the EntryType field.

Type: str

from_dictionary(dictionary: dict) → DisputeEntry[source]
property message_text: str | None
The message text of the dispute entry, if applicable. This is typically used for communication entries to provide the content of the message sent by the acquirer to the merchant or vice versa.

Type: str

property questionnaire: str | None
The questionnaire provided by the card scheme for the dispute, if applicable. This is typically used for communication entries to provide the content of the questionnaire sent by the acquirer to the merchant in case the card scheme requires a specific set of questions to be answered by the merchant in order to provide evidence for the dispute case.

Type: str

property response_due_date: date | None
The date when a response to the dispute is due. This field is typically relevant when the disputeStatus is “EVIDENCE_REQUESTED”, to indicate the deadline to respond to the dispute.

Type: date

property scheme_reason: str | None
The reason provided by the card scheme for the dispute.

Type: str

property scheme_reason_description: str | None
The human readable description of the reason provided by the card scheme for the dispute.

Type: str

property settlement_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

to_dictionary() → dict[source]
property transaction_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

property user_id: str | None
The unique identifier of the user that triggered the dispute entry, if applicable.

Type: str

class worldline.acquiring.sdk.v1.domain.dispute_entry_resources.DisputeEntryResources[source]

Bases: DataObject

__annotations__ = {'_DisputeEntryResources__dispute_entries': typing.Optional[typing.List[worldline.acquiring.sdk.v1.domain.dispute_entry_with_dispute_summary.DisputeEntryWithDisputeSummary]], '_DisputeEntryResources__pagination': typing.Optional[worldline.acquiring.sdk.v1.domain.pagination_response.PaginationResponse], '_DisputeEntryResources__request_id': typing.Optional[str]}
property dispute_entries: List[DisputeEntryWithDisputeSummary] | None
A list of dispute entries matching the provided search criteria. Each entry documents a single event in the lifecycle of the dispute, such as when the dispute was opened, when evidence was requested by the acquirer, when evidence was provided by the merchant, when a credit adjustment was made by the acquirer, etc.

Each entry has a category and type that indicate what kind of step it represents. The data elements can be different, depending on the entry type. For some steps more details are provided in a message text.

For each entry, if there are documents related to it, a list of document metadata will be included in the documents field.

Optionally a disputeSummary object can be included for each entry by setting the includeDisputeSummary parameter to true in the request of the Search Dispute Entries endpoint. This summary contains key information on the dispute case that can be useful to understand the context of the entry, such as the current status and stage of the dispute, the type of dispute, the amount in dispute, the reason code, etc.

Type: list[worldline.acquiring.sdk.v1.domain.dispute_entry_with_dispute_summary.DisputeEntryWithDisputeSummary]

from_dictionary(dictionary: dict) → DisputeEntryResources[source]
property pagination: PaginationResponse | None
Pagination details for paginated responses.

Type: worldline.acquiring.sdk.v1.domain.pagination_response.PaginationResponse

property request_id: str | None
The unique Worldline identifier for the request that resulted in this response.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.dispute_entry_with_dispute_summary.DisputeEntryWithDisputeSummary[source]

Bases: DisputeEntry

__annotations__ = {'_DisputeEntryWithDisputeSummary__dispute_id': typing.Optional[str], '_DisputeEntryWithDisputeSummary__dispute_summary': typing.Optional[worldline.acquiring.sdk.v1.domain.dispute_summary.DisputeSummary]}
property dispute_id: str | None
The unique identifier for a dispute.

Type: str

property dispute_summary: DisputeSummary | None
A summary of the dispute case, returned in the search results when searching for dispute
entries. This is only returned when explicitly requested via the includeDisputeSummary property is set to true in the request.

Type: worldline.acquiring.sdk.v1.domain.dispute_summary.DisputeSummary

from_dictionary(dictionary: dict) → DisputeEntryWithDisputeSummary[source]
to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.dispute_merchant_data.DisputeMerchantData[source]

Bases: DisputeMerchantDataBase

__annotations__ = {'_DisputeMerchantData__merchant_category_code': typing.Optional[int], '_DisputeMerchantData__merchant_city': typing.Optional[str], '_DisputeMerchantData__merchant_country_code': typing.Optional[str], '_DisputeMerchantData__merchant_name': typing.Optional[str]}
from_dictionary(dictionary: dict) → DisputeMerchantData[source]
property merchant_category_code: int | None
Merchant category code (MCC)

Type: int

property merchant_city: str | None
The city where the merchant is located.

Type: str

property merchant_country_code: str | None
The country code of the merchant’s location in ISO 3166-1 alpha-2 format.

Type: str

property merchant_name: str | None
Merchant name

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.dispute_merchant_data_base.DisputeMerchantDataBase[source]

Bases: DataObject

__annotations__ = {'_DisputeMerchantDataBase__acquirer_id': typing.Optional[str], '_DisputeMerchantDataBase__merchant_id': typing.Optional[str], '_DisputeMerchantDataBase__merchant_root_id': typing.Optional[str], '__acquirer_id': 'Optional[str]', '__merchant_id': 'Optional[str]', '__merchant_root_id': 'Optional[str]'}
property acquirer_id: str | None
The unique identifier of the acquirer.

Type: str

from_dictionary(dictionary: dict) → DisputeMerchantDataBase[source]
property merchant_id: str | None
The unique identifier of the merchant.

Type: str

property merchant_root_id: str | None
The root identifier of the merchant, which is the same for all sub-merchants under the same parent company.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.dispute_references.DisputeReferences[source]

Bases: DataObject

__annotations__ = {'_DisputeReferences__acquirer_dispute_reference': typing.Optional[str], '_DisputeReferences__scheme_dispute_reference': typing.Optional[str]}
property acquirer_dispute_reference: str | None
The reference provided by the acquirer for the dispute.

Type: str

from_dictionary(dictionary: dict) → DisputeReferences[source]
property scheme_dispute_reference: str | None
The reference provided by the card scheme for the dispute.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.dispute_response.DisputeResponse[source]

Bases: DataObject

__annotations__ = {'_DisputeResponse__dispute': typing.Optional[worldline.acquiring.sdk.v1.domain.dispute_case_with_entries.DisputeCaseWithEntries], '_DisputeResponse__request_id': typing.Optional[str]}
property dispute: DisputeCaseWithEntries | None
A dispute represents a chargeback case. It contains details on the dispute and a history of entries that were done against the dispute during the lifecycle of the dispute.

Each dispute has a unique disputeId that identifies it. You can use this disputeId to retrieve the details of the dispute and its history via the Retrieve Dispute endpoint, or to retrieve specific documents related to the dispute via the Retrieve Dispute Document endpoint.

We return both the schemeReason, which is the reason provided by the card scheme for the dispute, and the unifiedReason, which is our mapping of the scheme reason to a unified reason that we use across all schemes. This allows you to easily filter disputes based on the unifiedReason, while still having the schemeReason available for reference. The unifiedCategory is a high level category of the dispute reason, that we use to group similar unifiedReason values together.

The disputeStatus field represents the current status of the dispute. The possible values for this field are specific to each card scheme, but we also provide a disputeStatusCategory field that groups the different disputeStatus values into a few high level categories that are consistent across all schemes. This allows you to easily filter disputes based on the disputeStatusCategory, while still having the disputeStatus available for reference.

The disputeStage field represents the current stage of the dispute in the dispute lifecycle. The possible values for this field represent the different stages that a dispute can be in during its lifecycle, such as “DISPUTE”, “PRE_ARBITRATION”, “ARBITRATION”, etc.

The originalDisputeAmount object represents the original amount of the dispute when it was first created. This amount can change during the lifecycle of the dispute, for example if the cardholder disputes only part of the original transaction amount, or if there are fees applied to the dispute. The merchantBalanceAmount field represents the current amount that’s charged to or credited back to the merchant for this dispute. This amount can be different from the originalDisputeAmount due to partial disputes, fees, or if the dispute was challenged by the merchant and is currently being reviewed by the card scheme.

The disputeReferences object contains a set of references related to the dispute, such as the acquirer dispute reference and the scheme dispute reference. These references can be used when communicating with the acquirer or the card scheme about the dispute.

The DisputeDateTimeData object contains a set of date time fields related to the dispute, such as the opened date, response due date, closed date, etc. These fields can provide more context on the timeline of the dispute. When the disputeStatus is “EVIDENCE_REQUESTED”, the responseDueDate field indicates the deadline to respond to the dispute.

The originalTransactionData object contains data related to the original transaction that led to the dispute, such as transaction references, transaction amount, payment method data, etc. This information can be useful to understand the context of the dispute and to provide evidence when challenging the dispute.

The merchantData object contains data related to the merchant involved in the dispute, such as merchant name, merchant category code, acquirer ID, etc. This information can also be useful to understand the context of the dispute and to provide evidence when challenging the dispute.

Optionally the full history of entries for the dispute is included by setting the includeEntries parameter to true when retrieving the dispute details. Each entry in the history represents a step in the lifecycle of the dispute, such as when the dispute was opened, when evidence was requested by the acquirer, when evidence was provided by the merchant, when a credit adjustment was made by the acquirer, etc. The history is ordered from the oldest entry to the most recent one.

Type: worldline.acquiring.sdk.v1.domain.dispute_case_with_entries.DisputeCaseWithEntries

from_dictionary(dictionary: dict) → DisputeResponse[source]
property request_id: str | None
The unique Worldline identifier for the request that resulted in this response.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.dispute_summary.DisputeSummary[source]

Bases: DataObject

__annotations__ = {'_DisputeSummary__acquirer_dispute_reference': typing.Optional[str], '_DisputeSummary__merchant_data': typing.Optional[worldline.acquiring.sdk.v1.domain.dispute_merchant_data_base.DisputeMerchantDataBase], '_DisputeSummary__original_transaction_data': typing.Optional[worldline.acquiring.sdk.v1.domain.original_transaction_summary_data.OriginalTransactionSummaryData], '_DisputeSummary__scheme_reason': typing.Optional[str], '_DisputeSummary__scheme_reason_description': typing.Optional[str], '_DisputeSummary__unified_category': typing.Optional[str], '_DisputeSummary__unified_reason': typing.Optional[str]}
property acquirer_dispute_reference: str | None
The reference provided by the acquirer for the dispute.

Type: str

from_dictionary(dictionary: dict) → DisputeSummary[source]
property merchant_data: DisputeMerchantDataBase | None
Summary data related to the merchant involved in the dispute.

Type: worldline.acquiring.sdk.v1.domain.dispute_merchant_data_base.DisputeMerchantDataBase

property original_transaction_data: OriginalTransactionSummaryData | None
Data related to the original transaction that led to the dispute.

Type: worldline.acquiring.sdk.v1.domain.original_transaction_summary_data.OriginalTransactionSummaryData

property scheme_reason: str | None
The reason provided by the card scheme for the dispute.

Type: str

property scheme_reason_description: str | None
The human readable description of the reason provided by the card scheme for the dispute.

Type: str

to_dictionary() → dict[source]
property unified_category: str | None
The unified category of the dispute, used for categorization and reporting purposes. Only present if a dispute was received.

Possible values are:

  • AUTHORIZATION_RELATED (authorization related disputes)

  • FRAUD_RELATED (fraud related disputes)

  • CONSUMER_DISPUTE (consumer initiated disputes)

  • PROCESSING_ERROR (error during the payment processing leads to a dispute)

  • OTHER (collection of diverse dispute reasons)

Type: str

property unified_reason: str | None
The unified reason for the dispute, used for categorization and reporting purposes. Only present if a dispute was received.

Possible values are:

  • FRAUDULENT_CARD_USAGE (Fraudulent use of card)

  • UNAUTHORIZED_TRANSACTION (No valid Issuer authorization)

  • GENERAL_PAYMENT_ERROR (General payment error)

  • INVALID_TRANSACTION_TYPE (Invalid transaction type)

  • INVALID_CURRENCY (Invalid currency)

  • INVALID_CARD_NUMBER (Invalid card number)

  • INVALID_AMOUNT (Invalid amount)

  • DUPLICATE_CHARGE_OR_PAID_BY_OTHER_MEANS (Duplicate charge or paid by other means)

  • GENERAL_CUSTOMER_DISPUTE (General customer dispute)

  • GOODS_OR_SERVICES_NOT_RECEIVED (Goods or services not received)

  • CANCELLED_SUBSCRIPTION (Cancelled subscription)

  • GOODS_OR_SERVICES_NOT_MATCHING_ORDER (Goods or services not matching order)

  • COUNTERFEIT_MERCHANDISE (Counterfeit merchandise)

  • DUE_REFUND_NOT_RECEIVED (Due refund not received)

  • CHARGE_NOT_ACCEPTED ((Subsequent) Charge not accepted)

  • OTHER (Other)

Type: str

class worldline.acquiring.sdk.v1.domain.dukpt_pin_encryption_data.DukptPinEncryptionData[source]

Bases: PinEncryptionData

PIN_ENCRYPTION_TYPE = 'DUKPT'
__annotations__ = {'_DukptPinEncryptionData__key_serial_number': typing.Optional[str], '__key_serial_number': 'Optional[str]'}
from_dictionary(dictionary: dict) → DukptPinEncryptionData[source]
property key_serial_number: str | None
Key Serial Number (KSN) if DUKPT encryption is used for the PIN block (3DES: 10 b, AES: 12 b)

Type: str

property pin_encryption_type: str
Possible values are: AES_UKPT, DUKPT, ZPK.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.e_commerce_data.ECommerceData[source]

Bases: DataObject

__annotations__ = {'_ECommerceData__address_verification_data': typing.Optional[worldline.acquiring.sdk.v1.domain.address_verification_data.AddressVerificationData], '_ECommerceData__sca_exemption_request': typing.Optional[str], '_ECommerceData__three_d_secure': typing.Optional[worldline.acquiring.sdk.v1.domain.three_d_secure.ThreeDSecure]}
property address_verification_data: AddressVerificationData | None
Address Verification System data

Type: worldline.acquiring.sdk.v1.domain.address_verification_data.AddressVerificationData

from_dictionary(dictionary: dict) → ECommerceData[source]
property sca_exemption_request: str | None
Strong customer authentication exemption request. Indicates the reason why the transaction may be exempt from SCA requirements.

Possible values are:

  • LOW_VALUE_PAYMENT - Transaction amount is low enough to be exempt from SCA requirements.

  • SCA_DELEGATION - Strong Customer Authentication (SCA) has been performed through other means.

  • SECURE_CORPORATE_PAYMENT - The transaction is a secure corporate payment, using a corporate card.

  • TRANSACTION_RISK_ANALYSIS - The transaction risk has been analyzed and deemed low.

  • TRUSTED_BENEFICIARY - The beneficiary is a trusted entity with established relationship.

  • AUTHENTICATION_OUTAGE - The authentication service is currently unavailable.

Type: str

property three_d_secure: ThreeDSecure | None
3D Secure data.
Please note that if AAV or CAVV or equivalent is missing, transaction should not be flagged as 3D Secure.

Type: worldline.acquiring.sdk.v1.domain.three_d_secure.ThreeDSecure

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.e_commerce_data_for_account_verification.ECommerceDataForAccountVerification[source]

Bases: DataObject

__annotations__ = {'_ECommerceDataForAccountVerification__address_verification_data': typing.Optional[worldline.acquiring.sdk.v1.domain.address_verification_data.AddressVerificationData], '_ECommerceDataForAccountVerification__three_d_secure': typing.Optional[worldline.acquiring.sdk.v1.domain.three_d_secure.ThreeDSecure]}
property address_verification_data: AddressVerificationData | None
Address Verification System data

Type: worldline.acquiring.sdk.v1.domain.address_verification_data.AddressVerificationData

from_dictionary(dictionary: dict) → ECommerceDataForAccountVerification[source]
property three_d_secure: ThreeDSecure | None
3D Secure data.
Please note that if AAV or CAVV or equivalent is missing, transaction should not be flagged as 3D Secure.

Type: worldline.acquiring.sdk.v1.domain.three_d_secure.ThreeDSecure

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.e_commerce_data_for_response.ECommerceDataForResponse[source]

Bases: DataObject

__annotations__ = {'_ECommerceDataForResponse__address_verification_result': typing.Optional[str], '_ECommerceDataForResponse__card_security_code_result': typing.Optional[str]}
property address_verification_result: str | None
Result of Address Verification Result
Possible values:

  • MATCH

  • ADDRESS_MATCH

  • POSTAL_CODE_MATCH

  • MISMATCH

  • NOT_VERIFIED

  • OTHER

  • ERROR

Type: str

property card_security_code_result: str | None
Result of card security code check
Possible values:

  • MATCH

  • MISMATCH

  • NOT_VERIFIED

  • OMITTED

  • MISSING

Type: str

from_dictionary(dictionary: dict) → ECommerceDataForResponse[source]
to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.emv_data_item.EmvDataItem[source]

Bases: DataObject

__annotations__ = {'_EmvDataItem__tag': typing.Optional[str], '_EmvDataItem__value': typing.Optional[str]}
from_dictionary(dictionary: dict) → EmvDataItem[source]
property tag: str | None
EMV tag

Type: str

to_dictionary() → dict[source]
property value: str | None
EMV value encoded in base64

Type: str

class worldline.acquiring.sdk.v1.domain.geo_coordinates.GeoCoordinates[source]

Bases: DataObject

__annotations__ = {'_GeoCoordinates__latitude': typing.Optional[float], '_GeoCoordinates__longitude': typing.Optional[float]}
from_dictionary(dictionary: dict) → GeoCoordinates[source]
property latitude: float | None
Latitude of the service location

Type: float

property longitude: float | None
Longitude of the service location

Type: float

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.get_dcc_rate_request.GetDccRateRequest[source]

Bases: DataObject

__annotations__ = {'_GetDccRateRequest__card_payment_data': typing.Optional[worldline.acquiring.sdk.v1.domain.card_data_for_dcc.CardDataForDcc], '_GetDccRateRequest__operation_id': typing.Optional[str], '_GetDccRateRequest__original_payment_date': typing.Optional[datetime.date], '_GetDccRateRequest__point_of_sale_data': typing.Optional[worldline.acquiring.sdk.v1.domain.point_of_sale_data_for_dcc.PointOfSaleDataForDcc], '_GetDccRateRequest__rate_reference_id': typing.Optional[str], '_GetDccRateRequest__target_currency': typing.Optional[str], '_GetDccRateRequest__transaction': typing.Optional[worldline.acquiring.sdk.v1.domain.transaction_data_for_dcc.TransactionDataForDcc]}
property card_payment_data: CardDataForDcc | None

Type: worldline.acquiring.sdk.v1.domain.card_data_for_dcc.CardDataForDcc

from_dictionary(dictionary: dict) → GetDccRateRequest[source]
property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property original_payment_date: date | None
The date of the original payment. Our system will try to return the original rate associated with the provided originalPaymentDate, but it may not always be possible to retrieve the exact original rate. If possible you should use rateReferenceId instead.

Type: date

property point_of_sale_data: PointOfSaleDataForDcc | None

Type: worldline.acquiring.sdk.v1.domain.point_of_sale_data_for_dcc.PointOfSaleDataForDcc

property rate_reference_id: str | None
The reference of a previously used rate
This can be used in case of any follow-up action for which you want to reference the original rate. Our system will try to return the original rate associated with the provided rateReferenceId.

Alternatively you can provide originalPaymentDate to reference the date of the original payment. Our system will try to return the original rate associated with the provided originalPaymentDate, but it may not always be possible to retrieve the exact original rate. If possible you should use rateReferenceId instead.

Type: str

property target_currency: str | None
The currency to convert to

Type: str

to_dictionary() → dict[source]
property transaction: TransactionDataForDcc | None

Type: worldline.acquiring.sdk.v1.domain.transaction_data_for_dcc.TransactionDataForDcc

class worldline.acquiring.sdk.v1.domain.get_dcc_rate_response.GetDccRateResponse[source]

Bases: DataObject

__annotations__ = {'_GetDccRateResponse__disclaimer_display': typing.Optional[str], '_GetDccRateResponse__disclaimer_receipt': typing.Optional[str], '_GetDccRateResponse__proposal': typing.Optional[worldline.acquiring.sdk.v1.domain.dcc_proposal.DccProposal], '_GetDccRateResponse__result': typing.Optional[str]}
property disclaimer_display: str | None
The disclaimer display

Type: str

property disclaimer_receipt: str | None
The disclaimer receipt

Type: str

from_dictionary(dictionary: dict) → GetDccRateResponse[source]
property proposal: DccProposal | None

Type: worldline.acquiring.sdk.v1.domain.dcc_proposal.DccProposal

property result: str | None
The result of the operation

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.initial_card_on_file_data.InitialCardOnFileData[source]

Bases: DataObject

__annotations__ = {'_InitialCardOnFileData__future_use': typing.Optional[str], '_InitialCardOnFileData__transaction_type': typing.Optional[str]}
from_dictionary(dictionary: dict) → InitialCardOnFileData[source]
property future_use: str | None
Future use

Type: str

to_dictionary() → dict[source]
property transaction_type: str | None
Transaction type

Type: str

class worldline.acquiring.sdk.v1.domain.marketplace_data.MarketplaceData[source]

Bases: DataObject

__annotations__ = {'_MarketplaceData__retailer_country_code': typing.Optional[str], '_MarketplaceData__retailer_name': typing.Optional[str]}
from_dictionary(dictionary: dict) → MarketplaceData[source]
property retailer_country_code: str | None
Address country code, ISO 3166 international standard

Type: str

property retailer_name: str | None
Name of the retailer in the marketplace

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.merchant_data.MerchantData[source]

Bases: DataObject

__annotations__ = {'_MerchantData__address': typing.Optional[str], '_MerchantData__city': typing.Optional[str], '_MerchantData__country_code': typing.Optional[str], '_MerchantData__customer_service_data': typing.Optional[worldline.acquiring.sdk.v1.domain.customer_service_data.CustomerServiceData], '_MerchantData__merchant_category_code': typing.Optional[int], '_MerchantData__name': typing.Optional[str], '_MerchantData__payment_facilitator_id': typing.Optional[str], '_MerchantData__postal_code': typing.Optional[str], '_MerchantData__state_code': typing.Optional[str], '_MerchantData__sub_merchant_id': typing.Optional[str], '_MerchantData__tax_id': typing.Optional[str]}
property address: str | None
Street address

Type: str

property city: str | None
Address city

Type: str

property country_code: str | None
Address country code, ISO 3166 international standard

Type: str

property customer_service_data: CustomerServiceData | None
Customer Service Data

Type: worldline.acquiring.sdk.v1.domain.customer_service_data.CustomerServiceData

from_dictionary(dictionary: dict) → MerchantData[source]
property merchant_category_code: int | None
Merchant category code (MCC)

Type: int

property name: str | None
Merchant name

Type: str

property payment_facilitator_id: str | None
Payment Facilitator identifier as assigned by Worldline

Type: str

property postal_code: str | None
Address postal code

Type: str

property state_code: str | None
Address state code, only supplied if country is US or CA

Type: str

property sub_merchant_id: str | None
Sub-merchant identifier in the context of a Payment Facilitator.

Type: str

property tax_id: str | None
Applicable for Payment Facilitator submerchants located in France, Belgium or Luxembourg & having a valid national SIRET/Tax ID when using Bambora as the acquirer.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.merchant_id_item.MerchantIdItem[source]

Bases: DataObject

__annotations__ = {'_MerchantIdItem__acquirer_id': typing.Optional[str], '_MerchantIdItem__merchant_id': typing.Optional[str]}
property acquirer_id: str | None
The unique identifier of the acquirer.

Type: str

from_dictionary(dictionary: dict) → MerchantIdItem[source]
property merchant_id: str | None
The unique identifier of the merchant.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.merchant_root_id_item.MerchantRootIdItem[source]

Bases: DataObject

__annotations__ = {'_MerchantRootIdItem__acquirer_id': typing.Optional[str], '_MerchantRootIdItem__merchant_root_id': typing.Optional[str]}
property acquirer_id: str | None
The unique identifier of the acquirer.

Type: str

from_dictionary(dictionary: dict) → MerchantRootIdItem[source]
property merchant_root_id: str | None
The root identifier of the merchant, which is the same for all sub-merchants under the same parent company.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.merchant_scope.MerchantScope[source]

Bases: DataObject

__annotations__ = {'_MerchantScope__merchant_scope_type': typing.Optional[str], '__merchant_scope_type': 'Optional[str]'}
from_dictionary(dictionary: dict) → MerchantScope[source]
property merchant_scope_type: str
Possible values are: BY_ACQUIRER_IDS, BY_MERCHANT_ROOT_IDS, BY_MERCHANT_IDS.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.network_token_data.NetworkTokenData[source]

Bases: DataObject

__annotations__ = {'_NetworkTokenData__cryptogram': typing.Optional[str], '_NetworkTokenData__eci': typing.Optional[str]}
property cryptogram: str | None
Network token cryptogram

Type: str

property eci: str | None
Electronic Commerce Indicator
Value that indicates the level of authentication.
Contains different values depending on the brand.

Type: str

from_dictionary(dictionary: dict) → NetworkTokenData[source]
to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.online_pin_data.OnlinePinData[source]

Bases: DataObject

__annotations__ = {'_OnlinePinData__encrypted_pin_block': typing.Optional[str], '_OnlinePinData__pin_block_format': typing.Optional[int], '_OnlinePinData__pin_encryption_data': typing.Optional[worldline.acquiring.sdk.v1.domain.pin_encryption_data.PinEncryptionData]}
property encrypted_pin_block: str | None
Encrypted data containing a PIN

Type: str

from_dictionary(dictionary: dict) → OnlinePinData[source]
property pin_block_format: int | None
ISO 9564 based PIN block format.

Worldline acquiring only supports the following format:

  • 4 - ISO-4

Bambora acquiring supports the following formats:

  • 0 - ISO 9564-1 Format 0 (Standard PIN block format with PAN XOR, commonly used with 3DES / DUKPT).

  • 1 - ISO 9564-1 Format 1 (PIN block with transaction sequence/random number).

  • 2 - ISO 9564-1 Format 2 (Primarily used for offline/smart cards).

  • 3 - ISO 9564-1 Format 3 (Similar to Format 0 with random fill digits).

  • 4 - ISO 9564-1 Format 4 (AES-256 encrypted PIN block format, required for modern Online PIN / Tap on Mobile CVM solutions).

Type: int

property pin_encryption_data: PinEncryptionData | None
PIN encryption details used for the encryptedPinBlock.

The following variants are supported:

  • AES_UKPT - Used in combination with Worldline acquirers

  • DUKPT - Used in combination with the Bambora acquirer

  • ZPK - Zone PIN Key, used in combination with the Bambora acquirer

Type: worldline.acquiring.sdk.v1.domain.pin_encryption_data.PinEncryptionData

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.original_transaction_data.OriginalTransactionData[source]

Bases: DataObject

__annotations__ = {'_OriginalTransactionData__cardholder_verification_method': typing.Optional[str], '_OriginalTransactionData__local_transaction_date_time': typing.Optional[str], '_OriginalTransactionData__payment_category': typing.Optional[str], '_OriginalTransactionData__payment_method_data': typing.Optional[worldline.acquiring.sdk.v1.domain.payment_method_data.PaymentMethodData], '_OriginalTransactionData__point_of_sale_entry_mode': typing.Optional[str], '_OriginalTransactionData__scheme_processed_date_time': typing.Optional[str], '_OriginalTransactionData__settlement_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_OriginalTransactionData__transaction_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_OriginalTransactionData__transaction_references': typing.Optional[worldline.acquiring.sdk.v1.domain.transaction_references_dispute.TransactionReferencesDispute]}
property cardholder_verification_method: str | None
The cardholder verification method (CVM) used in the original transaction that led to the dispute.

Type: str

from_dictionary(dictionary: dict) → OriginalTransactionData[source]
property local_transaction_date_time: str | None
The local date and time of the original transaction capture that resulted in the dispute, in ISO 8601 format, but without the timezone designator.

Type: str

property payment_category: str | None
The category of the payment used in the original transaction that led to the dispute.

Possible values are:

  • SALES (Different kind of payments with debits the recipient)

  • CREDIT_VOUCHER (Refund/Credit payment)

  • ORIGINAL_CREDIT (Transaction that credits the recipient in a payment transaction (money send, original credit) or cardholder funds transfer)

  • ATM (ATM Deposit)

  • ACCOUNT_FUNDING (Transaction that debits the sender in a payment transaction (money send, original credit))

  • CASH_ADVANCE (Cash advance payment)

Type: str

property payment_method_data: PaymentMethodData | None
The payment method used in the original transaction that led to the dispute.

Type: worldline.acquiring.sdk.v1.domain.payment_method_data.PaymentMethodData

property point_of_sale_entry_mode: str | None
The point of sale (POS) entry mode used in the original transaction that led to the dispute.

Non-exclusive list of possible values:

  • Unknown

  • Track1

  • Track2

  • Track3

  • Chip

  • Manual

  • Contactless-EMV

  • Contactless-Magstripe

  • Account ID

  • EMV fallback

  • Server or Wallet

  • QRC Code TAGC

  • CredentialOnFile

  • URL-intent

Type: str

property scheme_processed_date_time: str | None
The date and time when the dispute was processed by the card scheme, in ISO 8601 format, but without the timezone designator.

Type: str

property settlement_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

to_dictionary() → dict[source]
property transaction_amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

property transaction_references: TransactionReferencesDispute | None
A full set of references related to the original transaction that led to the dispute.

Type: worldline.acquiring.sdk.v1.domain.transaction_references_dispute.TransactionReferencesDispute

class worldline.acquiring.sdk.v1.domain.original_transaction_references.OriginalTransactionReferences[source]

Bases: DataObject

__annotations__ = {'_OriginalTransactionReferences__original_scheme_transaction_id': typing.Optional[str], '_OriginalTransactionReferences__original_scheme_transaction_link_id': typing.Optional[str]}
from_dictionary(dictionary: dict) → OriginalTransactionReferences[source]
property original_scheme_transaction_id: str | None
ID assigned by the scheme to identify a transaction through its whole lifecycle.

Type: str

A unique transaction identifier generated by Mastercard to provide consistent linking of related transaction activity throughout the transaction lifecycle.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.original_transaction_summary_data.OriginalTransactionSummaryData[source]

Bases: DataObject

__annotations__ = {'_OriginalTransactionSummaryData__cardholder_verification_method': typing.Optional[str], '_OriginalTransactionSummaryData__payment_category': typing.Optional[str], '_OriginalTransactionSummaryData__payment_method_data': typing.Optional[worldline.acquiring.sdk.v1.domain.payment_method_data_base.PaymentMethodDataBase], '_OriginalTransactionSummaryData__point_of_sale_entry_mode': typing.Optional[str], '_OriginalTransactionSummaryData__transaction_references': typing.Optional[worldline.acquiring.sdk.v1.domain.transaction_references_base.TransactionReferencesBase]}
property cardholder_verification_method: str | None
The cardholder verification method (CVM) used in the original transaction that led to the dispute.

Type: str

from_dictionary(dictionary: dict) → OriginalTransactionSummaryData[source]
property payment_category: str | None
The category of the payment used in the original transaction that led to the dispute.

Possible values are:

  • SALES (Different kind of payments with debits the recipient)

  • CREDIT_VOUCHER (Refund/Credit payment)

  • ORIGINAL_CREDIT (Transaction that credits the recipient in a payment transaction (money send, original credit) or cardholder funds transfer)

  • ATM (ATM Deposit)

  • ACCOUNT_FUNDING (Transaction that debits the sender in a payment transaction (money send, original credit))

  • CASH_ADVANCE (Cash advance payment)

Type: str

property payment_method_data: PaymentMethodDataBase | None
The payment method used in the original transaction that led to the dispute.

Type: worldline.acquiring.sdk.v1.domain.payment_method_data_base.PaymentMethodDataBase

property point_of_sale_entry_mode: str | None
The point of sale (POS) entry mode used in the original transaction that led to the dispute.

Non-exclusive list of possible values:

  • Unknown

  • Track1

  • Track2

  • Track3

  • Chip

  • Manual

  • Contactless-EMV

  • Contactless-Magstripe

  • Account ID

  • EMV fallback

  • Server or Wallet

  • QRC Code TAGC

  • CredentialOnFile

  • URL-intent

Type: str

to_dictionary() → dict[source]
property transaction_references: TransactionReferencesBase | None
A subset of references related to the original transaction that led to the dispute. The full list is returned by the Retrieve Dispute endpoint.

Type: worldline.acquiring.sdk.v1.domain.transaction_references_base.TransactionReferencesBase

class worldline.acquiring.sdk.v1.domain.pagination_request.PaginationRequest[source]

Bases: DataObject

__annotations__ = {'_PaginationRequest__from_index': typing.Optional[int], '_PaginationRequest__page_size': typing.Optional[int], '_PaginationRequest__search_id': typing.Optional[str]}
from_dictionary(dictionary: dict) → PaginationRequest[source]
property from_index: int | None
The index of the first item in the current page of search results.

Type: int

property page_size: int | None
The number of items to be included in a page of search results.

Type: int

property search_id: str | None
A unique identifier for a search results.
It’s used for pagination of search results and is generated by us.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.pagination_response.PaginationResponse[source]

Bases: DataObject

__annotations__ = {'_PaginationResponse__last_index': typing.Optional[int], '_PaginationResponse__search_id': typing.Optional[str], '_PaginationResponse__total_count': typing.Optional[int]}
from_dictionary(dictionary: dict) → PaginationResponse[source]
property last_index: int | None
The index of the last item in the current page of search results.

Type: int

property search_id: str | None
A unique identifier for a search results.
It’s used for pagination of search results and is generated by us.

Type: str

to_dictionary() → dict[source]
property total_count: int | None
The total number of items matching the search criteria.

Type: int

class worldline.acquiring.sdk.v1.domain.payment_method_data.PaymentMethodData[source]

Bases: PaymentMethodDataBase

__annotations__ = {'_PaymentMethodData__issuing_country_code': typing.Optional[str]}
from_dictionary(dictionary: dict) → PaymentMethodData[source]
property issuing_country_code: str | None
Address country code, ISO 3166 international standard

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.payment_method_data_base.PaymentMethodDataBase[source]

Bases: DataObject

__annotations__ = {'_PaymentMethodDataBase__masked_identifier': typing.Optional[str], '_PaymentMethodDataBase__scheme': typing.Optional[str], '_PaymentMethodDataBase__scheme_brand': typing.Optional[str], '__masked_identifier': 'Optional[str]', '__scheme': 'Optional[str]', '__scheme_brand': 'Optional[str]'}
from_dictionary(dictionary: dict) → PaymentMethodDataBase[source]
property masked_identifier: str | None
The masked identifier of the card used in the original transaction that led to the dispute. The masked identifier typically includes the first six and last four digits of the card number, with the middle digits replaced by asterisks or other masking characters. Different masking patterns are used for card and non-card payment methods.

  • Card: 717171*******1234

  • Non-Card: DE89****4567

  • Non-Card: j***@email.com

Type: str

property scheme: str | None
The card scheme used in the original transaction that led to the dispute.

Common values:

  • MASTERCARD (Mastercard)

  • VISA (Visa)

  • JCB (Japan Credit Bureau)

  • UNION_PAY (UnionPay International)

  • DINERS (Diners)

  • EUROPEAN_PAYMENTS_INITIATIVE (European Payment Initiative (Wero))

  • CARTE_BANCAIRES (Cartes Bancaires)

  • EFTPOS (EFTPOS (Electronic Funds Transfer at Point of Sale))

Support for new schemes may be introduced without notice. Clients should handle unknown values gracefully.

Type: str

property scheme_brand: str | None
The card scheme brand used in the original transaction that led to the dispute.

Possible values are:

  • MSI (Maestro Debit Card)

  • MCC (MasterCard Credit Card)

  • CIR (Cirrus Debit Card)

  • DMC (MasterCard Debit Card)

  • VISA (VISA Credit Card)

  • VPAY (V PAY)

  • PLUS (PLUS)

  • ELEC (Visa Electron)

  • JCB (JCB)

  • CUP (China Union Pay Credit Card)

  • DINER (DINERS credit card)

  • EFTPOS (EFTPOS, for Australia)

  • CB (Cartes Bancaires Domestic Scheme France)

  • WERO (European payment solution developed by EPI)

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.payment_references.PaymentReferences[source]

Bases: DataObject

__annotations__ = {'_PaymentReferences__dynamic_descriptor': typing.Optional[str], '_PaymentReferences__merchant_reference': typing.Optional[str]}
property dynamic_descriptor: str | None
Custom text provided by the merchant that is shown to the customer on their account statement, next to or instead of the registered merchant name. Support and maximum length depend on the payment method.

Note that there are restrictions on length and allowed characters that differ depending on the brand and scheme. If this string is too long it’s usually truncated.

Type: str

from_dictionary(dictionary: dict) → PaymentReferences[source]
property merchant_reference: str | None
Custom text provided by the merchant that appears on their own settlement reports and on the reimbursement notices from the acquirer.

It allows the merchant to reconcile their payments in our report files and in their disputes.

It is advised to submit a unique value per transaction.
The value is returned in the baseTrxType/addlMercData element of the MRX file.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.pin_encryption_data.PinEncryptionData[source]

Bases: DataObject

__annotations__ = {'_PinEncryptionData__pin_encryption_type': typing.Optional[str], '__pin_encryption_type': 'Optional[str]'}
from_dictionary(dictionary: dict) → PinEncryptionData[source]
property pin_encryption_type: str
Possible values are: AES_UKPT, DUKPT, ZPK.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.plain_card_data.PlainCardData[source]

Bases: DataObject

__annotations__ = {'_PlainCardData__card_number': typing.Optional[str], '_PlainCardData__card_security_code': typing.Optional[str], '_PlainCardData__card_sequence_number': typing.Optional[int], '_PlainCardData__expiry_date': typing.Optional[str]}
property card_number: str | None
Card number (PAN, network token or DPAN).

Type: str

property card_security_code: str | None
The security code indicated on the card
Based on the card brand, it can be 3 or 4 digits long
and have different names: CVV2, CVC2, CVN2, CID, CVC, CAV2, etc.

Type: str

property card_sequence_number: int | None
Card sequence number extracted from track2

  • usually known only for on-us cards, as the position of the sequence number is issuer specific

  • for requests without track2 the card sequence number is usually stored in the EMV tag 5F34

Type: int

property expiry_date: str | None
Card or token expiry date in format MMYYYY

Type: str

from_dictionary(dictionary: dict) → PlainCardData[source]
to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.point_of_sale_data.PointOfSaleData[source]

Bases: DataObject

__annotations__ = {'_PointOfSaleData__emv_data': typing.Optional[typing.List[worldline.acquiring.sdk.v1.domain.emv_data_item.EmvDataItem]], '_PointOfSaleData__is_response_to_pin_request': typing.Optional[bool], '_PointOfSaleData__is_retry_with_the_same_operation_id': typing.Optional[bool], '_PointOfSaleData__online_pin_data': typing.Optional[worldline.acquiring.sdk.v1.domain.online_pin_data.OnlinePinData], '_PointOfSaleData__track2_data': typing.Optional[str]}
property emv_data: List[EmvDataItem] | None
EMV data of the card as tag/value pairs.
It is needed when cardEntryMode is CHIP or CONTACTLESS.

Type: list[worldline.acquiring.sdk.v1.domain.emv_data_item.EmvDataItem]

from_dictionary(dictionary: dict) → PointOfSaleData[source]
property is_response_to_pin_request: bool | None
Indicate whether the request is made after a first one that resulted in a PIN request

Type: bool

property is_retry_with_the_same_operation_id: bool | None
Indicate whether the request is a retry with the same operation ID after a first request that resulted in a PIN request

Type: bool

property online_pin_data: OnlinePinData | None
In case of online PIN verification, send this object with the appropriate values.

Depending on the acquirer, different PIN encryption types are supported. Please check with your Worldline contact which encryption type is supported for your account.

Type: worldline.acquiring.sdk.v1.domain.online_pin_data.OnlinePinData

to_dictionary() → dict[source]
property track2_data: str | None
Track 2 data from the card
It is needed when cardEntryMode is MAGNETIC_STRIPE.

Type: str

class worldline.acquiring.sdk.v1.domain.point_of_sale_data_for_dcc.PointOfSaleDataForDcc[source]

Bases: DataObject

__annotations__ = {'_PointOfSaleDataForDcc__terminal_country_code': typing.Optional[str], '_PointOfSaleDataForDcc__terminal_id': typing.Optional[str]}
from_dictionary(dictionary: dict) → PointOfSaleDataForDcc[source]
property terminal_country_code: str | None
ISO 3166 Country code of the terminal

Type: str

property terminal_id: str | None
The terminal ID

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.point_of_sale_data_for_response.PointOfSaleDataForResponse[source]

Bases: DataObject

__annotations__ = {'_PointOfSaleDataForResponse__emv_data': typing.Optional[typing.List[worldline.acquiring.sdk.v1.domain.emv_data_item.EmvDataItem]], '_PointOfSaleDataForResponse__pan_last4_digits': typing.Optional[str], '_PointOfSaleDataForResponse__pin_retry_counter': typing.Optional[int]}
property emv_data: List[EmvDataItem] | None
EMV data of the card as tag/value pairs.

Type: list[worldline.acquiring.sdk.v1.domain.emv_data_item.EmvDataItem]

from_dictionary(dictionary: dict) → PointOfSaleDataForResponse[source]
property pan_last4_digits: str | None
Last 4 digits of the PAN

Type: str

property pin_retry_counter: int | None
Number of PIN retries

Type: int

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.rate_data.RateData[source]

Bases: DataObject

__annotations__ = {'_RateData__exchange_rate': typing.Optional[float], '_RateData__inverted_exchange_rate': typing.Optional[float], '_RateData__mark_up': typing.Optional[float], '_RateData__mark_up_basis': typing.Optional[str], '_RateData__quotation_date_time': typing.Optional[datetime.datetime]}
property exchange_rate: float | None
The exchange rate

Type: float

from_dictionary(dictionary: dict) → RateData[source]
property inverted_exchange_rate: float | None
The inverted exchange rate

Type: float

property mark_up: float | None
The mark up applied on the rate (in percentage).

Type: float

property mark_up_basis: str | None
The source of the rate the markup is based upon. If the cardholder and the merchant are based in Europe, the mark up is calculated based on the rates provided by the European Central Bank.

Type: str

property quotation_date_time: datetime | None
The date and time of the quotation

Type: datetime

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.search_dispute_entries_request.SearchDisputeEntriesRequest[source]

Bases: DataObject

__annotations__ = {'_SearchDisputeEntriesRequest__dispute_id': typing.Optional[str], '_SearchDisputeEntriesRequest__entry_categories': typing.Optional[typing.List[str]], '_SearchDisputeEntriesRequest__entry_date_time': typing.Optional[worldline.acquiring.sdk.v1.domain.date_time_range.DateTimeRange], '_SearchDisputeEntriesRequest__entry_id': typing.Optional[str], '_SearchDisputeEntriesRequest__entry_types': typing.Optional[typing.List[str]], '_SearchDisputeEntriesRequest__include_dispute_summary': typing.Optional[bool], '_SearchDisputeEntriesRequest__merchant_scope': typing.Optional[worldline.acquiring.sdk.v1.domain.merchant_scope.MerchantScope], '_SearchDisputeEntriesRequest__pagination': typing.Optional[worldline.acquiring.sdk.v1.domain.pagination_request.PaginationRequest], '_SearchDisputeEntriesRequest__sort_order': typing.Optional[str]}
property dispute_id: str | None
The unique identifier for a dispute.

Type: str

property entry_categories: List[str] | None

Type: list[str]

property entry_date_time: DateTimeRange | None
A range of date time values, used to select disputes that have a date time field that falls within this range.

NOTE: You can set either one or both of the lower and greater than properties to filter the results.

Type: worldline.acquiring.sdk.v1.domain.date_time_range.DateTimeRange

property entry_id: str | None
The unique identifier for an dispute entry.

Type: str

property entry_types: List[str] | None

Type: list[str]

from_dictionary(dictionary: dict) → SearchDisputeEntriesRequest[source]
property include_dispute_summary: bool | None
If true, the summary of the dispute case will be included in the response for dispute entries search. The dispute case summary includes key information about the dispute case such as the current status, the reason for the dispute and the amount of the disputed transaction. This can be useful to provide context about the dispute case when searching for specific dispute entries.
False by default.

Type: bool

property merchant_scope: MerchantScope | None
A set of fields to specify the scope of the search for disputes related to a specific merchant or set of merchants. The following options are available:

  • Search for disputes related to specific acquirers, by providing the acquirerIds field.

  • Search for disputes related to specific merchant groups, by providing the merchantRootIds field.

  • Search for disputes related to specific merchants, by providing the merchantIds field.

If no merchant scope is provided, disputes for all merchants that the API user has access to will be returned (that also match the other provided search criteria, if any).

Type: worldline.acquiring.sdk.v1.domain.merchant_scope.MerchantScope

property pagination: PaginationRequest | None
Pagination details for paginated responses.

First request: Omit searchId, set fromIndex``=0, ``pageSize``=20 Subsequent requests: Use ``searchId from previous response to maintain query context.

Note: searchId expires after 24 hours. If you should perform your original search request again.

Type: worldline.acquiring.sdk.v1.domain.pagination_request.PaginationRequest

property sort_order: str | None
The order in which to sort the dispute entries in the response. Can be either ascending (ASC) or descending (DESC). The sorting is done based on the entryDateTime field of the dispute entries, so when the sort order is ascending, the oldest entry is returned first and the newest entry is returned last. By default, the dispute entries are sorted in descending order.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.search_disputes_request.SearchDisputesRequest[source]

Bases: DataObject

__annotations__ = {'_SearchDisputesRequest__acquirer_dispute_reference': typing.Optional[str], '_SearchDisputesRequest__acquirer_reference_number': typing.Optional[str], '_SearchDisputesRequest__closed_date_time': typing.Optional[worldline.acquiring.sdk.v1.domain.date_time_range.DateTimeRange], '_SearchDisputesRequest__dispute_id': typing.Optional[str], '_SearchDisputesRequest__dispute_stages': typing.Optional[typing.List[str]], '_SearchDisputesRequest__dispute_status_categories': typing.Optional[typing.List[str]], '_SearchDisputesRequest__is_open': typing.Optional[bool], '_SearchDisputesRequest__last_status_changed_date_time': typing.Optional[worldline.acquiring.sdk.v1.domain.date_time_range.DateTimeRange], '_SearchDisputesRequest__merchant_reference': typing.Optional[str], '_SearchDisputesRequest__merchant_scope': typing.Optional[worldline.acquiring.sdk.v1.domain.merchant_scope.MerchantScope], '_SearchDisputesRequest__opened_date_time': typing.Optional[worldline.acquiring.sdk.v1.domain.date_time_range.DateTimeRange], '_SearchDisputesRequest__pagination': typing.Optional[worldline.acquiring.sdk.v1.domain.pagination_request.PaginationRequest], '_SearchDisputesRequest__payment_id': typing.Optional[str], '_SearchDisputesRequest__response_due_date': typing.Optional[worldline.acquiring.sdk.v1.domain.date_range.DateRange], '_SearchDisputesRequest__schemes': typing.Optional[typing.List[str]], '_SearchDisputesRequest__sort_by': typing.Optional[str], '_SearchDisputesRequest__sort_order': typing.Optional[str], '_SearchDisputesRequest__unified_categories': typing.Optional[typing.List[str]]}
property acquirer_dispute_reference: str | None
The reference provided by the acquirer for the dispute.

Type: str

property acquirer_reference_number: str | None
Acquirer reference number (ARN) for transaction

Type: str

property closed_date_time: DateTimeRange | None
A range of date time values, used to select disputes that have a date time field that falls within this range.

NOTE: You can set either one or both of the lower and greater than properties to filter the results.

Type: worldline.acquiring.sdk.v1.domain.date_time_range.DateTimeRange

property dispute_id: str | None
The unique identifier for a dispute.

Type: str

property dispute_stages: List[str] | None

Type: list[str]

property dispute_status_categories: List[str] | None

Type: list[str]

from_dictionary(dictionary: dict) → SearchDisputesRequest[source]
property is_open: bool | None
Indicates whether the dispute is open or closed. An open dispute is a dispute that’s still in the process of being resolved, while a closed dispute is a dispute that has been resolved.

Type: bool

property last_status_changed_date_time: DateTimeRange | None
A range of date time values, used to select disputes that have a date time field that falls within this range.

NOTE: You can set either one or both of the lower and greater than properties to filter the results.

Type: worldline.acquiring.sdk.v1.domain.date_time_range.DateTimeRange

property merchant_reference: str | None
Custom text provided by the merchant that appears on their own settlement reports and on the reimbursement notices from the acquirer.

It allows the merchant to reconcile their payments in our report files and in their disputes.

It is advised to submit a unique value per transaction.
The value is returned in the baseTrxType/addlMercData element of the MRX file.

Type: str

property merchant_scope: MerchantScope | None
A set of fields to specify the scope of the search for disputes related to a specific merchant or set of merchants. The following options are available:

  • Search for disputes related to specific acquirers, by providing the acquirerIds field.

  • Search for disputes related to specific merchant groups, by providing the merchantRootIds field.

  • Search for disputes related to specific merchants, by providing the merchantIds field.

If no merchant scope is provided, disputes for all merchants that the API user has access to will be returned (that also match the other provided search criteria, if any).

Type: worldline.acquiring.sdk.v1.domain.merchant_scope.MerchantScope

property opened_date_time: DateTimeRange | None
A range of date time values, used to select disputes that have a date time field that falls within this range.

NOTE: You can set either one or both of the lower and greater than properties to filter the results.

Type: worldline.acquiring.sdk.v1.domain.date_time_range.DateTimeRange

property pagination: PaginationRequest | None
Pagination details for paginated responses.

First request: Omit searchId, set fromIndex``=0, ``pageSize``=20 Subsequent requests: Use ``searchId from previous response to maintain query context.

Note: searchId expires after 24 hours. If you should perform your original search request again.

Type: worldline.acquiring.sdk.v1.domain.pagination_request.PaginationRequest

property payment_id: str | None
The unique identifier for the original payment transaction that resulted in the dispute. Depending on the interface used for the original transaction different values are returned. If the original transaction was made through the Acquiring API, the paymentId from the original transaction is returned.

Type: str

property response_due_date: DateRange | None
A range of date values, used to select disputes that have a date field that falls within this range.

NOTE: You can set either one or both of the properties to filter the results.

Type: worldline.acquiring.sdk.v1.domain.date_range.DateRange

property schemes: List[str] | None

Type: list[str]

property sort_by: str | None
The field by which to sort the search results. This can be any of the date-time fields in the dispute resource, such as openedDateTime, closedDateTime, lastStatusChangedDateTime or responseDueDate.

Type: str

property sort_order: str | None
The order in which to sort the search results. Can be either ascending (ASC) or descending (DESC).

Type: str

to_dictionary() → dict[source]
property unified_categories: List[str] | None

Type: list[str]

class worldline.acquiring.sdk.v1.domain.search_disputes_response.SearchDisputesResponse[source]

Bases: DataObject

__annotations__ = {'_SearchDisputesResponse__disputes': typing.Optional[typing.List[worldline.acquiring.sdk.v1.domain.dispute_case.DisputeCase]], '_SearchDisputesResponse__pagination': typing.Optional[worldline.acquiring.sdk.v1.domain.pagination_response.PaginationResponse], '_SearchDisputesResponse__request_id': typing.Optional[str]}
property disputes: List[DisputeCase] | None
A list of dispute cases matching the provided search criteria. Each dispute case contains the full details of the dispute, but without the full history of entries for the dispute. These can be retrieved by setting the includeEntries parameter to true when using the Retrieve Dispute endpoint.

Type: list[worldline.acquiring.sdk.v1.domain.dispute_case.DisputeCase]

from_dictionary(dictionary: dict) → SearchDisputesResponse[source]
property pagination: PaginationResponse | None
Pagination details for paginated responses.

Type: worldline.acquiring.sdk.v1.domain.pagination_response.PaginationResponse

property request_id: str | None
The unique Worldline identifier for the request that resulted in this response.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.service_location_address.ServiceLocationAddress[source]

Bases: DataObject

__annotations__ = {'_ServiceLocationAddress__city': typing.Optional[str], '_ServiceLocationAddress__country_code': typing.Optional[str], '_ServiceLocationAddress__country_subdivision_code': typing.Optional[str], '_ServiceLocationAddress__postal_code': typing.Optional[str]}
property city: str | None
Address city

Type: str

property country_code: str | None
Address country code, ISO 3166 international standard

Type: str

property country_subdivision_code: str | None
Address country subdivision code, see list for details

Type: str

from_dictionary(dictionary: dict) → ServiceLocationAddress[source]
property postal_code: str | None
Address postal code

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.service_location_data.ServiceLocationData[source]

Bases: DataObject

__annotations__ = {'_ServiceLocationData__address': typing.Optional[worldline.acquiring.sdk.v1.domain.service_location_address.ServiceLocationAddress], '_ServiceLocationData__geo_coordinates': typing.Optional[worldline.acquiring.sdk.v1.domain.geo_coordinates.GeoCoordinates]}
property address: ServiceLocationAddress | None
Address where the cardholder received the service

Type: worldline.acquiring.sdk.v1.domain.service_location_address.ServiceLocationAddress

from_dictionary(dictionary: dict) → ServiceLocationData[source]
property geo_coordinates: GeoCoordinates | None
Geographical coordinates where the cardholder received the service. Geographical coordinates in decimal degree (DD) format Latitude,Longitude where Latitude and Longitude are floating point numbers with the unit degree. Integer and decimal digits are separated by a dot. East and north are indicated by positive numbers whereas west and south have negative ones.

Type: worldline.acquiring.sdk.v1.domain.geo_coordinates.GeoCoordinates

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.signed_amount_data.SignedAmountData[source]

Bases: DataObject

__annotations__ = {'_SignedAmountData__amount': typing.Optional[int], '_SignedAmountData__currency_code': typing.Optional[str], '_SignedAmountData__debit_credit_indicator': typing.Optional[str], '_SignedAmountData__number_of_decimals': typing.Optional[int]}
property amount: int | None
Amount of transaction formatted according to card scheme specifications. E.g. 100 for 1.00 EUR.

Type: int

property currency_code: str | None
Alpha-numeric ISO 4217 currency code for transaction, e.g. EUR

Type: str

property debit_credit_indicator: str | None
Indicates whether the dispute is for a debit or credit transaction.
Possible values are:

  • DEBIT (The merchant receives funds)

  • CREDIT (The merchant loses funds)

Type: str

from_dictionary(dictionary: dict) → SignedAmountData[source]
property number_of_decimals: int | None
Number of decimals in the amount

Type: int

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.sub_operation.SubOperation[source]

Bases: DataObject

__annotations__ = {'_SubOperation__amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_SubOperation__authorization_code': typing.Optional[str], '_SubOperation__operation_id': typing.Optional[str], '_SubOperation__operation_timestamp': typing.Optional[datetime.datetime], '_SubOperation__operation_type': typing.Optional[str], '_SubOperation__response_code': typing.Optional[str], '_SubOperation__response_code_category': typing.Optional[str], '_SubOperation__response_code_description': typing.Optional[str]}
property amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

property authorization_code: str | None
Authorization approval code

Type: str

from_dictionary(dictionary: dict) → SubOperation[source]
property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property operation_timestamp: datetime | None
Timestamp of the operation in ISO 8601 format (YYYY-MM-DDThh:mm:ss+TZD)
It can be expressed in merchant time zone (ex: 2023-10-10T08:00+02:00) or in UTC (ex: 2023-10-10T08:00Z) yyyy-MM-ddTHH:mm:ssZ

Type: datetime

property operation_type: str | None
The kind of operation.
Possible values are:

  • AUTHORIZATION

  • CAPTURE

  • REFUND

  • INCREMENT

  • AUTHORIZATION_REVERSAL

Type: str

property response_code: str | None
Numeric response code, e.g. 0, 5

Type: str

property response_code_category: str | None
Category of response code.
Possible values are:

  • APPROVED

  • PARTIALLY_APPROVED

  • DECLINED

Type: str

property response_code_description: str | None
Description of the response code

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.sub_operation_for_refund.SubOperationForRefund[source]

Bases: DataObject

__annotations__ = {'_SubOperationForRefund__amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_SubOperationForRefund__operation_id': typing.Optional[str], '_SubOperationForRefund__operation_timestamp': typing.Optional[datetime.datetime], '_SubOperationForRefund__operation_type': typing.Optional[str], '_SubOperationForRefund__response_code': typing.Optional[str], '_SubOperationForRefund__response_code_category': typing.Optional[str], '_SubOperationForRefund__response_code_description': typing.Optional[str]}
property amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

from_dictionary(dictionary: dict) → SubOperationForRefund[source]
property operation_id: str | None
A globally unique identifier of the operation, generated by you.
We advise you to submit a UUID or an identifier composed of an arbitrary string and a UUID/URL-safe Base64 UUID (RFC 4648 §5).
It’s used to detect duplicate requests or to reference an operation in technical reversals.

Type: str

property operation_timestamp: datetime | None
Timestamp of the operation in ISO 8601 format (YYYY-MM-DDThh:mm:ss+TZD)
It can be expressed in merchant time zone (ex: 2023-10-10T08:00+02:00) or in UTC (ex: 2023-10-10T08:00Z) yyyy-MM-ddTHH:mm:ssZ

Type: datetime

property operation_type: str | None
The kind of operation
Possible values are:

  • AUTHORIZATION

  • CAPTURE

  • AUTHORIZATION_REVERSAL

Type: str

property response_code: str | None
Numeric response code, e.g. 0, 5

Type: str

property response_code_category: str | None
Category of response code.
Possible values are:

  • APPROVED

  • PARTIALLY_APPROVED

  • DECLINED

Type: str

property response_code_description: str | None
Description of the response code

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.submit_evidence_request.SubmitEvidenceRequest[source]

Bases: DataObject

__annotations__ = {'_SubmitEvidenceRequest__document_ids': typing.Optional[typing.List[worldline.acquiring.sdk.v1.domain.dispute_document_id_item.DisputeDocumentIdItem]], '_SubmitEvidenceRequest__elaboration': typing.Optional[str], '_SubmitEvidenceRequest__include_entries': typing.Optional[bool], '_SubmitEvidenceRequest__partial_amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_SubmitEvidenceRequest__user_id': typing.Optional[str]}
property document_ids: List[DisputeDocumentIdItem] | None

Type: list[worldline.acquiring.sdk.v1.domain.dispute_document_id_item.DisputeDocumentIdItem]

property elaboration: str | None
The long message text of the dispute entry, if applicable. This is typically used for communication entries to provide the content of the message sent by the acquirer to the merchant or vice versa. This field can contain a more detailed message than the messageText property.

Type: str

from_dictionary(dictionary: dict) → SubmitEvidenceRequest[source]
property include_entries: bool | None
If true, the response will include the full history of dispute entries related to the dispute. False by default.

Type: bool

property partial_amount: AmountData | None
Optional: Challenge only a partial amount of the dispute. By providing this value, you accept automatic liability for the remaining disputed amount.

Rules:

  • Must be greater than 0

  • Must not exceed originalDisputeAmount

  • All submitted evidence will be applied only to defending this partial amount

Example: If dispute is EUR 100 and partialAmount is EUR 30, you’re defending EUR 30 and accepting liability for EUR 70.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

to_dictionary() → dict[source]
property user_id: str | None
The unique identifier of the user that triggered the dispute entry, if applicable.

Type: str

class worldline.acquiring.sdk.v1.domain.subsequent_card_on_file_data.SubsequentCardOnFileData[source]

Bases: DataObject

__annotations__ = {'_SubsequentCardOnFileData__card_on_file_initiator': typing.Optional[str], '_SubsequentCardOnFileData__initial_scheme_transaction_id': typing.Optional[str], '_SubsequentCardOnFileData__initial_scheme_transaction_link_id': typing.Optional[str], '_SubsequentCardOnFileData__transaction_type': typing.Optional[str]}
property card_on_file_initiator: str | None
Card on file initiator

Type: str

from_dictionary(dictionary: dict) → SubsequentCardOnFileData[source]
property initial_scheme_transaction_id: str | None
ID assigned by the scheme to identify a transaction through its whole lifecycle.

Type: str

A unique transaction identifier generated by Mastercard to provide consistent linking of related transaction activity throughout the transaction lifecycle.

Type: str

to_dictionary() → dict[source]
property transaction_type: str | None
Transaction type

Type: str

class worldline.acquiring.sdk.v1.domain.terminal_data.TerminalData[source]

Bases: DataObject

__annotations__ = {'_TerminalData__allow_single_tap': typing.Optional[bool], '_TerminalData__card_reading_capabilities': typing.Optional[typing.List[str]], '_TerminalData__cardholder_activated_terminal_level': typing.Optional[str], '_TerminalData__is_attended_terminal': typing.Optional[bool], '_TerminalData__is_offline_approved': typing.Optional[bool], '_TerminalData__mpos_device': typing.Optional[str], '_TerminalData__offline_authorization_response_code': typing.Optional[str], '_TerminalData__pin_entry_capability': typing.Optional[str], '_TerminalData__terminal_id': typing.Optional[str], '_TerminalData__terminal_location': typing.Optional[str]}
property allow_single_tap: bool | None
Indicate whether the terminal allow one single tap for a contactless transaction followed by a PIN entry if the contactless transaction is refused

Type: bool

property card_reading_capabilities: List[str] | None
Card reading capabilities of the terminal.

Type: list[str]

property cardholder_activated_terminal_level: str | None
Level of security for a terminal activated with the use of a card (Cardholder Activated Terminal)

Type: str

from_dictionary(dictionary: dict) → TerminalData[source]
property is_attended_terminal: bool | None
Indicate whether the terminal is attended or not

Type: bool

property is_offline_approved: bool | None
Indicate whether the transaction is approved offline by the terminal

Type: bool

property mpos_device: str | None
The type of device (mobile POS) used by the merchant as the terminal for accepting mPOS. Possible values are:

  • MPOS_TERMINAL_WITH_PCI_DONGLE - Merchant uses a POS terminal with a PCI dongle

  • COMMERCIAL_OFF_THE_SHELF - Commercial off-the-shelf device

Type: str

property offline_authorization_response_code: str | None
Offline authorization response code generated by the terminal. Example values:

  • Y1 - Offline approved

  • Z1 - Offline declined

  • Y3 - Unable to go online (offline approved)

  • Z3 - Unable to go online (offline declined)

Type: str

property pin_entry_capability: str | None
The capabilities of the terminal to enter the PIN

  • UNKNOWN : Unspecified or unknown

  • PRESENT : Terminal has PIN entry capability

  • ABSENT : Terminal does not have PIN entry capability

  • MPOS_SOFTWARE_BASED_PIN : Mobile POS with PIN entry capability

  • NOT_OPERATIVE : Terminal has PIN entry capability but PIN pad is not currently operative

Type: str

property terminal_id: str | None
The identifier of the terminal

Type: str

property terminal_location: str | None
The location of the terminal

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.three_d_secure.ThreeDSecure[source]

Bases: DataObject

__annotations__ = {'_ThreeDSecure__authentication_value': typing.Optional[str], '_ThreeDSecure__directory_server_transaction_id': typing.Optional[str], '_ThreeDSecure__eci': typing.Optional[str], '_ThreeDSecure__three_d_secure_type': typing.Optional[str], '_ThreeDSecure__version': typing.Optional[str]}
property authentication_value: str | None
MasterCard AAV in original base64 encoding or Visa, DinersClub, UnionPay or JCB CAVV in either hexadecimal or base64 encoding

Type: str

property directory_server_transaction_id: str | None
3D Secure 2.x directory server transaction ID

Type: str

property eci: str | None
Electronic Commerce Indicator
Value that indicates the level of authentication.
Contains different values depending on the brand.

Type: str

from_dictionary(dictionary: dict) → ThreeDSecure[source]
property three_d_secure_type: str | None
3D Secure type used in the transaction

Type: str

to_dictionary() → dict[source]
property version: str | None
3D Secure version

Type: str

class worldline.acquiring.sdk.v1.domain.transaction_data_for_dcc.TransactionDataForDcc[source]

Bases: DataObject

__annotations__ = {'_TransactionDataForDcc__amount': typing.Optional[worldline.acquiring.sdk.v1.domain.amount_data.AmountData], '_TransactionDataForDcc__transaction_timestamp': typing.Optional[datetime.datetime], '_TransactionDataForDcc__transaction_type': typing.Optional[str]}
property amount: AmountData | None
Amount for the operation.

Type: worldline.acquiring.sdk.v1.domain.amount_data.AmountData

from_dictionary(dictionary: dict) → TransactionDataForDcc[source]
to_dictionary() → dict[source]
property transaction_timestamp: datetime | None
The date and time of the transaction

Type: datetime

property transaction_type: str | None
The transaction type

Type: str

class worldline.acquiring.sdk.v1.domain.transaction_references_base.TransactionReferencesBase[source]

Bases: DataObject

__annotations__ = {'_TransactionReferencesBase__acquirer_reference_number': typing.Optional[str], '_TransactionReferencesBase__merchant_reference': typing.Optional[str], '_TransactionReferencesBase__payment_id': typing.Optional[str]}
property acquirer_reference_number: str | None
Acquirer reference number (ARN) for transaction

Type: str

from_dictionary(dictionary: dict) → TransactionReferencesBase[source]
property merchant_reference: str | None
Custom text provided by the merchant that appears on their own settlement reports and on the reimbursement notices from the acquirer.

It allows the merchant to reconcile their payments in our report files and in their disputes.

It is advised to submit a unique value per transaction.
The value is returned in the baseTrxType/addlMercData element of the MRX file.

Type: str

property payment_id: str | None
The unique identifier for the original payment transaction that resulted in the dispute. Depending on the interface used for the original transaction different values are returned. If the original transaction was made through the Acquiring API, the paymentId from the original transaction is returned.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.transaction_references_dispute.TransactionReferencesDispute[source]

Bases: TransactionReferencesBase

__annotations__ = {'_TransactionReferencesDispute__acquirer_transaction_reference': typing.Optional[str], '_TransactionReferencesDispute__merchant_operation_id': typing.Optional[str], '_TransactionReferencesDispute__retrieval_reference_number': typing.Optional[str], '_TransactionReferencesDispute__scheme_transaction_id': typing.Optional[str], '_TransactionReferencesDispute__scheme_transaction_link_id': typing.Optional[str], '_TransactionReferencesDispute__terminal_id': typing.Optional[str], '_TransactionReferencesDispute__terminal_transaction_reference': typing.Optional[str]}
property acquirer_transaction_reference: str | None
The reference provided by the acquirer for the original transaction capture that resulted in the dispute. Only present if the acquirer provided a reference in the original transaction capture response.

Type: str

from_dictionary(dictionary: dict) → TransactionReferencesDispute[source]
property merchant_operation_id: str | None
The merchant’s unique identifier for the original transaction capture request that resulted in the dispute. Only present if the merchant provided an operationId in the original transaction capture request.

Type: str

property retrieval_reference_number: str | None
Retrieval reference number (RRN) for transaction

Type: str

property scheme_transaction_id: str | None
ID assigned by the scheme to identify a transaction through its whole lifecycle.

Type: str

A unique transaction identifier generated by Mastercard to provide consistent linking of related transaction activity throughout the transaction lifecycle.

Type: str

property terminal_id: str | None
The identifier of the terminal

Type: str

property terminal_transaction_reference: str | None
The reference of the transaction from the terminal used in the original transaction capture that resulted in the dispute.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.upload_document_response.UploadDocumentResponse[source]

Bases: DataObject

__annotations__ = {'_UploadDocumentResponse__document_id': typing.Optional[str], '_UploadDocumentResponse__request_id': typing.Optional[str]}
property document_id: str | None
The unique identifier of a document submitted as evidence for the dispute case, if applicable.

Type: str

from_dictionary(dictionary: dict) → UploadDocumentResponse[source]
property request_id: str | None
The unique Worldline identifier for the request that resulted in this response.

Type: str

to_dictionary() → dict[source]
class worldline.acquiring.sdk.v1.domain.zpk_pin_encryption_data.ZpkPinEncryptionData[source]

Bases: PinEncryptionData

PIN_ENCRYPTION_TYPE = 'ZPK'
__annotations__ = {'_ZpkPinEncryptionData__zone_pin_key_id': typing.Optional[str], '__zone_pin_key_id': 'Optional[str]'}
from_dictionary(dictionary: dict) → ZpkPinEncryptionData[source]
property pin_encryption_type: str
Possible values are: AES_UKPT, DUKPT, ZPK.

Type: str

to_dictionary() → dict[source]
property zone_pin_key_id: str | None
ID of the Zone PIN Key if ZPK encryption is used for the PIN block

Type: str

class worldline.acquiring.sdk.v1.ping.ping_client.PingClient(parent: ApiResource, path_context: Mapping[str, str] | None)[source]

Bases: ApiResource

Ping client. Thread-safe.

__annotations__ = {}
__init__(parent: ApiResource, path_context: Mapping[str, str] | None)[source]
Parameters:
ping(context: CallContext | None = None) → None[source]

Resource /services/v1/ping - Check API connection

See also https://docs.acquiring.worldline-solutions.com/api-reference#tag/Ping/operation/ping

Parameters:

context – worldline.acquiring.sdk.call_context.CallContext

Returns:

None

Raises:

  • ValidationException – if the request was not correct and couldn’t be processed (HTTP status code 400)

  • AuthorizationException – if the request was not allowed (HTTP status code 403)

  • ReferenceException – if an object was attempted to be referenced that doesn’t exist or has been removed, or there was a conflict (HTTP status code 404, 409 or 410)

  • PlatformException – if something went wrong at the Worldline Acquiring platform, the Worldline Acquiring platform was unable to process a message from a downstream partner/acquirer, or the service that you’re trying to reach is temporary unavailable (HTTP status code 500, 502 or 503)

  • ApiException – if the Worldline Acquiring platform returned any other error

Indices and tables