payfurl 1.0.0__py3-none-any.whl

payfurl/__init__.py

@@ -0,0 +1,35 @@
+"""payFURL's Python SDK: the public REST API with an account's secret key.
+
+from payfurl import PayfurlClient, Environment
+from payfurl.models import NewChargeToken
+
+client = PayfurlClient("sectest...-au", Environment.SANDBOX)
+charge = client.charges.create_with_token(NewChargeToken(amount=Decimal("20.00"), currency="AUD", token=token))
+"""
+
+from . import models, webhooks
+from ._client import Environment, PayfurlClient, __version__
+from .errors import (
+    APIConnectionError,
+    APIError,
+    APITimeoutError,
+    AuthenticationError,
+    ErrorCode,
+    NotFoundError,
+    PayfurlError,
+)
+
+__all__ = [
+    "APIConnectionError",
+    "APIError",
+    "APITimeoutError",
+    "AuthenticationError",
+    "Environment",
+    "ErrorCode",
+    "NotFoundError",
+    "PayfurlClient",
+    "PayfurlError",
+    "__version__",
+    "models",
+    "webhooks",
+]

payfurl/_client.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+import logging
+import time
+from datetime import UTC, date, datetime
+from decimal import Decimal
+from enum import Enum, StrEnum
+from importlib.metadata import version
+from types import TracebackType
+from typing import Any, Literal, TypeVar, cast
+
+import httpx
+from pydantic import BaseModel, TypeAdapter
+
+from . import resources
+from .errors import APIConnectionError, APIError, APITimeoutError, AuthenticationError, NotFoundError
+from .models import ApplicationVersion, RootStatus
+
+__version__ = version("payfurl")
+
+logger = logging.getLogger("payfurl")
+
+T = TypeVar("T")
+
+
+class Environment(StrEnum):
+    """Which payFURL API a client calls. The key's region (its last part, such as `-au`) picks the regional host."""
+
+    #: The API on this machine (https://localhost:5001). TLS isn't verified: it serves a development certificate.
+    LOCAL = "local"
+    DEVELOPMENT = "development"
+    SANDBOX = "sandbox"
+    PRODUCTION = "production"
+
+
+_HOSTS = {
+    Environment.LOCAL: "https://localhost:5001",
+    Environment.DEVELOPMENT: "https://develop-api{region}.payfurl.com",
+    Environment.SANDBOX: "https://sandbox-api{region}.payfurl.com",
+    Environment.PRODUCTION: "https://api{region}.payfurl.com",
+}
+_REGIONS = {"au"}
+
+
+def _base_url(environment: Environment, key: str) -> str:
+    # A key ends in its account's region: sectest...-au. A region without a host of its own uses the global one.
+    region = key.rsplit("-", 1)[1].lower() if "-" in key else ""
+    return _HOSTS[environment].format(region=f"-{region}" if region in _REGIONS else "")
+
+
+Auth = Literal["secret", "public"] | None
+
+
+class PayfurlClient:
+    """The payFURL API with one account's keys.
+
+        client = PayfurlClient("sectest...-au", Environment.SANDBOX)
+        charge = client.charges.create_with_token(NewChargeToken(amount=Decimal("20.00"), currency="AUD", token=token))
+
+    The secret key calls every endpoint. A public key (`public_key=`) is needed only by `request(auth="public")`;
+    `info.providers()` takes either. Make one client per account and reuse it: it keeps connections open. Close it
+    with `close()`, or use it as a context manager.
+
+    GETs are retried `max_retries` times after a connection error, a timeout or a retryable API error, waiting
+    `retry_delay` seconds and doubling the wait each time. Nothing else is retried: the API has no idempotency keys,
+    so a retried charge could charge twice.
+
+    `http_client` sends the requests in place of the client's own (for proxies or event hooks); its TLS settings are
+    used as they are. `timeout` applies to every request either way.
+    """
+
+    def __init__(
+        self,
+        secret_key: str | None,
+        environment: Environment | str,
+        *,
+        public_key: str | None = None,
+        base_url: str | None = None,
+        timeout: float = 60.0,
+        max_retries: int = 2,
+        retry_delay: float = 0.5,
+        http_client: httpx.Client | None = None,
+    ) -> None:
+        if not (secret_key or "").strip() and not (public_key or "").strip():
+            raise ValueError("A payFURL secret key or public key is needed")
+        try:
+            environment = Environment(str(environment).lower())
+        except ValueError:
+            names = ", ".join(e.value for e in Environment)
+            raise ValueError(f"Unknown payFURL environment {environment!r}: use {names}") from None
+        self.secret_key = secret_key or None
+        self.public_key = public_key or None
+        self.environment = environment
+        self.base_url = (base_url or _base_url(environment, self.secret_key or self.public_key or "")).rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max(0, max_retries)
+        self.retry_delay = retry_delay
+        self._owns_http = http_client is None
+        # TLS is verified unless the client is for the API on this machine, and never changed on a caller's client.
+        self._http = http_client or httpx.Client(verify=environment is not Environment.LOCAL)
+
+        self.batches = resources.Batches(self)
+        self.charges = resources.Charges(self)
+        self.customers = resources.Customers(self)
+        self.disputes = resources.Disputes(self)
+        self.info = resources.Info(self)
+        self.payment_links = resources.PaymentLinks(self)
+        self.payment_methods = resources.PaymentMethods(self)
+        self.providers = resources.Providers(self)
+        self.settlements = resources.Settlements(self)
+        self.subscriptions = resources.Subscriptions(self)
+        self.tokens = resources.Tokens(self)
+        self.transfers = resources.Transfers(self)
+        self.vaults = resources.Vaults(self)
+        self.webhook_subscriptions = resources.WebhookSubscriptions(self)
+
+    def root(self) -> RootStatus:
+        """`GET /`: whether the API is up. Needs no key."""
+        return self._call("GET", "/", RootStatus, auth=None)
+
+    def version(self) -> ApplicationVersion:
+        """`GET /version`: the API's version and region."""
+        return self._call("GET", "/version", ApplicationVersion, auth=None)
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Any = None,
+        params: dict[str, str] | None = None,
+        auth: Auth = "secret",
+        headers: dict[str, str] | None = None,
+    ) -> Any:
+        """Advanced: calls an endpoint the SDK has no method for, with the client's keys, TLS, retries and errors.
+
+        Returns the response's JSON, decoded as `json.loads` does (`None` for an empty body), and raises the same
+        errors as the other methods. `auth` picks the key header: `"secret"`, `"public"` (needs `public_key`) or
+        `None`. Prefer the typed methods: an endpoint called this way may change without notice.
+        """
+        response = self._send(method, path, json=json, params=params, auth=auth, headers=headers)
+        return response.json() if response.content.strip() else None
+
+    def close(self) -> None:
+        """Closes the client's connections. A caller's `http_client` is left open."""
+        if self._owns_http:
+            self._http.close()
+
+    def __enter__(self) -> PayfurlClient:
+        return self
+
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None
+    ) -> None:
+        self.close()
+
+    def _call(
+        self,
+        method: str,
+        path: str,
+        response_type: type[T],
+        *,
+        body: BaseModel | dict[str, Any] | None = None,
+        query: BaseModel | dict[str, Any] | None = None,
+        auth: Auth = "secret",
+        headers: dict[str, str] | None = None,
+    ) -> T:
+        if isinstance(body, BaseModel):
+            json: Any = body.model_dump(mode="json", by_alias=True, exclude_none=True)
+        else:
+            json = None if body is None else {k: _json_value(v) for k, v in body.items() if v is not None}
+        params = _query(query.model_dump(by_alias=True, exclude_none=True) if isinstance(query, BaseModel) else query)
+        response = self._send(method, path, json=json, params=params, auth=auth, headers=headers)
+        return cast(T, _adapter(response_type).validate_json(response.content))
+
+    def _send(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Any,
+        params: dict[str, str] | None,
+        auth: Auth,
+        headers: dict[str, str] | None,
+    ) -> httpx.Response:
+        method = method.upper()
+        sent = {"Accept": "application/json", "User-Agent": f"payfurl-python/{__version__}", **(headers or {})}
+        if auth is not None:
+            key = self.secret_key if auth == "secret" else self.public_key
+            if key is None:
+                raise ValueError(f"This client has no {auth} key")
+            sent["x-secretkey" if auth == "secret" else "x-publickey"] = key
+
+        # Only reads are retried: a second charge POST could charge twice.
+        retries = self.max_retries if method == "GET" else 0
+        attempt = 0
+        while True:
+            start = time.monotonic()
+            try:
+                try:
+                    response = self._http.request(
+                        method, self.base_url + path, json=json, params=params, headers=sent, timeout=self.timeout
+                    )
+                except httpx.TimeoutException as e:
+                    raise APITimeoutError(f"{method} {path} timed out after {self.timeout} s") from e
+                except httpx.TransportError as e:
+                    raise APIConnectionError(f"{method} {path} failed: {e}") from e
+                # Never the body or headers: they hold card numbers and keys.
+                logger.debug(
+                    "%s %s: HTTP %s in %.0f ms", method, path, response.status_code, (time.monotonic() - start) * 1000
+                )
+                if response.is_success:
+                    return response
+                raise _error(response)
+            except (APIConnectionError, APIError) as e:
+                if attempt >= retries or (isinstance(e, APIError) and not e.is_retryable):
+                    raise
+                logger.debug("%s %s: retrying after %s", method, path, e)
+                time.sleep(self.retry_delay * 2**attempt)
+                attempt += 1
+
+
+def _error(response: httpx.Response) -> APIError:
+    try:
+        body: Any = response.json()
+    except ValueError:
+        body = response.text.strip() or None
+    if isinstance(body, dict) and isinstance(body.get("message"), str):
+        message = body["message"]
+    elif isinstance(body, str) and body:
+        # Some endpoints answer with a plain message, and a proxy with HTML.
+        message = body[:500]
+    else:
+        message = f"HTTP {response.status_code} from the payFURL API"
+    status = response.status_code
+    cls = AuthenticationError if status in (401, 403) else NotFoundError if status == 404 else APIError
+    return cls(message, status_code=status, body=body)
+
+
+def _json_value(value: Any) -> Any:
+    if isinstance(value, Decimal):
+        return float(value)
+    if isinstance(value, Enum):
+        return value.value
+    return value
+
+
+def _query(values: dict[str, Any] | None) -> dict[str, str] | None:
+    """Query parameters as the API's model binding reads them; `None`s left out."""
+    if not values:
+        return None
+    query = {}
+    for name, value in values.items():
+        if value is None:
+            continue
+        if isinstance(value, bool):
+            query[name] = "true" if value else "false"
+        elif isinstance(value, Decimal):
+            query[name] = format(value, "f")  # never an exponent: 1E+2
+        elif isinstance(value, datetime):
+            # A naive datetime is local time, as datetime.astimezone() takes it.
+            query[name] = value.astimezone(UTC).isoformat().replace("+00:00", "Z")
+        elif isinstance(value, date):
+            query[name] = value.isoformat()
+        elif isinstance(value, Enum):
+            query[name] = str(value.value)
+        else:
+            query[name] = str(value)
+    return query
+
+
+_adapters: dict[Any, TypeAdapter[Any]] = {}
+
+
+def _adapter(response_type: Any) -> TypeAdapter[Any]:
+    if response_type not in _adapters:
+        _adapters[response_type] = TypeAdapter(response_type)
+    return _adapters[response_type]

