routex_api/

lib.rs

#[cfg(feature = "uniffi")]
use chrono::NaiveDate;
use chrono::Utc;
use heck::ToKebabCase;
#[cfg(feature = "uniffi")]
use isocountry::CountryCode;
use jsonwebtoken::dangerous::insecure_decode;
use jsonwebtoken::{EncodingKey, Header, decode_header, encode};
pub use routex_models::{
    AccountStatus, AccountType, Amount, ConnectionId, CredentialsModel, DialogContext,
    DialogOption, Image, InputType, PaymentErrorCode, ProviderErrorCode, SecrecyLevel,
    ServiceBlockedCode, UnsupportedProductReason,
};
#[cfg(feature = "uniffi")]
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize, Serializer};
use serde_json::Value;
use serde_with::base64::Base64;
use std::any::Any;
use std::fmt;
use std::marker::PhantomData;
use std::net::IpAddr;
use std::str::FromStr;
use url::Url;
use uuid::Uuid;

#[cfg(feature = "uniffi")]
uniffi::setup_scaffolding!();

#[cfg(feature = "uniffi")]
uniffi::custom_type!(ConnectionData, Vec<u8>, {
    try_lift: |val| Ok(val.into()),
    lower: |obj| obj.into(),
});

#[cfg(feature = "uniffi")]
uniffi::custom_type!(Session, Vec<u8>, {
    try_lift: |val| Ok(val.into()),
    lower: |obj| obj.into(),
});

#[cfg(feature = "uniffi")]
uniffi::use_remote_type!(routex_models::CountryCode);

#[cfg(feature = "uniffi")]
uniffi::use_remote_type!(routex_models::Decimal);

#[cfg(feature = "uniffi")]
uniffi::custom_type!(NaiveDate, String, {
    remote,
    try_lift: |val| Ok(val.parse()?),
    lower: |obj| obj.to_string(),
});

type DateTime = chrono::DateTime<Utc>;

#[cfg(feature = "uniffi")]
uniffi::custom_type!(DateTime, String, {
    remote,
    try_lift: |val| Ok(val.parse()?),
    lower: |obj| obj.to_rfc3339_opts(chrono::SecondsFormat::Millis, true),
});

pub type Dialog<S> = routex_models::Dialog<ConfirmationContext<S>, InputContext<S>>;
pub type DialogInput<S> = routex_models::DialogInput<ConfirmationContext<S>, InputContext<S>>;

/// Representation of an API path
///
/// Use [`to_url`](Path::to_url) to build requests on clients,
/// [`to_string`](ToString::to_string) to get for service routes.
/// Note that the [`Display`](fmt::Display) implementation does NOT escape
/// the segments, so that e.g. axum / matchit captures can be used.
#[must_use]
pub struct Path(Vec<String>);

impl Path {
    fn new<I>(segments: I) -> Self
    where
        I: IntoIterator,
        I::Item: ToString,
    {
        Self(segments.into_iter().map(|s| s.to_string()).collect())
    }

    #[must_use]
    /// Build a URL from a base and the path.
    ///
    /// # Panics
    ///
    /// Panics if the given URL is cannot-be-a-base.
    pub fn to_url(&self, base: &Url) -> Url {
        let mut url = base.clone();
        url.path_segments_mut()
            .expect("cannot be base")
            .extend(&self.0);
        url
    }
}

impl fmt::Display for Path {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        for segment in &self.0 {
            f.write_str("/")?;
            f.write_str(segment)?;
        }

        Ok(())
    }
}

pub mod headers {
    use http::HeaderName;

    pub static SESSION_ID: HeaderName = HeaderName::from_static("yaxi-session-id");

    pub static TICKET: HeaderName = HeaderName::from_static("yaxi-ticket");

    pub static TICKET_ID: HeaderName = HeaderName::from_static("yaxi-ticket-id");

    pub static REDIRECT_URI: HeaderName = HeaderName::from_static("yaxi-redirect-uri");

    pub static TRACE_ID: HeaderName = HeaderName::from_static("yaxi-trace-id");
}

/// Indicates that a user is in session for a non-interactive service call.
///
/// When a user is in session, YAXI forwards the user's IP address to their bank. That
/// address is either this connection's own source IP ([`UserInSession::OnThisConnection`])
/// or an IP address the caller provides ([`UserInSession::At`]).
///
/// Without a user in session, banks limit how many requests a caller may make and
/// reject excess requests with an [`Error::AccessExceeded`] error. A user in session
/// lifts that limit.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
pub enum UserInSession {
    /// The user's IP is this connection's own source IP.
    #[serde(rename = "connection")]
    OnThisConnection,
    /// The user is at the given IP address.
    #[serde(untagged)]
    At(IpAddr),
}

#[cfg(feature = "uniffi")]
uniffi::custom_type!(IpAddr, String, {
    remote,
    try_lift: |val| Ok(val.parse()?),
    lower: |obj| obj.to_string(),
});

pub const CURRENT_MEDIA_TYPE: &str = "application/vnd.yaxi.v6";

pub mod keys {
    use super::Path;
    use clerk_report::PublishedVersionEntry;
    use serde::{Deserialize, Serialize};
    use serde_with::base64::Base64;

    /// Run a TEE-attested key settlement
    ///
    /// Method: POST<br>
    /// Request: [`Request`]<br>
    /// Response: [`Response`]
    pub fn settlement_path() -> Path {
        Path::new(["key-settlement"])
    }

    #[serde_with::serde_as]
    #[derive(Serialize, Deserialize, Clone, Debug)]
    #[serde(rename_all = "camelCase")]
    pub struct Request {
        /// The client's Curve25519 public key (Montgomery form, binary)
        #[serde_as(as = "Base64")]
        pub public_key: [u8; 32],
    }

    /// The contents of a key settlement's sealed box
    #[serde_with::serde_as]
    #[derive(Serialize, Deserialize)]
    #[serde(rename_all = "camelCase")]
    pub struct SettlementBoxMessage {
        #[serde_as(as = "Base64")]
        pub public_key: [u8; 32],
        #[serde_as(as = "Base64")]
        pub session_id: [u8; 32],
    }

    /// Response to a request for a TEE-attested key settlement.
    #[serde_with::serde_as]
    #[derive(Serialize, Deserialize, Clone, Debug)]
    #[serde(rename_all = "camelCase")]
    pub struct Response {
        /// TEE attestation report which also authenticates `chacha_box`
        #[serde_as(as = "Base64")]
        pub attestation_report: Vec<u8>,
        /// Versioned Chip Endorsement Key, AMD SEV Key and AMD Root Key as chain of PEM-encoded certificates
        pub vcek: String,
        /// Sealed box containing [`SettlementBoxMessage`]
        #[serde_as(as = "Base64")]
        pub chacha_box: Vec<u8>,
        /// The TEE's version, signed by YAXI. The contained measurement needs to match the
        /// attestation report's measurement.
        pub system_version: PublishedVersionEntry,
        /// Number of vCPUs of the issuing system.
        #[serde(default = "default_vcpus")]
        pub vcpus: usize,
    }

    fn default_vcpus() -> usize {
        2
    }
}

pub mod traces {
    use super::Path;

    /// Retrieve trace data
    ///
    /// Method: GET<br>
    /// Response: Trace data string
    pub fn path(trace_id: &str) -> Path {
        Path::new(["traces", trace_id])
    }
}

pub mod redirects {
    use super::Path;
    use serde::{Deserialize, Serialize};
    use url::Url;

    /// Register redirects
    ///
    /// Method: POST<br>
    /// Request: [`Request`]<br>
    /// Response: [`Response`]
    pub fn path() -> Path {
        Path::new(["redirects"])
    }

    #[derive(Serialize, Deserialize, Clone, Debug)]
    #[serde(rename_all = "camelCase")]
    pub struct Request {
        pub handle: String,
        pub redirect_uri: String,
    }

    #[derive(Serialize, Deserialize, Clone, Debug)]
    #[serde(rename_all = "camelCase")]
    pub struct Response {
        #[serde(serialize_with = "super::serialize_url")]
        pub redirect_url: Url,
    }
}

pub mod info {
    use super::Path;
    pub use isocountry::CountryCode;
    use routex_models::{ConnectionId, CredentialsModel};
    use serde::{Deserialize, Serialize};
    #[cfg(feature = "server")]
    use serde_with::base64::Base64;

    /// Search for connections (service provider integrations)
    ///
    /// Method: GET<br>
    /// Request: [`Request`]<br>
    /// Response: [`Vec<[ConnectionInfo]>`](ConnectionInfo)
    pub fn search_path() -> Path {
        Path::new(["search"])
    }

    #[derive(Serialize, Deserialize, Clone, Debug)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct Request {
        pub filters: Vec<SearchFilter>,
        #[serde(default)]
        pub iban_detection: bool,
        #[serde(skip_serializing_if = "Option::is_none")]
        pub limit: Option<usize>,
        #[serde(default)]
        #[serde(skip_serializing_if = "Vec::is_empty")]
        pub details: Vec<Details>,
    }

    impl Request {
        pub fn new(filters: impl IntoIterator<Item = SearchFilter>) -> Self {
            Self {
                filters: filters.into_iter().collect(),
                iban_detection: false,
                limit: None,
                details: Vec::new(),
            }
        }
    }

    /// Details to contain in search results.
    #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Copy, Debug)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
    pub enum Details {
        Bics,
        BankCodes,
    }

    /// Filters for the connection lookup
    ///
    /// String filters look for the given value anywhere in the related field, case-insensitive.
    #[serde_with::serde_as]
    #[derive(Serialize, Deserialize, Clone, Debug)]
    #[serde(rename_all = "camelCase")]
    #[serde(rename_all_fields = "camelCase")]
    pub enum SearchFilter {
        /// List of [`ConnectionType`]s to consider.
        Types(Vec<ConnectionType>),
        /// List of [`CountryCode`]s to consider.
        Countries(Vec<CountryCode>),
        /// String filter for the provider / product name or any alias.
        Name(String),
        /// String filter for the BIC.
        Bic(String),
        /// String filter for the (national) bank code.
        BankCode(String),
        /// String filter for any of those fields.
        Term(String),
        #[cfg(feature = "server")]
        EncryptedIban(#[serde_as(as = "Base64")] Vec<u8>),
    }

    /// Type of connections to consider when searching
    #[derive(Serialize, Deserialize, Hash, PartialEq, Eq, Copy, Clone, Debug)]
    #[non_exhaustive]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
    pub enum ConnectionType {
        /// Production connections.
        Production,
        /// Sandboxes connections, especially test systems provided by third-parties.
        Sandboxes,
    }

    /// Query connection information
    ///
    /// Method: GET<br>
    /// Response: [`ConnectionInfo`]
    pub fn fetch_path(connection_id: &str) -> Path {
        Path::new(["info", connection_id])
    }

    /// Connection meta data
    #[allow(clippy::module_name_repetitions)]
    #[derive(Serialize, Deserialize, Hash, Eq, PartialEq, Clone, Debug)]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
    #[serde(rename_all = "camelCase")]
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    pub struct ConnectionInfo {
        /// Unique identifier.
        pub id: ConnectionId,

        /// ISO 3166-1 ALPHA-2 country codes.
        pub countries: Vec<CountryCode>,

        /// Display name.
        pub display_name: String,

        /// Credentials model.
        pub credentials: CredentialsModel,

        /// Human-friendly label for the user identifier if relevant.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub user_id: Option<String>,

        /// Human-friendly label for the PIN / password if relevant.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub password: Option<String>,

        /// Advice for the credentials to be displayed.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub advice: Option<String>,

        /// Logo identifier.
        pub logo_id: String,

        #[allow(clippy::doc_markdown)]
        /// ISO 20022 BICFIIdentifiers.
        ///
        /// Note that this is only included in search results if requested.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub bics: Option<Vec<String>>,

        /// National bank codes (as used in IBANs).
        ///
        /// Note that this is only included in search results if requested.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub bank_codes: Option<Vec<String>>,
    }
}

macro_rules! context {
    ($name:ident) => {
        #[serde_with::serde_as]
        #[derive(Serialize, Deserialize)]
        #[serde(transparent)]
        pub struct $name<S>(#[serde_as(as = "Base64")] Vec<u8>, PhantomData<fn(S)>);

        impl<S> PartialEq for $name<S> {
            fn eq(&self, other: &Self) -> bool {
                self.0 == other.0
            }
        }

        impl<S> Eq for $name<S> {}

        impl<S> Clone for $name<S> {
            fn clone(&self) -> Self {
                Self(self.0.clone(), self.1)
            }
        }

        impl<S> fmt::Debug for $name<S> {
            fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
                f.debug_tuple("$name")
                    .field(&self.0)
                    .field(&self.1)
                    .finish()
            }
        }

        impl<S> From<Vec<u8>> for $name<S> {
            fn from(value: Vec<u8>) -> Self {
                Self(value, PhantomData)
            }
        }

        impl<S> From<$name<S>> for Vec<u8> {
            fn from(value: $name<S>) -> Self {
                value.0
            }
        }

        impl<S> AsRef<[u8]> for $name<S> {
            fn as_ref(&self) -> &[u8] {
                &self.0
            }
        }
    };
}

context!(InputContext);

context!(ConfirmationContext);

/// Data authenticated with an HMAC
///
/// Use [`to_data()`](Authenticated::to_data) to access the data locally.
///
/// Serialization is supported for transfer to a remote system as [JSON Web Token](https://jwt.io/).
/// The remote system can verify and read the data from the `data` claim:
/// ```
/// # let jwt = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJkYXRhIjpudWxsLCJleHAiOjIwMDAwMDAwMDB9.mWSPWTs-N4npIQpnybpFHbRiLW4D8xS36mX3CmRlRCM";
/// # type T = ();
/// # let hmac_key = b"a";
/// use jsonwebtoken::{decode, DecodingKey, Validation, Algorithm};
/// use serde::Deserialize;
///
/// #[derive(Deserialize, Clone, Debug)]
/// struct Claims {
///     data: T,
///     exp: u64,
/// }
///
/// let data = decode::<Claims>(
///     &jwt,
///     &DecodingKey::from_secret(hmac_key),
///     &Validation::new(Algorithm::HS256),
/// )?.claims.data;
/// # Ok::<(), Box<dyn std::error::Error>>(())
#[derive(Serialize, PartialEq, Eq, Clone, Debug)]
#[serde(transparent)]
pub struct Authenticated<T> {
    jwt: String,
    _phantom: PhantomData<T>,
}

impl<'de, T> Deserialize<'de> for Authenticated<T>
where
    T: for<'t> Deserialize<'t> + Clone,
{
    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        String::deserialize(deserializer)?
            .parse()
            .map_err(serde::de::Error::custom)
    }
}

impl<T> Authenticated<T>
where
    T: Serialize,
{
    #[must_use]
    /// Initialize authenticated data.
    ///
    /// # Panics
    ///
    /// Panics if [`jsonwebtoken::encode`] fails.
    pub fn new(data: T, key_id: impl Into<String>, key: &[u8]) -> Self {
        let header = Header {
            kid: Some(key_id.into()),
            ..Default::default()
        };

        let jwt = encode(
            &header,
            &Claims {
                data,
                // 2050-07-07 14:00 CEST
                exp: 2_540_808_000,
            },
            &EncodingKey::from_secret(key),
        )
        .expect("Encoding should work");

        Self {
            jwt,
            _phantom: PhantomData,
        }
    }
}