payfurl/errors.py

@@ -0,0 +1,261 @@
+"""The exceptions the SDK raises. Catch `PayfurlError` for all of them."""
+
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import Any
+
+
+class PayfurlError(Exception):
+    """Every error the SDK raises."""
+
+
+class APIError(PayfurlError):
+    """The API answered with an error status: a decline, a validation error, a conflict, a server error.
+
+    The API's error body (services/api `Error`) is in `body`, and its fields are attributes. `error_code` is the
+    payFURL error code (https://docs.payfurl.com/errorcodes). `is_retryable` says whether the same request may
+    succeed later.
+    """
+
+    def __init__(self, message: str, *, status_code: int, body: Any = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.body = body
+        error = body if isinstance(body, dict) else {}
+        code = error.get("code")
+        self.error_code: int | None = code if isinstance(code, int) else None
+        retryable = error.get("isRetryable")
+        # A body that isn't the API's (a load balancer's 502, say): worth retrying only if the server failed.
+        self.is_retryable: bool = retryable if isinstance(retryable, bool) else status_code >= 500 or status_code == 429
+        self.type: str | None = error.get("type")
+        self.resource: str | None = error.get("resource")
+        self.details: dict[str, str] | None = error.get("details")
+        self.gateway_code: str | None = error.get("gatewayCode")
+        self.gateway_message: str | None = error.get("gatewayMessage")
+        self.charge_id: str | None = error.get("chargeId")
+        self.trace_id: str | None = error.get("traceId")
+
+    def __str__(self) -> str:
+        code = f", error code {self.error_code}" if self.error_code is not None else ""
+        return f"{self.message} (HTTP {self.status_code}{code})"
+
+
+class AuthenticationError(APIError):
+    """HTTP 401 or 403: the key is wrong, or can't call this endpoint (a public key, say)."""
+
+
+class NotFoundError(APIError):
+    """HTTP 404: no such charge, customer, ... on this account."""
+
+
+class APIConnectionError(PayfurlError):
+    """The request didn't get a response: DNS, connection refused, TLS, a dropped connection."""
+
+
+class APITimeoutError(APIConnectionError):
+    """The request took longer than the client's `timeout`."""
+
+
+class ErrorCode(IntEnum):
+    """The payFURL error codes, in `APIError.error_code`: `ErrorCode(exc.error_code)` names one.
+
+    https://docs.payfurl.com/errorcodes lists what each means. A code added to the API after this version of the SDK
+    is not a member: `ErrorCode(n)` raises `ValueError` for it, so compare `exc.error_code` with the members.
+    """
+
+    NO_ERROR = 0
+    UNKNOWN_ERROR = 1
+    INVALID_AMOUNT = 2
+    INVALID_AUTHORISE_DETAILS = 3
+    INVALID_CAPTURE_DETAILS = 4
+    INVALID_CARD_NUMBER = 5
+    INVALID_CCV = 6
+    INVALID_COUNTRY = 7
+    INVALID_COUNTRY_FOR_TRANSFER = 8
+    INVALID_EXPIRY_DATE = 9
+    INVALID_PAYMENT_DETAILS = 10
+    INVALID_PAYPAL_ACCOUNT = 11
+    INVALID_REFUND_DETAILS = 12
+    INVALID_VOID_DETAILS = 13
+    EXPIRED_CARD = 14
+    INSUFFICIENT_FUNDS = 15
+    LOCATION_NOT_SUPPORTED = 16
+    PAYPAL_BILLING_AGREEMENT_CANCELLED = 17
+    THREE_D_SECURE_FAILED = 18
+    ACCOUNT_EMAIL_UNCONFIRMED = 19
+    ACCOUNT_ERROR = 20
+    ACCOUNT_IS_LOCKED_OR_CLOSED = 21
+    ACCOUNT_NOT_AUTHORISED = 22
+    ACCOUNT_RESTRICTED = 23
+    AMOUNT_EXCEEDS_MAX_AMOUNT_FOR_PAY_TO_AGREEMENT = 24
+    AMOUNT_TOO_LARGE = 25
+    AUTHENTICATION_AUTHORIZATION_ERROR = 26
+    BILLING_POSTAL_CODE_NOT_SUPPORTED = 27
+    CURRENCY_COMPLIANCE_ISSUES_WITH_TRANSACTIONS = 28
+    CURRENCY_NOT_SUPPORTED = 29
+    DUPLICATE = 30
+    DUPLICATE_TRANSACTION = 31
+    FEATURE_UNAVAILABLE = 32
+    PAY_TO_AGREEMENT_IS_NOT_ACTIVE = 33
+    PROVIDER_SERVICE_ERROR = 34
+    RATE_LIMITING_APPLIED = 35
+    RECEIVER_ACCOUNT_LOCKED = 36
+    RETRY_LATER = 37
+    SENDER_ACCOUNT_ISSUE = 38
+    INVALID_PROVIDER_ID = 39
+    INVALID_AUTHENTICATION = 40
+    INVALID_ENVIRONMENT = 41
+    TOKENISE_CARD_ERROR = 42
+    TRANSACTION_ERROR = 43
+    NOT_SUPPORT_CHARGE = 44
+    UNABLE_TO_REFUND = 45
+    UNABLE_TO_CHARGE = 46
+    UNABLE_TO_CAPTURE = 47
+    UNABLE_TO_VOID = 48
+    UNABLE_TO_ADD_CUSTOMER = 49
+    NO_TRANSACTION_FOUND = 50
+    INVALID_OR_EXPIRED_TOKEN = 51
+    INVALID_CUSTOMER_ID = 52
+    INVALID_CHARGE = 53
+    INVALID_CHARGE_STATUS = 54
+    INVALID_CARD_LENGTH = 55
+    INVALID_PAYMENT_METHOD_ID = 56
+    INVALID_PAYMENT_METHOD = 57
+    INVALID_PAYMENT_TYPE = 58
+    INVALID_THREE_DS_SERVER_TRANS_ID = 59
+    INVALID_TRANSFER_AMOUNT = 60
+    INVALID_REFERENCE_ID = 61
+    INVALID_VAULT_ID = 62
+    NO_CARD_PROVIDERS_CONFIGURED = 63
+    CUSTOMER_HAS_NO_DEFAULT_PAYMENT_METHOD_ID = 64
+    NO_PROVIDER_FOUND = 65
+    NO_VAULT_ID_ASSOCIATED_WITH_THIS_PAYMENT_METHOD = 66
+    NO_TRANSFER_INFORMATION_PROVIDED = 67
+    TRANSFER_LARGER_THAN_ORIGINAL_CHARGE = 68
+    DUPLICATE_GROUP_REFERENCE = 69
+    DUPLICATE_TRANSFER_REFERENCE = 70
+    FEATURE_AUTHORISE_AND_CAPTURE_IS_NOT_SUPPORTED = 71
+    INVALID_CUSTOMER_ID_REMOVED = 72
+    INVALID_PAYMENT_METHOD_ID_REMOVED = 73
+    INVALID_AMOUNT_MUST_BE_POSITIVE = 74
+    FEATURE_VERIFY_PENDING_IS_NOT_SUPPORTED = 75
+    INVALID_AMOUNT_MAXIMUM_AVAILABLE_REFUND = 76
+    INVALID_CAPTURE_AMOUNT_PASSED = 77
+    FEATURE_PARTIAL_CAPTURE_IS_NOT_SUPPORTED_CAPTURE_AMOUNT = 78
+    AMOUNT_OUTSIDE_RANGE_FOR_MERCHANT = 79
+    GATEWAY_TIMEOUT = 80
+    INVALID_PAYMENT_INFORMATION = 81
+    CANNOT_PROVIDE_BOTH_EXPIRE_DATE_AND_EXPIRE_SECONDS = 82
+    INVALID_EXPIRE_DATE_OR_EXPIRE_SECONDS = 83
+    INVALID_CHARGE_ID = 84
+    CANNOT_PROVIDE_BOTH_VAULT_EXPIRE_DATE_AND_VAULT_EXPIRE_SECONDS = 85
+    INVALID_VAULT_EXPIRY_DATE = 86
+    INVALID_TOKEN_ID = 87
+    INVALID_TRANSFER_ID = 88
+    INVALID_NOTIFICATION_FORMAT = 89
+    VALIDATION_ERROR = 90
+    TOKEN_VERIFICATION_NOT_SUPPORTED = 91
+    INVALID_ADDRESS = 92
+    CARD_BLOCKED = 93
+    TIMEOUT = 94
+    VIS_IS_NOT_SUPPORTED = 95
+    THE_ORDER_INFORMATION_IS_INVALID = 96
+    METADATA_DOES_NOT_CONTAIN_REQUIRED_FIELDS = 97
+    FRAUD_IS_NOT_SUPPORTED = 98
+    CARD_IS_NOT_ENROLLED_FOR_VIS = 99
+    PROVIDER_NOT_SUPPORTED = 100
+    INVALID_BATCH = 101
+    INVALID_BATCH_DATA = 102
+    DIRECT_DEBIT_NOT_SUPPORTED = 103
+    INVALID_SUBSCRIPTION_ID = 104
+    NO_DATA_TO_UPDATE_THE_PAYMENT_METHOD = 105
+    PAYMENT_METHOD_MUST_BE_OF_TYPE_CARD = 106
+    UNABLE_TO_UPDATE_THE_PAYMENT_METHOD = 107
+    UNABLE_TO_UPDATE_SUBSCRIPTION = 108
+    UNABLE_TO_CREATE_WEBHOOK_SUBSCRIPTION = 109
+    UNABLE_TO_GET_WEBHOOK_SUBSCRIPTION = 110
+    UNABLE_TO_DELETE_WEBHOOK_SUBSCRIPTION = 111
+    BLOCKED_BY_FRAUD_RULES = 112
+    REQUIRE_3D_SECURE = 113
+    UNABLE_TO_CREATE_NETWORK_TOKEN = 114
+    UNABLE_TO_CREATE_PAYMENT_LINK = 115
+    INVALID_PAYMENT_LINK_ID = 116
+    INVALID_FALLBACK_PROVIDER_ID = 117
+    INVALID_DISPUTE_ID = 118
+    APPLE_PAY_UNKNOWN_PUBLIC_KEY_HASH = 119
+    APPLE_PAY_PLATFORM_MODE_UNSUPPORTED = 120
+    APPLE_PAY_TOKEN_VERIFICATION_FAILED = 121
+    APPLE_PAY_TOKEN_DECRYPTION_FAILED = 122
+    STOP_RECURRING_PAYMENTS = 123
+    REFER_TO_CARD_ISSUER = 901
+    REFER_TO_CARD_ISSUER_SPECIAL_CONDITIONS = 902
+    INVALID_MERCHANT = 903
+    PICK_UP_CARD = 904
+    DO_NOT_HONOR = 905
+    ERROR = 906
+    PICK_UP_CARD_SPECIAL_CONDITION = 907
+    HONOUR_WITH_IDENTIFICATION = 908
+    REQUEST_IN_PROGRESS = 909
+    APPROVED_FOR_PARTIAL_AMOUNT = 910
+    APPROVED_VIP = 911
+    INVALID_TRANSACTION = 912
+    ISSUER_INVALID_AMOUNT = 913
+    INVALID_CARD_NUMBER_NO_SUCH_NUMBER = 914
+    NO_SUCH_ISSUER = 915
+    APPROVED_UPDATE_TRACK3 = 916
+    CUSTOMER_CANCELLATION = 917
+    CUSTOMER_DISPUTE = 918
+    RE_ENTER_TRANSACTION = 919
+    INVALID_RESPONSE = 920
+    NO_ACTION_TAKEN = 921
+    SUSPECTED_MALFUNCTION = 922
+    UNACCEPTABLE_TRANSACTION_FEE = 923
+    FILE_UPDATE_NOT_SUPPORTED_BY_RECEIVER = 924
+    UNABLE_TO_LOCATE_RECORD_ON_FILE = 925
+    DUPLICATE_FILE_UPDATE_RECORD_OLD_RECORD_REPLACED = 926
+    FILE_UPDATE_FIELD_EDIT_ERROR = 927
+    FILE_UPDATE_FILE_LOCKED_OUT = 928
+    FILE_UPDATE_NOT_SUCCESSFUL_CONTACT_ACQUIRER = 929
+    FORMAT_ERROR = 930
+    BANK_NOT_SUPPORTED_BY_SWITCH = 931
+    COMPLETED_PARTIALLY = 932
+    EXPIRED_CARD_PICK_UP = 933
+    SUSPECTED_FRAUD_PICK_UP = 934
+    CARD_ACCEPTOR_CONTACT_ACQUIRER_PICK_UP = 935
+    RESTRICTED_CARD_PICK_UP = 936
+    CARD_ACCEPTOR_CALL_ACQUIRER_SECURITY_PICK_UP = 937
+    ALLOWABLE_PIN_TRIES_EXCEEDED = 938
+    NO_CREDIT_ACCOUNT = 939
+    REQUESTED_FUNCTION_NOT_SUPPORTED = 940
+    LOST_CARD_PICK_UP = 941
+    NO_UNIVERSAL_ACCOUNT = 942
+    STOLEN_CARD_PICK_UP = 943
+    NO_INVESTMENT_ACCOUNT = 944
+    ISSUER_INSUFFICIENT_FUNDS = 951
+    NO_CHECKING_ACCOUNT = 952
+    NO_SAVINGS_ACCOUNT = 953
+    ISSUER_EXPIRED_CARD = 954
+    INCORRECT_PERSONAL_IDENTIFICATION_NUMBER = 955
+    NO_CARD_RECORD = 956
+    TRANSACTION_NOT_PERMITTED_TO_CARDHOLDER = 957
+    TRANSACTION_NOT_PERMITTED_TO_TERMINAL = 958
+    SUSPECTED_FRAUD = 959
+    CARD_ACCEPTOR_CONTACT_ACQUIRER = 960
+    EXCEEDS_WITHDRAWAL_AMOUNT_LIMIT = 961
+    RESTRICTED_CARD = 962
+    SECURITY_VIOLATION = 963
+    ORIGINAL_AMOUNT_INCORRECT = 964
+    EXCEEDS_WITHDRAWAL_FREQUENCY_LIMIT = 965
+    CARD_ACCEPTOR_CALL_ACQUIRERS_SECURITY_DEPARTMENT = 966
+    HARD_CAPTURE_REQUIRES_CARD_PICK_UP_AT_ATM = 967
+    RESPONSE_RECEIVED_TOO_LATE = 968
+    ALLOWABLE_NUMBER_OF_PIN_TRIES_EXCEEDED = 975
+    CUTOFF_IS_IN_PROCESS = 990
+    ISSUER_OR_SWITCH_IS_INOPERATIVE = 991
+    FINANCIAL_INSTITUTION_OR_INTERMEDIATE_NETWORK_FACILITY_CANNOT_BE_FOUND_FOR_ROUTING = 992
+    TRANSACTION_CANNOT_BE_COMPLETED_VIOLATION_OF_LAW = 993
+    DUPLICATE_TRANSMISSION = 994
+    RECONCILE_ERROR = 995
+    SYSTEM_MALFUNCTION = 996