impl<T> FromStr for Authenticated<T>
where
    T: for<'de> Deserialize<'de> + Clone,
{
    type Err = jsonwebtoken::errors::Error;

    fn from_str(jwt: &str) -> Result<Self, Self::Err> {
        // Syntax check
        decode::<T>(jwt)?;
        Ok(Self {
            jwt: jwt.to_string(),
            _phantom: PhantomData,
        })
    }
}

impl<T> Authenticated<T>
where
    T: for<'de> Deserialize<'de> + Clone,
{
    #[must_use]
    pub fn as_str(&self) -> &str {
        &self.jwt
    }

    #[must_use]
    /// Get the key identifier from the token header.
    ///
    /// # Panics
    ///
    /// Panics if the token header cannot get decoded. This is unexpected as decoding is tested in [`FromStr`].
    pub fn key_id(&self) -> Option<String> {
        decode_header(&self.jwt).unwrap().kid
    }

    #[cfg(feature = "client")]
    #[must_use]
    #[allow(clippy::missing_panics_doc)]
    pub fn to_data(&self) -> T {
        decode(&self.jwt).unwrap()
    }

    #[cfg(feature = "server")]
    /// Return contained data, applying a decoder.
    ///
    /// # Errors
    ///
    /// Forwards errors returned by [`Decoder::decode`].
    pub fn decode<D: Decoder>(&self, decoder: &D) -> Result<T, D::Error> {
        decoder.decode::<T>(&self.jwt).map(|d| d.data)
    }
}

#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Claims<T> {
    pub data: T,
    pub exp: u64,
}

#[cfg(feature = "server")]
pub trait Decoder {
    type Error;

    /// Verifies `mac` for `data`.
    ///
    /// # Errors
    ///
    /// Returns `Self::Error` if verification fails.
    fn decode<T>(&self, jwt: &str) -> Result<Claims<T>, Self::Error>
    where
        T: for<'de> Deserialize<'de> + Clone;
}

/// Response from YAXI Open Banking services.
///
/// The response either carries an [authenticated](Authenticated) [result](OBResult)
/// or an interrupt (i.e. a dialog or redirect for the user).
#[derive(Serialize, Deserialize, Debug)]
pub enum OBResponse<S: Service> {
    #[serde(bound = "S:")]
    Result(
        Authenticated<OBResult<S::Output>>,
        Option<Session>,
        Option<ConnectionData>,
    ),
    #[serde(bound = "S:")]
    Dialog(Dialog<S>),
    #[serde(bound = "S:")]
    Redirect(Redirect<S>),
    #[serde(bound = "S:")]
    RedirectHandle(RedirectHandle<S>),
}

impl<S: Service> Clone for OBResponse<S> {
    fn clone(&self) -> Self {
        match self {
            OBResponse::Result(authenticated, session, connection_data) => OBResponse::Result(
                authenticated.clone(),
                session.clone(),
                connection_data.clone(),
            ),
            OBResponse::Dialog(dialog) => OBResponse::Dialog(dialog.clone()),
            OBResponse::Redirect(redirect) => OBResponse::Redirect(redirect.clone()),
            OBResponse::RedirectHandle(redirect_handle) => {
                OBResponse::RedirectHandle(redirect_handle.clone())
            }
        }
    }
}

#[derive(Serialize, Deserialize, Debug)]
#[cfg_attr(not(feature = "server"), non_exhaustive)]
#[serde(rename_all = "camelCase")]
pub struct NonInteractiveResponse<S: Service> {
    #[serde(bound = "S:")]
    pub result: S::Output,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub session: Option<Session>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub connection_data: Option<ConnectionData>,
}

/// A value returned by YAXI Open Banking services.
///
/// Besides the value itself, it contains a timestamp and a ticket identifier
/// (bound to known input parameters and service type).
#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct OBResult<T> {
    pub data: T,
    pub ticket_id: Uuid,
    pub timestamp: DateTime,
}

#[serde_with::serde_as]
#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
pub struct Session(#[serde_as(as = "Base64")] Vec<u8>);

impl From<Vec<u8>> for Session {
    fn from(value: Vec<u8>) -> Self {
        Session(value)
    }
}

impl From<Session> for Vec<u8> {
    fn from(session: Session) -> Self {
        session.0
    }
}

impl AsRef<[u8]> for Session {
    fn as_ref(&self) -> &[u8] {
        &self.0
    }
}

#[serde_with::serde_as]
#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
#[serde(transparent)]
pub struct ConnectionData(#[serde_as(as = "Base64")] Vec<u8>);

impl From<Vec<u8>> for ConnectionData {
    fn from(value: Vec<u8>) -> Self {
        ConnectionData(value)
    }
}

impl From<ConnectionData> for Vec<u8> {
    fn from(connection_data: ConnectionData) -> Self {
        connection_data.0
    }
}

impl AsRef<[u8]> for ConnectionData {
    fn as_ref(&self) -> &[u8] {
        &self.0
    }
}

/// User redirect.
///
/// The user is meant to get sent to the [`url`](Self::url) and the [`context`](Self::context) can
/// be used for continuing the process at the service that issued the redirect object afterward.
///
/// A web application needs to direct the user agent to the returned URL.
/// A desktop or mobile application could either open it in a browser or inside an element like a WebView.
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Redirect<S> {
    #[serde(serialize_with = "serialize_url")]
    pub url: Url,
    #[serde(bound = "S:")]
    pub context: ConfirmationContext<S>,
}

impl<S> PartialEq for Redirect<S> {
    fn eq(&self, other: &Self) -> bool {
        let Self { url, context } = self;
        url == &other.url && context == &other.context
    }
}

impl<S> Eq for Redirect<S> {}

impl<S> Clone for Redirect<S> {
    fn clone(&self) -> Self {
        Self {
            url: self.url.clone(),
            context: self.context.clone(),
        }
    }
}

impl<S> fmt::Debug for Redirect<S> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Redirect")
            .field("url", &self.url)
            .field("context", &self.context)
            .finish()
    }
}

// This is a hack to work around Revolut not accepting plus-encoded URLs
// See https://github.com/servo/rust-url/issues/927
fn serialize_url<S: Serializer>(value: &Url, serializer: S) -> Result<S::Ok, S::Error> {
    let string_repr = value.to_string().replace('+', "%20");
    serializer.serialize_str(&string_repr)
}

/// Incomplete user redirect.
///
/// A final redirect URI needs to get registered, using the handle, to receive the URL to send the user to.
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RedirectHandle<S> {
    pub handle: String,
    #[serde(bound = "S:")]
    pub context: ConfirmationContext<S>,
}

impl<S> PartialEq for RedirectHandle<S> {
    fn eq(&self, other: &Self) -> bool {
        let Self { handle, context } = self;
        handle == &other.handle && context == &other.context
    }
}

impl<S> Eq for RedirectHandle<S> {}

impl<S> Clone for RedirectHandle<S> {
    fn clone(&self) -> Self {
        Self {
            handle: self.handle.clone(),
            context: self.context.clone(),
        }
    }
}

impl<S> fmt::Debug for RedirectHandle<S> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RedirectHandle")
            .field("handle", &self.handle)
            .field("context", &self.context)
            .finish()
    }
}

/// Decode a JWT without any validation or verification.
fn decode<T>(jwt: &str) -> jsonwebtoken::errors::Result<T>
where
    T: for<'de> Deserialize<'de> + Clone,
{
    insecure_decode::<Claims<T>>(jwt).map(|data| data.claims.data)
}

macro_rules! enum_with_display {
    {
        $(#[$meta:meta])*
        pub enum $name:ident {
            $($variant:ident,)+
        }
    } => {
        $(#[$meta])*
        pub enum $name {
            $($variant,)+
        }

        impl fmt::Display for $name {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                f.write_str(match self {
                    $(Self::$variant => stringify!($variant),)+
                })
            }
        }
    }
}

enum_with_display! {
    #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Copy, Debug)]
    pub enum ServiceId {
        Accounts,
        CollectPayment,
        Transactions,
        Balances,
        Transfer,
    }
}

/// Ticket to use a service.
///
/// This must be issued by a trusted backend for use in the (untrusted) frontend.
///
/// It carries
/// * an identifier of the service that is intended to be used,
/// * an arbitrary ticket identifier for verifying the results later on and
/// * any critical input data for the service.
///
/// The ticket data gets wrapped in a [JSON Web Token](https://jwt.io/) as claim `data`.
/// The token must also contain an expiry in the claim `exp` and the key identifier in the `kid` header field.
///
/// Example issuance of an `Authenticated<Ticket<accounts::Service>>` for the accounts service:
///
/// ```
/// # const HMAC_KEY: &[u8] = b"foo";
/// # const HMAC_KEY_ID: &str = "foo";
/// use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
/// use serde::Serialize;
/// use std::time::{SystemTime, UNIX_EPOCH};
/// use uuid::Uuid;
///
/// let ticket_id = Uuid::new_v4();
///
/// #[derive(Serialize, Debug)]
/// struct Ticket<T> {
///     service: String,
///     id: Uuid,
///     data: T,
/// }
///
/// #[derive(Serialize, Debug)]
/// struct Claims<T> {
///     data: Ticket<T>,
///     exp: u64,
/// }
///
/// let header = Header {
///     alg: Algorithm::HS256,
///     kid: Some(HMAC_KEY_ID.to_string()),
///     ..Default::default()
/// };
///
/// let authenticated_ticket = encode(
///     &header,
///     &Claims {
///         data: Ticket {
///             service: "Accounts".to_string(),
///             id: ticket_id,
///             data: (),
///         },
///         exp: SystemTime::now().duration_since(UNIX_EPOCH).expect("Time went backwards").as_secs() + 600,
///     },
///     &EncodingKey::from_secret(HMAC_KEY),
/// )?;
/// # let auth: routex_api::Authenticated<routex_api::Ticket<routex_api::accounts::Service>> = authenticated_ticket.parse().unwrap();
/// # auth.to_data();
/// # auth.key_id().unwrap();
/// # Ok::<(), Box<dyn std::error::Error>>(())
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[serde(try_from = "DeserializedTicket<S::TicketData>")]
pub struct Ticket<S: Service> {
    pub service: ServiceId,
    pub id: Uuid,
    pub data: S::TicketData,
}

impl<S: Service> PartialEq for Ticket<S> {
    fn eq(&self, other: &Self) -> bool {
        let Self { service, id, data } = self;
        service == &other.service && id == &other.id && data == &other.data
    }
}

impl<S: Service> Eq for Ticket<S> {}

impl<S: Service> fmt::Debug for Ticket<S> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Ticket")
            .field("service", &self.service)
            .field("id", &self.id)
            .field("data", &self.data)
            .finish()
    }
}

impl<S: Service> Clone for Ticket<S> {
    fn clone(&self) -> Self {
        Self {
            service: self.service,
            id: self.id,
            data: self.data.clone(),
        }
    }
}

#[derive(Deserialize, Debug)]
struct DeserializedTicket<T> {
    service: ServiceId,
    id: Uuid,
    data: Option<T>,
}

impl<S: Service> TryFrom<DeserializedTicket<S::TicketData>> for Ticket<S> {
    type Error = &'static str;

    fn try_from(
        DeserializedTicket { service, id, data }: DeserializedTicket<S::TicketData>,
    ) -> Result<Self, Self::Error> {
        let data = (&() as &dyn Any)
            .downcast_ref::<S::TicketData>()
            .cloned()
            .or(data)
            .ok_or("missing field `data`")?;

        Ok(Self { service, id, data })
    }
}

pub trait Service {
    const ID: ServiceId;

    type TicketData: Serialize
        + for<'de> Deserialize<'de>
        + PartialEq
        + Eq
        + Clone
        + fmt::Debug
        + Send
        + Sync
        + 'static;

    type RequestData: Serialize + for<'de> Deserialize<'de> + Send + Sync + Clone;

    type Output: Serialize + for<'de> Deserialize<'de> + Send + fmt::Debug + Clone;

    /// Use the service
    ///
    /// Method: POST<br>
    /// Request: `Self::Request`<br>
    /// Response: [`OBResponse<Self>`](OBResponse)
    fn path() -> Path {
        Path::new([&Self::ID.to_string().to_kebab_case(), "service"])
    }

    fn response_path() -> Path {
        Path::new([&Self::ID.to_string().to_kebab_case(), "response"])
    }

    fn confirmation_path() -> Path {
        Path::new([&Self::ID.to_string().to_kebab_case(), "confirmation"])
    }
}

pub trait NonInteractiveService: Service {
    fn non_interactive_path() -> Path {
        Path::new([&Self::ID.to_string().to_kebab_case(), "non-interactive"])
    }
}

#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Copy, Debug)]
#[serde(tag = "ticketStatus")]
pub enum TicketStatus<T> {
    Unfinished,
    Error(ErrorKind),
    Success(T),
}

enum_with_display! {
    #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Copy, Debug)]
    #[serde(tag = "error")]
    pub enum ErrorKind {
        UnexpectedError,
        Canceled,
        InvalidCredentials,
        ServiceBlocked,
        Unauthorized,
        AccessExceeded,
        PeriodOutOfBounds,
        UnsupportedProduct,
        PaymentFailed,
        UnexpectedValue,
        TicketError,
        ProviderError,
        NotFound,
    }
}

#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
#[serde(rename_all = "camelCase")]
pub struct Credentials {
    pub connection_id: ConnectionId,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub user_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub password: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub connection_data: Option<ConnectionData>,
}

#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ResponseData<S> {
    #[serde(bound = "S:")]
    pub context: InputContext<S>,
    pub response: String,
}

impl<S> PartialEq for ResponseData<S> {
    fn eq(&self, other: &Self) -> bool {
        let Self { context, response } = self;
        context == &other.context && response == &other.response
    }
}

impl<S> Eq for ResponseData<S> {}

impl<S> Clone for ResponseData<S> {
    fn clone(&self) -> Self {
        Self {
            context: self.context.clone(),
            response: self.response.clone(),
        }
    }
}

impl<S> fmt::Debug for ResponseData<S> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ResponseData")
            .field("context", &self.context)
            .field("response", &self.response)
            .finish()
    }
}

#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfirmationData<S> {
    #[serde(bound = "S:")]
    pub context: ConfirmationContext<S>,
}

impl<S> PartialEq for ConfirmationData<S> {
    fn eq(&self, other: &Self) -> bool {
        let Self { context } = self;
        context == &other.context
    }
}

impl<S> Eq for ConfirmationData<S> {}

impl<S> Clone for ConfirmationData<S> {
    fn clone(&self) -> Self {
        Self {
            context: self.context.clone(),
        }
    }
}

impl<S> fmt::Debug for ConfirmationData<S> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ConfirmationData")
            .field("context", &self.context)
            .finish()
    }
}

#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
#[serde(rename_all_fields = "camelCase")]
#[cfg_attr(not(feature = "exhaustive-error"), non_exhaustive)]
pub enum Error {
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    UnexpectedError {
        #[serde(skip_serializing_if = "Option::is_none")]
        user_message: Option<String>,
    },
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    Canceled {},
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    InvalidCredentials {
        #[serde(skip_serializing_if = "Option::is_none")]
        user_message: Option<String>,
    },
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    ServiceBlocked {
        #[serde(skip_serializing_if = "Option::is_none")]
        user_message: Option<String>,
        #[serde(skip_serializing_if = "Option::is_none")]
        code: Option<ServiceBlockedCode>,
    },
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    Unauthorized {
        #[serde(skip_serializing_if = "Option::is_none")]
        user_message: Option<String>,
    },
    /// The bank rejected the request for exceeding the consent's permitted access
    /// frequency.
    ///
    /// This most commonly arises on the non-interactive refresh service, where a
    /// caller exceeds the bank's limit on requests made without a user in session.
    /// Provide a [`UserInSession`] to lift that limit.
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    AccessExceeded {
        #[serde(skip_serializing_if = "Option::is_none")]
        user_message: Option<String>,
    },
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    PeriodOutOfBounds {
        #[serde(skip_serializing_if = "Option::is_none")]
        user_message: Option<String>,
    },
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    UnsupportedProduct {
        #[serde(skip_serializing_if = "Option::is_none")]
        reason: Option<UnsupportedProductReason>,
        #[serde(skip_serializing_if = "Option::is_none")]
        user_message: Option<String>,
    },
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    PaymentFailed {
        #[serde(skip_serializing_if = "Option::is_none")]
        code: Option<PaymentErrorCode>,
        #[serde(skip_serializing_if = "Option::is_none")]
        user_message: Option<String>,
    },
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    UnexpectedValue { error: String },
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    TicketError {
        error: String,
        code: TicketErrorCode,
    },
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    ProviderError {
        #[serde(skip_serializing_if = "Option::is_none")]
        code: Option<ProviderErrorCode>,
        #[serde(skip_serializing_if = "Option::is_none")]
        user_message: Option<String>,
    },
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    InterruptError {},
}

#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Copy, Debug)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
#[cfg_attr(not(feature = "server"), non_exhaustive)]
pub enum TicketErrorCode {
    /// Missing "yaxi-ticket" header
    Missing,
    /// Invalid ticket
    Invalid,
    /// Ticket token lacks "kid"
    MissingKey,
    /// Unknown key
    UnknownKey,
    /// Ticket does not match service
    Mismatch,
    /// Ticket is expired
    Expired,
    /// Ticket lifetime is too long
    InvalidLifetime,
    /// Expired key
    ExpiredKey,
    /// Environment mismatch between key and routex
    KeyEnvironmentMismatch,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
#[cfg_attr(not(feature = "server"), non_exhaustive)]
pub enum Filter<F> {
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    Eq(F, Value),
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    NotEq(F, Value),
    #[cfg(feature = "server")]
    Contains(F, Value),
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    And(Box<Self>, Box<Self>),
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    Or(Box<Self>, Box<Self>),
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    Supports(SupportedService),
}

#[derive(Serialize, Deserialize, Clone, Debug)]
#[cfg_attr(not(feature = "server"), non_exhaustive)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
pub enum SupportedService {
    CollectPayment,
}

impl<F> Filter<F> {
    #[must_use]
    /// Add an additional filter.
    pub fn and(self, other: Filter<F>) -> Filter<F> {
        Filter::And(Box::new(self), Box::new(other))
    }

    #[must_use]
    /// Add an alternative filter.
    pub fn or(self, other: Filter<F>) -> Filter<F> {
        Filter::Or(Box::new(self), Box::new(other))
    }
}

pub struct Field<F, T> {
    field: F,
    phantom: PhantomData<T>,
}

impl<F, T> Field<F, T>
where
    F: Copy,
    T: Serialize,
{
    /// Filter for equality with a given value.
    ///
    /// # Panics
    ///
    /// Panics if [`serde_json::to_value`] for the value fails.
    pub fn eq(&self, value: T) -> Filter<F> {
        Filter::Eq(self.field, serde_json::to_value(&value).unwrap())
    }

    /// Filter for inequality with a given value.
    ///
    /// # Panics
    ///
    /// Panics if [`serde_json::to_value`] for the value fails.
    pub fn not_eq(&self, value: T) -> Filter<F> {
        Filter::NotEq(self.field, serde_json::to_value(&value).unwrap())
    }
}

pub trait GetValue {
    type Model;

    fn get(&self, model: &Self::Model) -> Value;
}

macro_rules! fields {
    {
        $model:ty, $enum_name:ident
        $(($const_name:ident, $variant_name:ident, $field_name:ident, $($type:ty)+))+
        $(
            server:
            $(($server_variant_name:ident, $server_field_name:ident))+
        )?
    } => {
        #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Copy, Debug)]
        #[non_exhaustive]
        #[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
        pub enum $enum_name {
            $($variant_name,)+
            $($(
                #[cfg(feature = "server")]
                $server_variant_name,
            )+)?
        }

        impl $enum_name {
            $(
                pub const $const_name: crate::Field<$enum_name, $($type)+> = crate::Field {
                    field: $enum_name::$variant_name,
                    phantom: std::marker::PhantomData,
                };
            )+
        }

        impl crate::GetValue for $enum_name {
            type Model = $model;

            fn get(&self, model: &$model) -> serde_json::Value {
                match self {
                    $($enum_name::$variant_name => serde_json::to_value(&model.$field_name),)+
                    $($(
                        #[cfg(feature = "server")]
                        $enum_name::$server_variant_name => serde_json::to_value(&model.$server_field_name),
                    )+)?
                }.expect("Serialization should work")
            }
        }
    }
}

#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceRequest<S: Service> {
    pub credentials: Credentials,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub session: Option<Session>,
    #[serde(default, skip_serializing_if = "is_false")]
    pub recurring_consents: bool,
    #[serde(flatten, bound = "S:")]
    pub data: <S as Service>::RequestData,
}

impl<S: Service> Clone for ServiceRequest<S> {
    fn clone(&self) -> Self {
        Self {
            credentials: self.credentials.clone(),
            session: self.session.clone(),
            recurring_consents: self.recurring_consents,
            data: self.data.clone(),
        }
    }
}

#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NonInteractiveRequest<S: Service> {
    pub connection_data: ConnectionData,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub session: Option<Session>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub user_in_session: Option<UserInSession>,
    #[serde(flatten, bound = "S:")]
    pub data: <S as Service>::RequestData,
}

#[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Default, Debug)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
pub struct Account {
    /// ISO 20022 IBAN2007Identifier.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub iban: Option<String>,

    /// Account number that is not an IBAN, e.g. ISO 20022 BBANIdentifier or primary account number (PAN) of a card account.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub number: Option<String>,

    /// ISO 20022 BICFIIdentifier.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub bic: Option<String>,

    /// National bank code.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub bank_code: Option<String>,

    /// ISO 4217 Alpha 3 currency code.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub currency: Option<String>,

    /// Name of account, assigned by ASPSP.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub name: Option<String>,

    /// Display name of account, assigned by PSU.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub display_name: Option<String>,

    /// Legal account owner.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub owner_name: Option<String>,

    /// Product name.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub product_name: Option<String>,

    /// Account status.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub status: Option<AccountStatus>,

    /// Account type.
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub type_: Option<AccountType>,
}

pub mod accounts {
    use super::{Account, AccountStatus, AccountType, Filter, ServiceId, SupportedService};
    use serde::{Deserialize, Serialize};

    #[derive(Clone, Debug)]
    pub struct Service {}

    impl super::Service for Service {
        const ID: ServiceId = ServiceId::Accounts;

        type TicketData = ();

        type RequestData = RequestData;

        type Output = Vec<Account>;
    }

    impl super::NonInteractiveService for Service {}

    fields! {
        routex_models::Account, AccountField
        (IBAN, Iban, iban, Option<String>)
        (NUMBER, Number, number, Option<String>)
        (BIC, Bic, bic, Option<String>)
        (BANK_CODE, BankCode, bank_code, Option<String>)
        (CURRENCY, Currency, currency, String)
        (NAME, Name, name, Option<String>)
        (DISPLAY_NAME, DisplayName, display_name, Option<String>)
        (OWNER_NAME, OwnerName, owner_name, Option<String>)
        (PRODUCT_NAME, ProductName, product_name, Option<String>)
        (STATUS, Status, status, Option<AccountStatus>)
        (TYPE, Type, type_, Option<AccountType>)
        server:
        (Capabilities, capabilities)
    }

    impl Account {
        #[must_use]
        /// Filter for possible support of YAXI Open Banking services.
        pub fn supports(service: SupportedService) -> Filter<AccountField> {
            Filter::Supports(service)
        }
    }

    #[derive(Serialize, Deserialize, Clone)]
    #[serde(rename_all = "camelCase")]
    pub struct RequestData {
        pub fields: Vec<AccountField>,
        #[serde(skip_serializing_if = "Option::is_none")]
        pub filter: Option<Filter<AccountField>>,
    }
}

#[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
#[serde(rename_all = "camelCase")]
#[serde(rename_all_fields = "camelCase")]
#[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
pub enum AccountIdentifier {
    /// ISO 20022 IBAN2007Identifier.
    Iban(String),

    /// Account number that is not an IBAN, e.g. ISO 20022 BBANIdentifier.
    Number(String),
}

#[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
#[serde(rename_all = "camelCase")]
#[serde(rename_all_fields = "camelCase")]
#[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
pub enum CreditorAccountIdentifier {
    /// ISO 20022 IBAN2007Identifier.
    Iban(String),
}

#[serde_with::serde_as]
#[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
#[serde(rename_all = "camelCase")]
#[serde(rename_all_fields = "camelCase")]
#[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
pub enum DebtorAccountIdentifier {
    /// ISO 20022 IBAN2007Identifier.
    #[serde(alias = "Iban")]
    Iban(String),
    #[cfg(feature = "server")]
    EncryptedIban(#[serde_as(as = "Base64")] Vec<u8>),
}

#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
#[serde(rename_all = "camelCase")]
pub struct AccountReference {
    #[serde(flatten)]
    pub id: AccountIdentifier,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub currency: Option<String>,
}

#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
#[serde(rename_all = "camelCase")]
pub struct DebtorAccountReference {
    #[serde(flatten)]
    pub id: DebtorAccountIdentifier,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[cfg_attr(feature = "uniffi", uniffi(default))]
    pub currency: Option<String>,
}

pub mod balances {
    pub use rust_decimal::Decimal;
    use serde::{Deserialize, Serialize};

    use crate::{AccountReference, DateTime, ServiceId};

    #[derive(Clone, Debug)]
    pub struct Service {}

    impl super::Service for Service {
        const ID: ServiceId = ServiceId::Balances;

        type TicketData = ();

        type RequestData = RequestData;

        type Output = Balances;
    }

    impl super::NonInteractiveService for Service {}

    #[derive(Serialize, Deserialize, Clone)]
    #[serde(rename_all = "camelCase")]
    pub struct RequestData {
        pub accounts: Vec<AccountReference>,
    }

    #[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
    #[serde(rename_all = "camelCase")]
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
    pub struct Balances {
        /// List of balances for accounts.
        pub balances: Vec<AccountBalances>,

        /// Accounts that were requested but not found.
        #[serde(default, skip_serializing_if = "Vec::is_empty")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub missing_accounts: Vec<AccountReference>,
    }

    #[allow(clippy::module_name_repetitions)]
    #[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
    #[serde(rename_all = "camelCase")]
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
    pub struct AccountBalances {
        pub account: AccountReference,

        /// List of balances (of different types) for the account.
        pub balances: Vec<Balance>,
    }

    #[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
    #[serde(rename_all = "camelCase")]
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
    pub struct Balance {
        pub amount: Decimal,
        pub currency: String,
        pub balance_type: BalanceType,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub credit_limit_included: Option<bool>,
        #[serde(default, skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub date_time: Option<DateTime>,
    }

    #[derive(Serialize, Deserialize, Copy, Clone, Eq, PartialEq, Debug)]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
    pub enum BalanceType {
        /// Balance from booked transactions.
        Booked,

        /// Available balance from booked transactions.
        ///
        /// Depending on the bank, a credit line may or may not be included
        /// (see [`Balance::credit_limit_included`]). For the most current
        /// balance without credit, prefer [`Booked`](Self::Booked) and judge
        /// recency by [`Balance::date_time`].
        Available,

        /// Expected balance from booked and pending transactions.
        Expected,
    }
}

pub mod transactions {
    use chrono::NaiveDate;
    use isocountry::CountryCode;
    pub use routex_models::{Amount, Fee, TransactionStatus};
    use rust_decimal::Decimal;
    use serde::{Deserialize, Serialize};
    use url::Url;

    use crate::{AccountReference, ServiceId};

    #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
    #[serde(rename_all = "camelCase")]
    pub struct TicketData {
        pub account: AccountReference,
        pub range: Range,
        pub webhook: Option<Url>,
    }

    #[derive(Clone, Debug)]
    pub struct Service {}

    impl super::Service for Service {
        const ID: ServiceId = ServiceId::Transactions;

        type TicketData = TicketData;

        type RequestData = RequestData;

        type Output = Option<Vec<Transaction>>;
    }

    impl super::NonInteractiveService for Service {}

    #[derive(Serialize, Deserialize, Clone)]
    #[serde(rename_all = "camelCase")]
    pub struct RequestData {}

    #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
    #[serde(rename_all = "camelCase")]
    #[serde(rename_all_fields = "camelCase")]
    pub enum Range {
        Reference(String),
        #[serde(untagged)]
        Period {
            /// Earliest date (inclusive)
            from: NaiveDate,
            /// Latest date (inclusive)
            to: Option<NaiveDate>,
        },
    }

    #[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
    #[serde(rename_all = "camelCase")]
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
    pub struct Transaction {
        /// Identifier used for delta requests.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub entry_reference: Option<String>,

        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub batch: Option<BatchData>,

        /// Booking date (ASPSP's books).
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub booking_date: Option<NaiveDate>,

        /// Value date. Expected / requested value date in case of pending entries.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub value_date: Option<NaiveDate>,

        /// Date of the actual transaction, e.g. a card payment.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub transaction_date: Option<NaiveDate>,

        /// Transaction status.
        pub status: TransactionStatus,

        /// Unique reference assigned by the account servicer.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub account_servicer_reference: Option<String>,

        /// Unique identifier assigned by the sending party.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub payment_id: Option<String>,

        /// Unique identifier assigned by the first instructing agent.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub transaction_id: Option<String>,

        /// Unique end-to-end identifier assigned by the initiating party.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub end_to_end_id: Option<String>,

        /// Mandate identifier.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub mandate_id: Option<String>,

        /// SEPA creditor identifier.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub creditor_id: Option<String>,

        /// Transaction amount as billed to the account.
        pub amount: Amount,

        /// Indicator for reversals.
        #[serde(default, skip_serializing_if = "super::is_false")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub reversal: bool,

        /// Original amount of the transaction.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub original_amount: Option<Amount>,

        /// Exchange rates.
        #[serde(default, skip_serializing_if = "Vec::is_empty")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub exchanges: Vec<ExchangeRate>,

        /// Any fees related to the transaction.
        #[serde(default, skip_serializing_if = "Vec::is_empty")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub fees: Vec<Fee>,

        /// Creditor data. In case of reversals this refers to the initial transaction.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub creditor: Option<Party>,

        /// Debtor data. In case of reversals this refers to the initial transaction.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub debtor: Option<Party>,

        /// Remittance (purpose).
        #[serde(default, skip_serializing_if = "Vec::is_empty")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub remittance_information: Vec<String>,

        /// ISO 20022 ExternalPurpose1Code.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub purpose_code: Option<String>,

        /// Bank Transaction Codes.
        #[serde(default, skip_serializing_if = "Vec::is_empty")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub bank_transaction_codes: Vec<BankTransactionCode>,

        /// Additional information attached to the transaction.
        ///
        /// This might be a proprietary, localized, human-readable long text corresponding to some machine-readable bank transaction code that is not directly provided by the bank.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub additional_information: Option<String>,
    }

    #[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
    #[serde(rename_all = "camelCase")]
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
    pub struct BatchData {
        /// Number of transactions in the batch, if known.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub number_of_transactions: Option<u32>,

        /// Details of transactions in the batch.
        ///
        /// Note that this does not necessarily match a given number of transactions.
        /// It could be e.g. empty as no details are given or a single entry with common details on all transactions in the batch.
        pub transactions: Vec<BatchTransactionDetails>,
    }

    #[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
    #[serde(rename_all = "camelCase")]
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
    pub struct BatchTransactionDetails {
        /// Unique reference assigned by the account servicer.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub account_servicer_reference: Option<String>,

        /// Unique identifier assigned by the sending party.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub payment_id: Option<String>,

        /// Unique identifier assigned by the first instructing agent.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub transaction_id: Option<String>,

        /// Unique end-to-end identifier assigned by the initiating party.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub end_to_end_id: Option<String>,

        /// Mandate identifier.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub mandate_id: Option<String>,

        /// SEPA creditor identifier.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub creditor_id: Option<String>,

        /// Transaction amount as billed to the account.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub amount: Option<Amount>,

        /// Indicator for reversals.
        #[serde(default, skip_serializing_if = "super::is_false")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub reversal: bool,

        /// Original amount of the transaction.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub original_amount: Option<Amount>,

        /// Exchange rates.
        #[serde(default, skip_serializing_if = "Vec::is_empty")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub exchanges: Vec<ExchangeRate>,

        /// Any fees related to the transaction.
        #[serde(default, skip_serializing_if = "Vec::is_empty")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub fees: Vec<Fee>,

        /// Creditor data. In case of reversals this refers to the initial transaction.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub creditor: Option<Party>,

        /// Debtor data. In case of reversals this refers to the initial transaction.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub debtor: Option<Party>,

        /// Remittance (purpose).
        #[serde(default, skip_serializing_if = "Vec::is_empty")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub remittance_information: Vec<String>,

        /// ISO 20022 ExternalPurpose1Code.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub purpose_code: Option<String>,

        /// Bank Transaction Codes.
        #[serde(default, skip_serializing_if = "Vec::is_empty")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub bank_transaction_codes: Vec<BankTransactionCode>,

        /// Additional information attached to the transaction.
        ///
        /// This might be a proprietary, localized, human-readable long text corresponding to some machine-readable bank transaction code that is not directly provided by the bank.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub additional_information: Option<String>,
    }

    #[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
    #[serde(rename_all = "camelCase")]
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
    pub struct ExchangeRate {
        /// ISO 4217 Alpha 3 currency code of the source currency that gets converted.
        pub source_currency: String,
        /// ISO 4217 Alpha 3 currency code of the target currency that
        /// the source currency gets converted into.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub target_currency: Option<String>,
        /// ISO 4217 Alpha 3 currency code of the unit currency for the exchange rate.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub unit_currency: Option<String>,
        pub exchange_rate: Decimal,
    }

    #[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
    #[serde(rename_all = "camelCase")]
    #[cfg_attr(not(feature = "server"), non_exhaustive)]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
    pub struct Party {
        /// Creditor / debtor name.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub name: Option<String>,

        /// ISO 20022 IBAN2007Identifier for the creditor / debtor account.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub iban: Option<String>,

        /// ISO 20022 BICFIIdentifier for the creditor / debtor agent.
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub bic: Option<String>,

        /// Ultimate creditor / debtor (name).
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub ultimate: Option<String>,
    }

    #[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
    #[serde(rename_all = "camelCase")]
    #[serde(rename_all_fields = "camelCase")]
    #[non_exhaustive]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
    pub enum BankTransactionCode {
        /// ISO 20022 Bank Transaction Code.
        Iso {
            /// ISO 20022 ExternalBankTransactionDomain1Code.
            domain: String,

            /// ISO 20022 ExternalBankTransactionFamily1Code.
            family: String,

            /// ISO 20022 ExternalBankTransactionSubFamily1Code.
            sub_family: String,
        },
        /// SWIFT transaction code.
        Swift(String),
        /// BAI2 transaction code.
        Bai(String),
        /// National transaction code, e.g. German GVC.
        National { code: String, country: CountryCode },
        /// Unspecified transaction codes, possibly with an issuer information.
        Other {
            code: String,
            #[serde(skip_serializing_if = "Option::is_none")]
            issuer: Option<String>,
        },
    }
}

#[allow(clippy::trivially_copy_pass_by_ref)]
fn is_false(val: &bool) -> bool {
    !*val
}

#[derive(Serialize, Deserialize, Copy, Clone, Eq, PartialEq, Debug)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
#[non_exhaustive]
pub enum PaymentStatus {
    /// The payment was received and is getting processed.
    ///
    /// Especially without realtime bookings this is often the final status reported by the ASPSP.
    Accepted,

    /// The payment was partially accepted, i.e. only some of the transactions of a bulk payment or the payment needs further authorization.
    PartiallyAccepted,

    /// Settlement on the debtor's account has been completed.
    CompletedDebtor,

    /// Settlement on the creditor's account has been completed.
    CompletedCreditor,
}

pub mod collect_payment {
    pub use routex_models::Amount;
    use serde::{Deserialize, Serialize};
    use serde_with::base64::Base64;

    use super::{
        CreditorAccountIdentifier, DebtorAccountReference, Path, PaymentStatus, ServiceId,
    };

    /// Query ticket status, possibly polling pending confirmations
    ///
    /// Method: POST<br>
    /// Response: [`Option<TicketStatus<SuccessStatusData>>`](super::TicketStatus)
    pub fn status_path(ticket_id: &str) -> Path {
        Path::new(["collect-payment", "status", ticket_id])
    }

    #[derive(Serialize, Deserialize, PartialEq, Eq, Default, Clone, Debug)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    pub struct SuccessStatusData {
        #[serde(skip_serializing_if = "Option::is_none")]
        pub payment_status: Option<PaymentStatus>,
    }

    #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
    #[serde(rename_all = "camelCase")]
    pub struct TicketData {
        pub amount: Amount,
        pub creditor_account: CreditorAccountIdentifier,
        pub creditor_name: String,
        pub remittance: String,
        #[serde(skip_serializing_if = "Option::is_none")]
        pub instant: Option<bool>,
        #[serde(skip_serializing_if = "Option::is_none")]
        pub fields: Option<Vec<Field>>,
    }

    #[derive(Clone, Debug)]
    pub struct Service {}

    impl super::Service for Service {
        const ID: ServiceId = ServiceId::CollectPayment;

        type TicketData = TicketData;

        type RequestData = RequestData;

        type Output = PaymentInitiation;
    }

    #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Copy, Debug)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
    pub enum Field {
        DebtorIban,
        DebtorName,
        EncryptedDebtorIban,
        EncryptedDebtorName,
    }

    #[derive(Serialize, Deserialize, Clone)]
    #[serde(rename_all = "camelCase")]
    pub struct RequestData {
        #[serde(skip_serializing_if = "Option::is_none")]
        pub account: Option<DebtorAccountReference>,
    }

    #[serde_with::serde_as]
    #[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Default, Debug)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
    pub struct PaymentInitiation {
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub status: Option<PaymentStatus>,
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub debtor_name: Option<String>,
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub debtor_iban: Option<String>,
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        #[serde_as(as = "Option<Base64>")]
        pub encrypted_debtor_name: Option<Vec<u8>>,
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        #[serde_as(as = "Option<Base64>")]
        pub encrypted_debtor_iban: Option<Vec<u8>>,
    }
}

pub mod transfer {
    pub use routex_models::{ChargeBearer, CreditorAddress, ISODateTimeOrDate, PaymentProduct};
    use serde::{Deserialize, Serialize};

    use super::{
        Amount, CreditorAccountIdentifier, DebtorAccountReference, PaymentStatus, ServiceId,
    };

    #[derive(Clone, Debug)]
    pub struct Service {}

    impl super::Service for Service {
        const ID: ServiceId = ServiceId::Transfer;

        type TicketData = ();

        type RequestData = RequestData;

        type Output = Transfer;
    }

    #[derive(Serialize, Deserialize, Clone)]
    #[serde(rename_all = "camelCase")]
    pub struct RequestData {
        pub product: PaymentProduct,
        #[serde(skip_serializing_if = "Option::is_none")]
        pub debtor_account: Option<DebtorAccountReference>,
        #[serde(skip_serializing_if = "Option::is_none")]
        pub debtor_name: Option<String>,
        #[serde(skip_serializing_if = "Option::is_none")]
        pub requested_execution_date: Option<ISODateTimeOrDate>,
        pub details: Vec<TransferDetails>,
    }

    #[derive(Serialize, Deserialize, Clone)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
    pub struct TransferDetails {
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub end_to_end_identification: Option<String>,
        pub amount: Amount,
        pub creditor_account: CreditorAccountIdentifier,
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub creditor_agent_bic: Option<String>,
        pub creditor_name: String,
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub creditor_address: Option<CreditorAddress>,
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub remittance: Option<String>,
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub charge_bearer: Option<ChargeBearer>,
    }

    impl TransferDetails {
        pub fn new(
            amount: Amount,
            creditor_account: CreditorAccountIdentifier,
            creditor_name: impl Into<String>,
        ) -> Self {
            Self {
                end_to_end_identification: None,
                amount,
                creditor_account,
                creditor_agent_bic: None,
                creditor_name: creditor_name.into(),
                creditor_address: None,
                remittance: None,
                charge_bearer: None,
            }
        }
    }

    #[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Default, Debug)]
    #[serde(rename_all = "camelCase")]
    #[non_exhaustive]
    #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
    pub struct Transfer {
        #[serde(skip_serializing_if = "Option::is_none")]
        #[cfg_attr(feature = "uniffi", uniffi(default))]
        pub status: Option<PaymentStatus>,
    }
}

#[cfg(test)]
mod tests {
    use std::fmt::Debug;

    use jsonwebtoken::{Algorithm, EncodingKey, Header, encode};
    use serde::{Deserialize, Serialize};
    use serde_json::json;
    use uuid::Uuid;

    use crate::{
        Authenticated, Claims, ConfirmationContext, ConfirmationData, Dialog, DialogInput,
        InputContext, OBResult, Redirect, RedirectHandle, ResponseData, ServiceId, Session, Ticket,
    };

    #[test]
    fn read_response() {
        let serialized = serde_json::to_string(
            &encode(
                &Header::new(Algorithm::HS256),
                &Claims {
                    data: "data",
                    exp: 2_540_808_000,
                },
                &EncodingKey::from_secret(b"does_not_matter"),
            )
            .unwrap(),
        )
        .unwrap();

        let response = serde_json::from_str::<Authenticated<String>>(&serialized).unwrap();

        assert_eq!(&super::decode::<String>(&response.jwt).unwrap(), "data");
    }

    struct Service;

    impl crate::Service for Service {
        const ID: ServiceId = ServiceId::Accounts;

        type TicketData = ();

        type RequestData = ();

        type Output = ();
    }

    #[allow(
        dead_code,
        unconditional_recursion,
        clippy::extra_unused_type_parameters
    )]
    fn test_bounds<T: Serialize + for<'de> Deserialize<'de> + Clone + Eq + PartialEq + Debug>() {
        test_bounds::<InputContext<Service>>();
        test_bounds::<ConfirmationContext<Service>>();
        test_bounds::<DialogInput<Service>>();
        test_bounds::<Dialog<Service>>();
        test_bounds::<Redirect<Service>>();
        test_bounds::<RedirectHandle<Service>>();
        test_bounds::<OBResult<()>>();
        test_bounds::<Session>();

        test_bounds::<Authenticated<Ticket<Service>>>();
        test_bounds::<Ticket<Service>>();
        test_bounds::<ResponseData<Service>>();
        test_bounds::<ConfirmationData<Service>>();
    }

    fn test_eq_<T: PartialEq + Debug>(o: &T) {
        assert!(o.eq(o));
    }

    #[test]
    fn test_eq() {
        let ic = InputContext::<Service>::from(vec![]);
        let cc = ConfirmationContext::<Service>::from(vec![]);

        test_eq_(&ic);
        test_eq_(&cc);
        test_eq_(&Redirect {
            url: "url:".parse().unwrap(),
            context: cc.clone(),
        });
        test_eq_(&RedirectHandle {
            handle: String::new(),
            context: cc.clone(),
        });
        test_eq_(&Ticket::<Service> {
            service: ServiceId::Accounts,
            id: Uuid::new_v4(),
            data: (),
        });
        test_eq_(&ResponseData {
            context: ic,
            response: String::new(),
        });
        test_eq_(&ConfirmationData { context: cc });
    }

    #[test]
    fn no_ticket_data() {
        assert!(
            serde_json::from_value::<Ticket<Service>>(json!({
            "id": Uuid::new_v4(),
            "service": ServiceId::Accounts,
            }))
            .is_ok()
        );
    }

    #[test]
    fn missing_ticket_data() {
        let err = serde_json::from_value::<Ticket<super::collect_payment::Service>>(json!({
            "id": Uuid::new_v4(),
            "service": ServiceId::CollectPayment,
        }))
        .unwrap_err();

        assert_eq!(err.to_string(), "missing field `data`");
    }

    #[test]
    fn user_in_session_wire() {
        use super::UserInSession;

        let at = UserInSession::At("203.0.113.7".parse().unwrap());
        assert_eq!(
            serde_json::to_value(UserInSession::OnThisConnection).unwrap(),
            json!("connection")
        );
        assert_eq!(serde_json::to_value(&at).unwrap(), json!("203.0.113.7"));

        assert_eq!(
            serde_json::from_value::<UserInSession>(json!("connection")).unwrap(),
            UserInSession::OnThisConnection,
        );
        assert_eq!(
            serde_json::from_value::<UserInSession>(json!("203.0.113.7")).unwrap(),
            at
        );

        assert!(serde_json::from_value::<UserInSession>(json!("nonsense")).is_err());
    }
}